diff --git a/tests/data/wpd19_10000.w2vinput b/tests/data/wpd19_10000.w2vinput
index f1ab5ea..0b75f68 100644
--- a/tests/data/wpd19_10000.w2vinput
+++ b/tests/data/wpd19_10000.w2vinput
@@ -1,2127 +1,1310 @@
-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
+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 1968 bis 2000 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 1968 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 1997 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 1990er 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 .
+2007 sendete die ARD am 8. und 9. 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 N. Y. ) Stuart Rosenberg ( für Let ’ s 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 2008 wird als Art Director des Spiels Alan Smithee genannt .
+2014 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 2001 , ISBN 0-8166-3534-X . Weblinks Artikel über Smithee von ABC Online ( englisch ) Der Mann , der niemals lebte , Spiegel Online einestages Alan Smithee lebt ! , DRadio Wissen Einzelnachweise latimes.com : , zuletzt geprüft am 2. April 2011 Eigener Eintrag für in der IMDb in der Internet Movie Database Siehe zu diesen Regelungen Artikel 8 , Abschnitt 8-211 des ( PDF ; 125 kB ) der DGA von 2008 , abgerufen am 25. April 2012 http://einestages.spiegel.de/external/ShowTopicAlbumBackground/a13641/l26/l0/F.html#featuredEntry Alan Smithee ist schuld ! in Frankfurter Allgemeine Sonntagszeitung vom 17. August 2014 , Seite 36 
+
+Actinium ist ein radioaktives chemisches Element mit dem Elementsymbol Ac und der Ordnungszahl 89. Im Periodensystem der Elemente steht es in der 3. IUPAC-Gruppe , der Scandiumgruppe .
+Das Element ist ein Metall und gehört zur 7. Periode , d-Block .
+Es ist der Namensgeber der Gruppe der Actinoide , der ihm folgenden 14 Elemente .
+Geschichte Datei :P eriodensystem Mendelejews.jpg
+Das Actinium wurde im Jahr 1899 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 1902 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 1904 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 1971 und später im Jahr 2000 immer noch als fraglich beschrieben .
+Sie zeigen , dass die Publikationen von 1904 einerseits und die von 1899 und 1900 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 227Ac durch Bestrahlung von 226Ra 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 1945 , 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 Ac3 + - Ion ist farblos .
+Das chemische Verhalten von Actinium ähnelt sehr dem Lanthan .
+Actinium ist in allen zehn bekannten Verbindungen dreiwertig .
+Isotope Bekannt sind 26 Isotope , wovon nur zwei natürlich vorkommen .
+Das langlebigste Isotop 227Ac ( Halbwertszeit 21,8 Jahre ) hat zwei Zerfallskanäle : es ist ein Alpha- und Beta-Strahler .
+227Ac ist ein Zerfallsprodukt des Uranisotops 235U und kommt zu einem kleinen Teil in Uranerzen vor .
+Daraus lassen sich wägbare Mengen 227Ac 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 227Ac geht der größte Teil unter Emission von Beta-Teilchen in das Thorium isotop 227Th , aber ca. 1 % zerfällt durch Alpha-Emission zu Francium 223Fr .
+Eine Lösung von 227Ac ist daher als Quelle für das kurzlebige 223Fr 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 AcPO4 sind sie alle den entsprechenden Lanthanverbindungen ähnlich und enthalten Actinium in der Oxidationsstufe + 3. Insbesondere unterscheiden sich die Gitterkonstanten der jeweiligen Lanthan- und Actinium-Verbindungen nur in wenigen Prozent .
+Oxide Actinium ( III ) - oxid ( Ac2O3 ) kann durch Erhitzen des Hydroxids bei 500 ° C oder des Oxalats bei 1100 ° C im Vakuum erhalten werden .
+Das Kristallgitter ist isotyp mit den Oxiden der meisten dreiwertigen Seltenerdmetalle .
+Halogenide Actinium ( III ) - fluorid ( AcF3 ) kann entweder in Lösung oder durch Feststoffreaktion dargestellt werden .
+Im ersten Fall gibt man bei Raumtemperatur Flusssäure zu einer Ac3 + - Lösung und fällt das Produkt aus .
+im anderen Fall wird Actinium-Metall mit Fluorwasserstoff bei 700 ° C in einer Platinapparatur behandelt .
+Actinium ( III ) - chlorid ( AcCl3 ) wird durch Umsetzung von Actiniumhydroxid oder - oxalat mit Tetrachlormethan bei Temperaturen oberhalb von 960 ° C erhalten .
+Die Reaktion von Aluminiumbromid und Actinium ( III ) - oxid führt zum Actinium ( III ) - bromid ( AcBr3 ) und Behandlung mit feuchtem Ammoniak bei 500 ° C führt zum Oxibromid AcOBr .
+Weitere Verbindungen Gibt man Natriumdihydrogenphosphat ( NaH2PO4 ) zu einer Lösung von Actinium in Salzsäure , erhält man weiß gefärbtes Actiniumphosphat ( AcPO4 · 0,5 H2O ) ; ein Erhitzen von Actinium ( III ) - oxalat mit Schwefelwasserstoff bei 1400 ° C für ein paar Minuten führt zu schwarzem Actinium ( III ) - sulfid ( Ac2S3 ) .
+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 2006 ; ISBN 1-4020-3555-1 , S. 18–51 ( doi : 10.1007/1-4020-3598-5_2 ) .
+Weblinks Einzelnachweise André-Louis Debierne : „ Sur une nouvelle matière radio-active “ , in : Comptes rendus , 1899 , 129 , S. 593–595 ( ) . André-Louis Debierne : „ Sur un nouvel élément radio-actif : l ’ actinium “ , in : Comptes rendus , 1900 , 130 , S. 906–908 ( ) . N. A. Figurowski , Die Entdeckung der chemischen Elemente und der Ursprung ihrer Namen , in deutscher Übersetzung von Leo Korniljew / Ernst Lemke , Moskau 1981 , ISBN 3-7614-0561-8 , S. 64.Friedrich Oskar Giesel : „ Ueber Radium und radioactive Stoffe “ , in : Berichte der Deutschen Chemischen Gesellschaft , 1902 , 35 ( 3 ) , S. 3608–3611 ( doi : 10.1002/cber.190203503187 ) . Friedrich Oskar Giesel : „ Ueber den Emanationskörper ( Emanium ) “ , in : Berichte der Deutschen Chemischen Gesellschaft , 1904 , 37 ( 2 ) , S. 1696–1699 ( doi : 10.1002/cber.19040370280 ) . Friedrich Oskar Giesel : „ Ueber Emanium “ , in : Berichte der Deutschen Chemischen Gesellschaft , 1905 , 38 ( 1 ) , S. 775–778 ( doi : 10.1002/cber.190503801130 ) . H. W. Kirby : „ The Discovery of Actinium “ , in : Isis , 1971 , 62 ( 3 ) , S. 290–308 ( ) . J. P. Adloff : „ The centenary of a controversial discovery : actinium “ , in : Radiochim . Acta , 2000 , 88 , S. 123 ( doi : 10.1524/ract.2000.88.3-4.123 ) . Frederick Seitz , David Turnbull : Solid state physics : advances in research and applications , Academic Press , 1964 , ISBN 0-12-607716-9 , S. 289–291 ( ) . Glenn T. Seaborg : „ The Transuranium Elements “ , in : Science , 1946 , 104 , Nr. 2704 , S. 379–386 ( doi : 10.1126/science.104.2704.379 ; PMID 17842184 ) . Joseph G. Stites , Murrell L. Salutsky , Bob D. Stone : „ Preparation of Actinium Metal “ , in : J. Am . Chem. Soc . , 1955 , 77 ( 1 ) , S. 237–240 ( doi : 10.1021/ja01606a085 ) . J. J. Katz , W. M. Manning : „ Chemistry of the Actinide Elements “ , in : Annual Review of Nuclear Science , 1952 , 1 , S. 245–262 ( doi : 10.1146/annurev . ns.01.120152.001333 ) . Sherman Fried , French Hagemann , W. H. Zachariasen : „ The Preparation and Identification of Some Pure Actinium Compounds “ , in : J. Am . Chem. Soc . , 1950 , 72 , S. 771–775 ( doi : 10.1021/ja01158a034 ) . 
+
+Datei : Ang Lee - 66eme Festival de Venise ( Mostra ) 2.jpg Ang Lee ( ; * 23. Oktober 1954 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 ( 2005 ) und Life of Pi : Schiffbruch mit Tiger ( 2012 ) wurde er jeweils mit dem Oscar in der Kategorie Beste Regie ausgezeichnet .
+Leben Ang Lee wurde 1954 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 1978 in die USA , um an der Universität von Illinois in Urbana-Champaign Theaterwissenschaft und - regie zu studieren .
+Nach dem Erwerb seines B. A. in Illinois verlegte er sich ganz auf das Studium der Film- und Theaterproduktion an der Universität von New York , das er 1985 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-8-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 1992 , 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 2006 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 1983 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 ( * 1984 ) und Mason ( * 1990 ) .
+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 1985 zwei Preise beim renommierten Filmfest seiner Universität . Erst 1992 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 .
+1992–1994 : 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 ( 1992 ) , 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 2005 hat Squires jeden Film , den Ang Lee gedreht hat , geschnitten .
+Nach dem Erfolg seines Erstlings konnte Lee als Nächstes Das Hochzeitsbankett ( 1993 ) 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 1993 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 1993 .
+Mit nur einer Million US-Dollar Produktionskosten erzielte er ein Einspielergebnis von über 23 Millionen US-Dollar .
+Sihung Lung ist auch im letzten Teil der Trilogie , Eat Drink Man Woman ( 1994 ) , 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 .
+1995–1999 : 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 1970er Jahre ; Ride with the Devil ist im Amerikanischen Bürgerkrieg angesiedelt .
+2000–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 2001 auch mit einem Chlotrudis Award ausgezeichnet , seinen zweiten Chlotrudis erhielt er 2006 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 .
+2007 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 2007 im offiziellen Wettbewerb der 64. 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 2008 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 2009 wurde bekannt gegeben , dass Lee die Jury der 66. Filmfestspiele von Venedig leiten werde . Zwei Monate später erhielt er für seine Komödie Taking Woodstock eine Einladung in den Wettbewerb der 62. Internationalen Filmfestspiele von Cannes .
+2013 wurde er in die Wettbewerbsjury des 66. 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 Datei : Ang Lee 66ème Festival de Venise ( Mostra ) . jpg
+1992 : Schiebende Hände ( Pushing Hands , Tui shou )
+1993 : Das Hochzeitsbankett ( The Wedding Banquet , Xi yan )
+1994 : Eat Drink Man Woman ( Yin shi nan nu )
+1995 : Sinn und Sinnlichkeit ( Sense and Sensibility )
+1997 : Der Eissturm ( The Icestorm )
+1999 : Wer mit dem Teufel reitet ( Ride with the Devil )
+2000 : Tiger and Dragon ( auch : Crouching Tiger , Hidden Dragon , Wo hu cang long )
+2001 : The Hire : Chosen ( Kurzwerbefilm für eine Automarke ) 2003 : Hulk
+2005 : Brokeback Mountain
+2007 : Gefahr und Begierde ( Sè , jiè )
+2009 : Taking Woodstock
+2012 : Life of Pi : Schiffbruch mit Tiger
+2016 : Die irre Heldentour des Billy Lynn ( Billy Lynn ’ s Long Halftime Walk )
+2019 : Gemini Man
+Auszeichnungen ( Auswahl ) Oscarverleihung
+2001 : Auszeichnung in der Kategorie Bester fremdsprachiger Film für Tiger & Dragon
+2001 : Nominierung in der Kategorie Beste Regie für Tiger & Dragon
+2001 : Nominierung in der Kategorie Bester Film für Tiger & Dragon
+2006 : Auszeichnung in der Kategorie Beste Regie für Brokeback Mountain
+2013 : Auszeichnung in der Kategorie Beste Regie für Life of Pi : Schiffbruch mit Tiger
+2013 : 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
+1996 : Nominierung in der Kategorie Beste Regie für Sinn und Sinnlichkeit
+2001 : Auszeichnung in der Kategorie Beste Regie für Tiger & Dragon
+2006 : Auszeichnung in der Kategorie Beste Regie für Brokeback Mountain
+2013 : 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
+1996 : Nominierung in der Kategorie Beste Spielfilmregie für Sinn und Sinnlichkeit
+2001 : Auszeichnung in der Kategorie Beste Spielfilmregie für Tiger & Dragon
+2006 : Auszeichnung in der Kategorie Beste Spielfilmregie für Brokeback Mountain
+2013 : Nominierung in der Kategorie Beste Spielfilmregie für Life of Pi : Schiffbruch mit Tiger
+Weitere Auszeichnungen 1993 : Goldener Bär der Berliner Filmfestspiele für Das Hochzeitsbankett
+1993 : Golden Horse Beste Regie für Das Hochzeitsbankett
+1996 : Goldener Bär der Berliner Filmfestspiele für Sinn und Sinnlichkeit
+1997 : Bundesfilmpreis für den besten ausländischen Film mit Sinn und Sinnlichkeit
+2000 : Golden Horse Bester Film für Tiger and Dragon
+2001 : Hong Kong Film Award für Tiger and Dragon
+2002 : Aufnahme in die American Academy of Arts and Sciences
+2005 : Goldener Löwe des Filmfestivals in Venedig für Brokeback Mountain
+2007 : Golden Horse Beste Regie für Gefahr und Begierde
+2007 : 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
+Literatur Tanja Hanhart ( Redaktorin ) : Ang Lee und sein Kino .
+Poesie im Grossformat .
+In : du 796 ( Feb .
+2006 ) , ISBN 978-3-03717-021-2 . Thomas Koebner : [ Artikel ] Ang Lee . In : Ders .
+( Hrsg. ) : Filmregisseure .
+Biographien , Werkbeschreibungen , Filmographien .
+Mit 109 Abbildungen .
+3. , aktualisierte und erweiterte Auflage .
+Reclam , Stuttgart 2008 [ 1. Aufl. 1999 ] , ISBN 978-3-15-010662-4 , S. 429–433 . Qin Hu : Das Kino von Ang Lee – Von der chinesischen Philosophie , Kunstauffassung und Kultur zu filmästhetischen Aspekten . Gardez !
+Verlag , 2008 . Michael Pekler , Andreas Ungerböck : Ang Lee und seine Filme . Schüren , Marburg 2009 , ISBN 978-3-89472-665-2 . Isabell Gössele : Das Kino des Ang Lee – Im Atem des verborgenen Drachen . Tectum , Marburg 2009 , ISBN 978-3-8288-2046-3 . Weblinks Biografie auf film-zeit.de Ang Lee Biografie bei WHO ’ S WHO In : Spiegel Online , 17. Oktober 2007 , Interview Der Subtext des Western , Interview auf critic.de Ralph Geisenhanslüke : In : Zeit , 1. Januar 2013 , Interview Andreas Kilb : In : FAZ , 23. Oktober 2014 Einzelnachweise Michael Pekler , Andreas Ungerböck : Ang Lee und seine Filme . Schüren , Marburg 2009 . Christoph Schneider : Chronik von Leben und Werk . In : Ang Lee und sein Kino . Poesie im Grossformat . In : du 796 ( Feb . 2006 ) , S. 64–70 . 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 2009 , S. 17. 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 , 2009 , S. 72.Pekler , Ungerböck 2009 , S. 19. Christoph Schneider : Chronik von Leben und Werk . In : Ang Lee und sein Kino . Poesie im Grossformat . In : du 796 ( Feb . 2006 ) , S. 65.Pekler , Ungerböck 2009 , S. 135 f. Douglas Tseng : Shorter version of Lust to be shown here . In : The Straits Times ( Singapore ) , 26. September 2007 , LIFE ! – LIFE BUZZ In : fr-online , 28. Februar 2009 , abgerufen am 12. Juni 2019 Schiffbruch mit Zuschauer in FAZ , 24. Dezember 2012 , S. 25. 
+
+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 zahlen / nicht 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 ( 1966 , gedruckt 1967 ) 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 1987 , ISBN 3-518-28266-2 . Jürgen Frese : Sprechen als Metapher für Handeln . In : Hans-Georg Gadamer : Das Problem der Sprache .
+Achter Deutscher Kongress für Philosophie .
+Heidelberg 1966 , Fink Verlag , München 1967 , S. 45–55 . Jürgen Frese : Prozesse im Handlungsfeld . Klaus Boer Verlag , München 1985 , ISBN 3-924963-06-1 . Einzelnachweise Frese 1967 , S. 50f.Frese , 1985 
+
+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 1847 mit seinem algebraischen Logikkalkül .
+Den ersten aussagenlogischen Kalkül mit Schlussregeln formulierte Gottlob Frege im Rahmen seiner Begriffsschrift 1879 .
+Er war die Vorlage für den Aussagenkalkül von Bertrand Russell 1908 , 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 , 1 ) oder nicht wahr ( f , falsch , false , 0 ) 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 781 km von Hamburg entfernt .
+: 9 ist durch 3 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 781 km von Hamburg entfernt ist .
+: Es ist nicht der Fall , dass 9 durch 3 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 : 9 ist durch 3 teilbar B : 9 ist eine Quadratzahl
+Diese Teilaussagen und ihre Negationen werden nun durch miteinander verknüpft : : 9 ist durch 3 teilbar und 9 ist eine Quadratzahl .
+: 9 ist nicht durch 3 teilbar und 9 ist eine Quadratzahl .
+: 9 ist durch 3 teilbar und 9 ist keine Quadratzahl .
+: 9 ist nicht durch 3 teilbar und 9 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 und / oder 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 : 9 ist durch 3 teilbar B : 9 ist eine Quadratzahl Diese Teilaussagen und ihre Negationen werden nun durch miteinander verknüpft : : 9 ist durch 3 teilbar oder 9 ist eine Quadratzahl .
+: 9 ist nicht durch 3 teilbar oder 9 ist eine Quadratzahl .
+: 9 ist durch 3 teilbar oder 9 ist keine Quadratzahl .
+: 9 ist nicht durch 3 teilbar oder 9 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 6 teilbar ist , dann ist die Zahl n durch 3 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 3 teilbar ist , dann ist n nicht durch 6 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 6 teilbar , also ist n auch nicht durch 3 teilbar . Auch diese Folgerung ist falsch .
+Die Zahl 15 ist nicht durch 6 teilbar und sehr wohl durch 3.
+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 6 teilbar , wenn n durch 2 und durch 3 teilbar ist . Wenn n durch 6 teilbar ist , dann folgt daraus , dass n durch 2 und durch 3 teilbar ist .
+Umgekehrt gilt aber auch : Wenn n durch 2 und durch 3 teilbar ist , dann ist n durch 6 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 A ∧ B 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 1931 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 P0 , P1 , P2 , … 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 0 } ( N 0 : Menge der natürlichen Zahlen inkl. 0 ) , d. h.
+V = { P0 , P1 , P2 , P3 , … } 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 Formel . ( Diese Formel heißt Negation von F. ) Sind F und G zwei ( nicht notwendigerweise unterschiedliche ) Formeln , so ist auch ( F ∧ G ) eine Formel . ( Diese Formel heißt Konjunktion von F und G. ) Sind F und G zwei ( nicht notwendigerweise unterschiedliche ) Formeln , so ist auch ( F ∨ G ) eine Formel . ( Diese Formel heißt Disjunktion von F und G. ) Sind F und G zwei ( nicht notwendigerweise unterschiedliche ) Formeln , so ist auch ( F → G ) eine Formel . ( Diese 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 Formel . ( Diese 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 1908 , den er 1910 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 1879 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 P0 wahr ist , dass P1 falsch ist und dass P2 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 Leibniz ’ sche 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 V ( X) = wahr ist ( das heißt V ( X ∧ W )= V ( X)) . 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 : VArithmetik ( X+Y )= VArithmetik ( X) , wenn VArithmetik ( Y ) = 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 : V ( X ∨ F ) = V ( X) , wenn V ( F )= falsch 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
+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
+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 P0 ∧ ¬ P0 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 und / oder 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 wahr / falsch 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 1. Februar 1870 aus genau 6.120.375,4 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. 23 ) .
+2. Auflage , revised and expanded .
+Center for the Study of Language and Information , Stanford CA 1991 , ISBN 0-937073-74-1 . Ansgar Beckermann : Einführung in die Logik . 2. , neu bearbeitete und erweiterte Auflage .
+de Gruyter , Berlin u. a. 2003 , ISBN 3-11-017965-2 . Karel Berka , Lothar Kreiser : Logik-Texte .
+Kommentierte Auswahl zur Geschichte der modernen Logik .
+4. , gegenüber der 3. , erweiterte , durchgesehene Auflage .
+Akademie-Verlag , Berlin 1986 . Wolfgang Detel : Grundkurs Philosophie . Band 1 : Logik ( = Universal-Bibliothek . Nr. 18468 ) .
+Reclam , Stuttgart 2007 , ISBN 978-3-15-018468-4 . Wilfrid Hodges : Logic . Penguin Books , Harmondsworth 1977 , ISBN 0-14-021985-4 ( 2. Auflage .
+ebenda 2001 ISBN 0-14-100314-6 ) .
+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
+( = Eagle . Bd. 2 ) .
+Edition am Gutenbergplatz , Leipzig 2003 , ISBN 3-937219-02-1 . E. J. Lemmon : Beginning Logic . Nelson , London 1965 ( 2. Auflage .
+Chapman & Hall , London 1987 , ISBN 0-412-38090-0 ) .
+Wesley C. Salmon : Logik . ( = Universal-Bibliothek . Nr. 7996 ) .
+Reclam Stuttgart 1983 , ISBN 3-15-007996-9 . Weblinks Vorlesungsmitschnitt Mathematik I Uni Tübingen .
+Die ersten zwei Stunden handeln ausführlich von Wahrheitstabellen .
+Christian Spannagel : Aussagen- und Prädikatenlogik .
+Vorlesungsreihe , 2012 . Einzelnachweise Karl Dürr : Aussagenlogik im Mittelalter . In : Erkenntnis . Bd. 7 , Nr. 1 , 1937/1938 , , S. 160–168 , doi : 10.1007/BF00666521 . 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 § Symbole . E. Grädel ( 2009 ) S. 1 f Zur prädikatenlogischen Entsprechung siehe Prädikatenlogik erster Stufe § Terme.Vergleiche E. Grädel ( 2009 ) S. 2 Bertrand Russell : Mathematical logic as based on the theory of types . In : American Journal of Mathematics . 30 , 1908 , S. 246 ( 2 ) - ( 6 ) . ( PDF ; 1,9 MB ) = Principia Mathematica Band I , S. 12f . 
+
+Anthony Minghella , CBE ( * 6. Januar 1954 auf der Isle of Wight , Großbritannien ; † 18. März 2008 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 .
+1978 drehte er einen ersten Kurzfilm .
+Seit 1981 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 1988 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 2008 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 : 2006 wurde sein Hörspiel Eyes Down Looking mit Jude Law zu Ehren von Samuel Beckett auf BBC Radio 3 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 ( 2007 ) 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 54 Jahren in einem Londoner Krankenhaus an inneren Blutungen infolge der Operation eines Tonsillen karzinoms und eines Karzinoms im Nacken .
+Auszeichnungen 1984 erhielt Minghella den Londoner Kritikerpreis als meistversprechender junger Dramatiker , 1986 den Kritikerpreis für sein Stück Made in Bangkok als bestes Stück der Saison .
+1997 erhielt er für Der englische Patient den Oscar in der Rubrik Beste Regie , 1999 eine Oscar-Nominierung in der Kategorie „ Bestes adaptiertes Drehbuch “ für Der talentierte Mr. Ripley , bei dem er auch Regie führte .
+2001 wurde Minghella zum Commander of the British Empire ( CBE ) ernannt .
+Von 2003 bis 2007 war er Präsident des British Film Institute .
+Seit 1997 trägt das Anthony Minghella Theatre auf der Isle of Wight seinen Namen .
+Filmografie als Regisseur ( Auswahl )
+1991 : Wie verrückt und aus tiefstem Herzen ( Truly Madly Deeply )
+1993 : 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
+1996 : Der englische Patient ( The English Patient ) 1999 : Der talentierte Mr. Ripley ( The Talented Mr. Ripley ) 2003 : Unterwegs nach Cold Mountain ( Cold Mountain ) 2006 : Breaking and Entering – Einbruch &amp; Diebstahl ( Breaking and Entering ) 2009 : New York , I Love You ( Szene ) Weblinks , BBC , 18. März 2008 ( englisch ) 
+
+Image : 180 degree rule.svgDiese Illustration zeigt die Achse zwischen den beiden Personen und den 180 ° - Bogen , auf dem Kameras platziert werden können ( grün ) .
+Wenn 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 180-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 
+
+Datei : Alfred Hitchcock by Jack Mitchell.jpg Sir Alfred Joseph Hitchcock KBE ( * 13. August 1899 in Leytonstone , England ; † 29. April 1980 in Los Angeles , Kalifornien ) war ein britischer Filmregisseur , Drehbuchautor , Filmproduzent und Filmeditor .
+Er siedelte 1939 in die USA über und nahm am 20. April 1955 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 53 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 3. Januar 1980 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 ( 1862–1914 ) und dessen Ehefrau Emma Jane Whelan ( 1863–1942 ) . 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 1910 und 1913 war er Schüler des St. - Ignatius-College , einer Londoner Jesuiten-Schule . Er verließ das College mit knapp 14 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 1914 , zu dem er kein enges Verhältnis hatte , band Hitchcock noch enger an seine Mutter .
+1915 nahm er eine Stelle als technischer Angestellter bei der W. T.
 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
+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 1920 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 1921 und 1922 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 .
+1922 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 13 ( 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 1924 schließlich erwarb .
+Er stellte Hitchcock als Regieassistent ein , sowie ( auf dessen Empfehlung ) die Filmeditorin Alma Reville .
+Die beiden kannten sich seit 1921 , seitdem sie gelegentlich an denselben Filmen gearbeitet hatten .
+Bis 1925 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 1924/25 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 1925 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 ( 1925 ) 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 1925 beziehungsweise 1926 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 1926 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 1927 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 1927 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 Farmer ’ s 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 1926 heirateten Alfred Hitchcock und Alma Reville , die für die Hochzeit zum katholischen Glauben konvertierte .
+1928 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 ( 1929 ) 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 ( 1930 ) 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 Camber ’ s 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 ( 1934 ) .
+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 39 Stufen ( 1935 , 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 ( 1936 ) und Sabotage ( 1936 ) , 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 ( 1937 ) war eine weitere , unbeschwerte Variation der Geschichte vom unschuldig Verfolgten .
+Der gefeierte Thriller Eine Dame verschwindet ( 1938 ) 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 1930er 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 1938 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 1940 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 ( 1941 , RKO ) , der ersten Zusammenarbeit mit Cary Grant , und Saboteure ( 1942 , 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
+( 1941 , RKO ) nicht zufrieden .
+Weit mehr am Herzen lag ihm die Arbeit an dem Drama Im Schatten des Zweifels ( 1943 , 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 ( 1943 , 20th 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 ( 1945 ) , 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 ( 1946 ) 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 ( 1947 ) 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 Datei : Alfred Hitchcock NYWTS.jpg Bereits im April 1946 , 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 ( 1948 ) 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 ( 1949 ) , 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 1944 gestorben war , wurden Hitchcocks Interessen von mehreren anderen Personen wahrgenommen , bevor er 1948 mit Lew Wasserman zusammentraf .
+Wasserman war seit 1946 Präsident der weltgrößten Künstleragentur Music Corporation of America ( MCA ) , der sich Hitchcock 1948 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 ( 1950 ) 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 1950 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 20 Jahre beibehalten .
+Der Fremde im Zug ( 1951 , 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 .
+1952 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 1950er Jahre das Fernsehen Einzug in die Wohnzimmer hielt , versuchte die Kinoindustrie , mit neuen technischen Verfahren wie dem Breitbildformat Cinemascope oder dem 3D-Verfahren den Zuschauerschwund aufzuhalten .
+So drängte Warner Bros .
+Hitchcock , seinen nächsten Film in 3D 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 3-D-Effekte ein .
+Bei Anruf Mord ( 1954 ) 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 3D-Verfahren zeigte Hitchcock die Grenzen bei Warner Brothers .
+Er schloss daher 1953 einen Vertrag mit Paramount ab , der ihm völlige künstlerische Freiheit garantierte .
+1954 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 ( 1955 ) 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 d ’ Azur 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 .
+1955 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 ( 1956 ) , dem einzigen Remake eines seiner Filme in seiner Karriere .
+Ebenfalls 1955 startete die wöchentliche Fernsehserie Alfred Hitchcock Presents ( ab 1962 The Alfred Hitchcock Hour ) .
+Hitchcock war Produzent , trat in vielen Folgen als Moderator auf und inszenierte insgesamt 18 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 1956 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 1957 drehte Hitchcock seinen letzten Film für Paramount : Vertigo – Aus dem Reich der Toten ( 1958 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 ( 1959 , 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 ( 1960 ) 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 1961 in Angriff : Die Vögel ( 1963 ) , 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 1960er 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 ( 1964 ) 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 R. R. R. R. , 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 7. März 1965 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 ( 1966 ) kehrte Hitchcock schließlich zum Genre des Spionagefilms zurück , in dem er bereits in den 1930er Jahren in England große Erfolge gefeiert hatte .
+Die Premiere dieses 50. 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 1968 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 51. Film , aber wann ich meinen letzten Film drehen werde , ist von mir , meinen Finanziers und Gott noch nicht entschieden worden . “
+Im Spätsommer 1970 nahm Hitchcock sein nächstes Projekt in Angriff und reiste dafür wieder in seine Heimat , wo er diesmal begeistert empfangen wurde .
+Frenzy ( 1972 ) 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 1973 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 1976 überwiegend freundlich aufgenommen , und Hitchcock schöpfte aus der Sympathie , die ihm entgegenschlug , für kurze Zeit Kraft , neue Filmideen aufzugreifen .
+Sein erst Anfang 1978 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 1979 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 3. Januar 1980 wurde Hitchcock in den britischen Adelsstand erhoben .
+Am Morgen des 29. April 1980 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 , 1929 ) 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 1940er 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 ( 1946 ) , die ihren Sohn zum Mord an der Frau , die er liebt , antreibt .
+Der extremste Fall tritt in Psycho ( 1960 ) 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 ( 1963 ) 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 ( 1964 ) 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 ( 1927 ) bis Frenzy ( 1972 ) .
+Darüber hinaus finden sich vereinzelt Geheimdienstmitarbeiter unter den Nebenfiguren , die sich als Gegner ( das Ehepaar Drayton in Der Mann , der zuviel wußte , 1956 ) 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 [ 1956 ] 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 „ 39 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 1956 .
+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 1929 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 ( 1948 ) 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 ( 1963 ) 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 ! ( 1930 ) 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 ( 1936 , der Dauerakkord des toten Organisten in der Kirche ) , Eine Dame verschwindet ( 1938 , die Melodie mit dem Geheimcode und der „ Volkstanz “ ) , Im Schatten des Zweifels ( 1943 , der „ Merry-Widow “ - Walzer ) , Der Fremde im Zug ( 1951 , die Szenen auf dem Rummelplatz ) und Das Fenster zum Hof ( 1954 , die im Laufe des Films entstehende Komposition des Klavierspielers ) .
+In Der Mann , der zuviel wußte ( 1956 ) 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 1950er und frühen 1960er 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 1930er 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 1922 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 1919 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 ( 1925 ) des sowjetischen Regisseurs Eisenstein angesehen werden .
+In Die 39 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 1940er und 1950er 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 1920er 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 1969 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 1930er und 1940er 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 1942 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 1934 und 1967 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 1940er 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 1932 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 1948 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 1999 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 1951 und 1964 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 35 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 ( 1964 ) alle Filmmusiken für Hitchcock komponierte .
+Der Filmeditor George Tomasini war bis zu seinem Tod 1964 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 1927 führte Hitchcock ein stilisiertes Selbstporträt als Logo , das bis heute bekannt ist . Anfang der 1930er 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 .
+1962 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 ) FilmAuftritt / RolleFilmAuftritt / RolleDer 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 3 bzw. 66 min. ) . Easy VirtueMit einem Gehstock hinter einem Tennisplatz ( nach 15 min. ) . ErpressungLiest in der U-Bahn eine Zeitung und wird dabei von einem Jungen gestört , der ihm den Hut über die Ohren zieht ( nach 11 min. ) . Mord – Sir John greift ein !
+Geht im Gespräch mit einer Frau an dem Haus vorbei , in dem der Mord stattfand ( nach 60 min. ) . Der Mann , der zuviel wußte von 1934Überquert die Straße in einem Regenmantel ( nach 33 min. ) . Die 39 StufenGeht über den Gehsteig und wirft eine Kaugummipackung weg , während Robert Donat und Lucie Mannheim fluchtartig das Theater verlassen ( nach 6 min. ) . SabotageGeht an einem Kino vorbei ( nach 9 min. ) . Jung und unschuldigVor dem Gerichtsgebäude mit einer Kamera in der Hand ( nach 15 min. ) . Eine Dame verschwindetIn der Londoner Victoria Station geht er mit dunklem Mantel und einer Zigarette hastig auf den Bahnsteig ( nach 90 min. ) . RebeccaGeht hinter George Sanders vorbei , als dieser neben einer Telefonzelle mit einem Polizisten diskutiert ( nach 123 min. ) . Der AuslandskorrespondentMit Mantel , Hut und Tageszeitung , kurz nachdem Joel McCrea sein Hotel verlassen hat ( nach 11 min. ) . VerdachtAn einem Briefkasten ( nach 45 min. ) . Mr. und Mrs. SmithAuf der Straße geht er an Robert Montgomery vorbei ( nach 41 min. ) . SaboteureSteht links vor dem Schaufenster eines Drugstore , als das Auto des Saboteurs dort anhält ( nach 61 min. ) . Im Schatten des ZweifelsHat beim Kartenspiel im Zug nach Santa Rosa ein „ Full House “ ( nach 17 min. ) . Ich kämpfe um dichKommt aus dem Fahrstuhl im Hotel Empire mit einem Geigenkasten und einer Zigarette ( nach 36 min. ) . BerüchtigtAuf der Party in Rains Wohnung , trinkt Champagner in einem Zug leer und verschwindet dann ( nach 60 min. ) . Der Fall ParadinKommt an der Cumberland Station aus dem Zug mit einem Cellokasten in der Hand ( nach 36 min. ) . Cocktail 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 52 min. ) . Sklavin 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 3 bzw. 14 min. ) . Die rote LolaDreht sich nach Jane Wyman um , die sich gerade als Marlene Dietrichs Dienstmädchen verkleidet hat ( nach 38 min. ) . Der Fremde im ZugSteigt mit einem Kontrabass in einen Zug , als Farley Granger den Zug in Metcalf verlässt .
+( nach 10 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 44 min ) .
+Ich beichteGeht am oberen Rand an einer langen Treppe vorbei ( nach 2 min. ) . Das Fenster zum HofZieht im Apartment des Musikers eine Uhr auf ( nach 25 min. ) . Immer Ä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 21 min. ) . Über den Dächern von NizzaEr sitzt neben John Robie ( Cary Grant ) im Bus ( nach 10 min. ) . Der Mann , der zuviel wußte von 1956Mit dem Rücken zur Kamera auf dem Markt in Marrakesch , bei dem Akrobaten , kurz vor dem Mord ( nach 25 min. ) . Vertigo – 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 10 min. ) . Der unsichtbare DritteLäuft auf einen Bus zu , dessen Tür sich vor seiner Nase schließt ( nach 2 min. ) . PsychoEr steht , vom Inneren von Marions Büro aus sichtbar , auf der Straße und trägt einen Cowboyhut ( nach 6 min. ) . Die VögelVerlässt die Tierhandlung mit zwei weißen Terriern in dem Moment , in dem Tippi Hedren eintritt ( nach 2 min. ) . MarnieVerlässt ein Hotelzimmer und geht durch den Korridor ( nach 5 min. ) . Der zerrissene VorhangSitzt mit einem Baby auf dem Schoß im Hotelfoyer ( nach 8 min. ) . TopasAm La-Guardia-Flughafen in New York steht er aus einem Rollstuhl auf und begrüßt jemanden ( nach 28 min. ) . FrenzyAm 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 3 min. ) . FamiliengrabIn seinem letzten Film sieht man seine Silhouette hinter der Milchglasscheibe einer Türe mit der Aufschrift : „ Registratur für Geburten und Sterbefälle “ ( nach 38 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 1955 in das Fernsehgeschäft ein .
+Hitchcock gründete die Fernsehproduktionsfirma Shamley Productions und produzierte bis 1965 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 1966 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 d ’ une marionette ( Trauermarsch einer Marionette ) , das sich im Weiteren zu einer Erkennungsmelodie für Hitchcocks Öffentlichkeitsarbeit entwickelte .
+Bücher und Zeitschriften 1956 schloss Hitchcock einen Lizenzvertrag mit HSD Publications ab , der die Überlassung seines Namens für das Krimi-Magazin Alfred Hitchcock ’ s 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 1964 bis 1987 erschien in den USA die Jugend-Krimi-Reihe „ The Three Investigators “ , auf Deutsch seit 1968 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 1940er 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 1950er bis Anfang der 1960er 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 ( 1980 ) das Grundmotiv aus Psycho weiter und zitiert aus weiteren Hitchcock-Filmen .
+1976 lehnte sich Schwarzer Engel stark an Vertigo an .
+1984 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 ( 1975 ) in Spannungsaufbau und Dramaturgie an Die Vögel und ist die Filmreihe ( 1981–1989 ) stark von Der unsichtbare Dritte ( 1959 ) beeinflusst .
+Auch ein Film wie Schindlers Liste ( 1993 ) 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 16 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 1950er Jahre war Hitchcock insbesondere in Frankreich bei den Vertretern der Nouvelle Vague hoch angesehen .
+1957 veröffentlichten die damaligen Filmkritiker und späteren Regisseure Éric Rohmer und Claude Chabrol das erste Buch über ihn .
+1956 erschien ein Sonderheft der Cahiers du cinéma , das maßgeblich zu Hitchcocks Popularität in Frankreich beitrug .
+Als er im Mai 1960 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 1962 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 1966 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 ( 1968 ) oder Das Geheimnis der falschen Braut ( 1969 ) , 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 ( 1983 ) , 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 451 . 1968/69 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 ( 1959 ) , Das Auge des Bösen ( 1962 ) , Der Schlachter ( 1970 ) und Masken ( 1987 ) .
+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 ( 1943 ) , Der dritte Mann von Carol Reed ( 1949 ) , Zeugin der Anklage von Billy Wilder ( 1957 ) , Frantic von Roman Polański ( 1988 ) und Schatten der Vergangenheit von Kenneth Branagh ( 1991 ) .
+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 53 von Hitchcock selbst inszenierten Spielfilmen Uraufführung : für die Kinofilme nach der Internet Movie Database , für die Fernsehfilme nach Donald Spoto 1921–1925 ( Stummfilme ; in Schwarzweiß ) 1925–1939 ( bis einschließlich Nr. 9 Stummfilme , ab Nr. 10 Tonfilme ; alle Filme in Schwarzweiß ) 1940–1947 ( 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 1945 in London .
+Er hat dies später im Interview als seinen Beitrag zum Krieg bezeichnet .
+Der Film wurde nicht fertiggestellt .
+1948–1957 ( Filme Nr. 36 , 37 , 38 und 44 in Schwarzweiß , alle anderen in Farbe ) Zwischen 1955 und 1965 trat der Regisseur in insgesamt 360 Folgen der Fernsehserien Alfred Hitchcock Presents ( 267 Folgen ) und The Alfred Hitchcock Hour ( 93 Folgen ) in der Rolle des Gastgebers auf .
+1958–1964 ( Film Nr. 47 in Schwarzweiß , alle anderen in Farbe ) 1966–1976 ( alle Filme in Farbe ) Auszeichnungen Datei : Hitchcock walk of fame.jpg
+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 1968 gewann er den Irving G. Thalberg Memorial Award als Spezialoscar für besonders kreative Filmproduzenten .
+Zudem wurde Rebecca 1941 mit dem Oscar für den besten Film ausgezeichnet , den aber nicht Hitchcock , sondern der Produzent David O. Selznick entgegennehmen durfte .
+1939 : NYFCC Award als Bester Regisseur für Eine Dame verschwindet
+1941 : Oscar-Nominierung für Rebecca ( Beste Regie ) 1942 : Oscar-Nominierung für Verdacht ( Bester Film ) 1944 : Oscar-Nominierung für Das Rettungsboot ( Beste Regie ) 1945 : Oscar-Nominierung für Ich kämpfe um dich ( Beste Regie ) 1948 : Kinema Junpo Award für Verdacht als Bester Fremdsprachiger Film
+1950 : Preis beim Filmfestival von Locarno für Die rote Lola
+1954 : Oscar-Nominierung für Das Fenster zum Hof ( Beste Regie ) 1958 : Golden Globe für „ The best TV-Show : Alfred Hitchcock Presents “ 1958 : Zweiter Platz beim Laurel Award als Bester Regisseur
+1958 : Silberne Muschel beim Filmfestival von San Sebastián für Vertigo – Aus dem Reich der Toten
+1959 : Golden Laurel als Bester Regisseur / Produzent
+1959 : Silberne Muschel beim Filmfestival von San Sebastián für Der unsichtbare Dritte
+1960 : Oscar-Nominierung für Psycho ( Beste Regie ) 1960 : Golden Laurel als Bester Regisseur / Produzent
+1961 : Golden Laurel als Bester Regisseur / Produzent
+1962 : Golden Laurel als Bester Regisseur / Produzent
+1963 : Zweiter Platz beim Laurel Award als Bester Regisseur / Produzent
+1964 : Golden Laurel als Bester Regisseur / Produzent
+1965 : Zweiter Platz beim Laurel Award als Bester Regisseur / Produzent
+1965 : Milestone Award der Producers Guild of America
+1966 : Ehrung durch die Association of Cinematography , Television and Allied Technicians ( ACTT ) 1966 : Golden Laurel als Bester Regisseur / Produzent
+1967 : Zweiter Platz beim Laurel Award als Bester Regisseur / Produzent
+1968 : Irving G. Thalberg Memorial Award als Spezialoscar für besonders kreative Filmproduzenten 1968 : Ehrendoktorwürde der University of California
+1968 : D. W. Griffith Award der Directors Guild of America
+1969 : Officier des Arts et des Lettres
+1970 : National Board of Review Award als Bester Regisseur für Topas
+1971 : Ehrenmitgliedschaft der britischen Society of Film and Television
+1971 : Golden Laurel als Bester Regisseur / Produzent
+1971 : Ernennung zum Ritter der Ehrenlegion bei der Cinémathèque française
+1971 : BAFTA Award für sein Lebenswerk ( Academy Fellowship ) 1972 : Golden Globe für sein Lebenswerk : Cecil B. DeMille Award
+1972 : Ehrendoktorwürde der Universität von Columbia
+1973 : Grand Master Award der Mystery Writers of America
+1974 : Würdigung durch die „ Film Society of Lincoln Center “ in New York 1979 : AFI Life Achievement Award des American Film Institute
+1980 : Knight Commander of the British Empire
+1984 : Jussi ( Finnland ) als Bester ausländischer Filmemacher 1994 : 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 6506 Hollywood Blvd , den anderen in der Kategorie Fernsehen am 7013 Hollywood Blvd.
+Biografische Spielfilme über Hitchcock The Girl ( TV Spielfilm , 2012 ) 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 , 2012 ) 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 D ’ Arcy ( Anthony Perkins ) Dokumentarfilme Hitchcock – Truffaut . Dokumentarfilm , USA , Frankreich , 2014 , 79 Min. , Buch : Kent Jones und Serge Toubiana , Regie : Kent Jones , Produktion : arte France , Artline Films , Cohen Media Group , Erstsendung : 16. November 2015 bei arte , Dossier mit Filmausschnitten vom Festival de Cannes 2015 , .
+Literatur Biografien Laurent Bouzereau : Alfred Hitchcock . Knesebeck , München 2010 , ISBN 978-3-86873-250-4 ( mit einem Vorwort von Patricia Hitchcock O’Connell und bisher unveröffentlichtem Bildmaterial und herausnehmbaren Faksimiles von Storyboards und handschriftlichen Notizen ) .
+Charlotte Chandler : It ’ s Only a Movie : Alfred Hitchcock – A Personal Biography . Simon & Schuster , New York 2005 , ISBN 0-7432-3970-9 . Thomas Koebner : Alfred Hitchcock . In : Ders .
+( Hrsg. ) : Filmregisseure .
+Biographien , Werkbeschreibung , Filmographien .
+3. , aktualisierte und erweiterte Auflage .
+Reclam , Stuttgart 2008 [ 1. Aufl. 1999 ] , ISBN 978-3-15-010662-4 , S. 324–331 . Patrick McGilligan : Alfred Hitchcock .
+A Life in Darkness and Light .
+Wiley , Chichester 2003 , ISBN 0-470-86972-0 . Enno Patalas : Hitchcock . dtv , München 1999 , ISBN 3-423-31020-0 . Donald Spoto : Alfred Hitchcock – Die dunkle Seite des Genies . Ins Deutsche übersetzt von Bodo Fründt .
+Heyne , München 1984 , ISBN 3-453-55146-X . John Russel Taylor : Die Hitchcock-Biographie . Fischer Cinema , Frankfurt am Main 1982 , ISBN 3-596-23680-0 . Thilo Wydra : Alfred Hitchcock .
+Leben – Werk – Wirkung .
+Suhrkamp , Berlin 2010 , ISBN 978-3-518-18243-7 . Werkschauen Sortiert in der chronologischen Reihenfolge der jeweiligen Originalausgabe .
+Éric Rohmer , Claude Chabrol : Hitchcock . Ed. Universitaires , Paris 1957 . H. P.
+Manz : Alfred Hitchcock – eine Bildchronik . Mit Texten von Hitchcock , Godard , Truffaut u. a. Sanssouci , Zürich 1962 . François Truffaut : Mr.
+Hitchcock , wie haben Sie das gemacht ?
+.
+Heyne , München 1973 , ISBN 3-453-86141-8 ( Abfolge von Interviews ( circa 50 Stunden ) des französischen Regisseurs mit Hitchcock ) , Originalausgabe : Le cinéma selon Hitchcock . ( 1966 , 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 1976 , ISBN 3-442-10201-4 . François Truffaut , Robert Fischer ( Hrsg. ) : Truffaut , Hitchcock . Diana , Zürich 1999 , ISBN 3-8284-5021-0 ( frz. Original : 1984 ; erweiterte und gebundene Ausgabe von Mr.
+Hitchcock , wie haben Sie das gemacht ?
+( 1966 ) ) . Bodo Fründt : Alfred Hitchcock und seine Filme . Heyne Filmbibliothek Band Nr. 91 , München 1986 , ISBN 3-453-86091-8 . Robert E. Kapsis : Hitchcock : The Making of a Reputation . University of Chicago Press , Chicago 1992 , ISBN 0-226-42489-8 ( 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 Hitchcock ’ s Psycho . Verlag Robert Fischer + Uwe Wiedleroither , Stuttgart 1993 , ISBN 3-924098-06-9 Eva Rieger : Alfred Hitchcock und die Musik .
+Eine Untersuchung zum Verhältnis von Film , Musik und Geschlecht .
+Kleine , Bielefeld 1996 , ISBN 3-89370-236-9 Donald Spoto : Alfred Hitchcock und seine Filme . Wilhelm Heyne , München 1999 , ISBN 3-453-15746-X . Lars-Olav Beier , Georg Seeßlen ( Hrsg. ) : Alfred Hitchcock . Bertz + Fischer , Berlin 1999 , ISBN 3-929470-76-4 . Bill Krohn : Hitchcock at Work . Phaidon , Wien 2000 , ISBN 0-7148-4333-4 ( detaillierte Studie über Hitchcocks Arbeitsweise in seiner amerikanischen Zeit ) .
+Paul Duncan : Alfred Hitchcock , The Complete Films . Deutsch im Taschen-Verlag , Köln 2003 , ISBN 3-8228-1671-X Nikolai Wojtko ( Hrsg. ) : Alfred Hitchcock – der Filmverführer . Kovac , Hamburg 2005 , ISBN 978-3-8300-2148-3 . Gregor J. Weber : Jeder tötet , was er liebt .
+Liebes- und Todesszenen in den Filmen Alfred Hitchcocks .
+Schüren , Marburg 2007 , ISBN 978-3-89472-487-0 . Adrian Weibel : Spannung bei Hitchcock .
+Zur Funktionsweise des auktorialen Suspense .
+Königshausen & Neumann , Würzburg 2008 , ISBN 978-3-8260-3681-1 . Henry Keazor ( Hrsg. ) : Hitchcock und die Künste . Schüren , Marburg 2013 , ISBN 978-3-89472-828-1 . Éric Rohmer und Claude Chabrol : Hitchcock . Hrsg. und aus dem Französischen von Robert Fischer .
+Alexander , Berlin 2013 , ISBN 978-3-89581-280-4 . Stephen Rebello : Hitchcock und die Geschichte von „ Psycho “ . Wilhelm Heyne , München 2013 , ISBN 978-3-453-43726-5 ( Grundlage für das Drehbuch von Hitchcock ) .
+Paul Duncan ( Hrsg. ) : Alfred Hitchcock .
+Sämtliche Filme .
+Taschen , Köln 2019 , ISBN 978-3-8365-6681-0 . ( Mit zahlreichen Filmfotos , Kinoplakaten und Bildern von Dreharbeiten ) Weiteres Antoine de Baecque , Serge Toubiana : François Truffaut – Biographie . Éditions Gallimard , Paris 1996 , dt. 2004 , Egmont vgs Verlagsgesellschaft , ISBN 3-8025-3417-4 Fußnoten / Einzelnachweise Hauptquellen sind die beiden Biografien von Taylor und Spoto sowie die Bücher von Truffaut und Krohn .
+Weblinks Hitchcock-Wiki hitchcock.tv – umfangreiche englischsprachige Privatseite Hitchcock EyeGate Sammlung Alfred Hitchcock Homepage – umfangreiche deutschsprachige Privatseite von Hermann Holzner ( abgerufen am 15. September 2009 ) die biografischen Daten entstammen in der Regel den Biografien von Spoto und Taylor Laut Spoto ( dort S. 34 ) 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 2013 , hier insbesondere die Einleitung S. 9–32 Vgl. u. a. Taylor , S. 57f https://www.youtube.com/watch?v=IceUa3c-8zY https://www.youtube.com/watch?v=-HXLIx0KhKg Er selbst bezeichnete später Der Mieter als seinen eigentlich „ ersten Film “ Vgl. Duncan , S. 28Vgl . Spoto , S. 113ff . Vgl. Spoto , S. 120 Vgl. u. a. Duncan , S. 45Verschiedene Sprachversionen waren bei den frühen Tonfilmen üblich . Siehe Duncan , S. 57 Vgl. Taylor , S. 54 Vgl. Spoto , S. 342 Vgl. Spoto , S. 369 Vgl. Spoto , S. 374 Vgl. Truffaut ( 1966 ) , S. 196ff Vgl. Spoto , S. 461–471 . Vgl. Spoto , S. 489ff . Vgl. Taylor , S. 310. Vgl. Spoto , S. 559.Donald Spoto schreibt , Burks sei noch im selben Jahr bei einem Hausbrand ums Leben gekommen . Dies ist falsch . Er starb erst 1968 . Vgl. Taylor , S. 323f . Vgl. Spoto , S. 579f . Hitchcock im September 1969 , siehe Spoto , S. 589. Siehe Spoto , S. 597. Vgl. Spoto , S. 598ff . Siehe Donald Spoto : The Art of Alfred Hitchcock . Fifty Years of Motion Pictures . New York , London etc. : Doubleday 1992 ; S. 393–428 . Vgl. Truffaut ( 1966 ) , S. 308. Vgl. Truffaut ( 1966 ) , S. 238. 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. 528. 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. 117. Vgl. Spoto , S. 506f . 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 1950er- und 1960er-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 , 1995 , S. 249 ; Shohini Chaudhuri : Feminist Film Theorists : Laura Mulvey , Kaja Silverman , Teresa de Lauretis , Barbara Creed . Taylor & Francis , 2006 , S. 73. Siehe Truffaut ( 1966 ) , S. 250. Siehe Truffaut ( 1966 ) , S. 89. Vgl. Spoto , S. 470. Siehe Spoto , S. 487. 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 ( 1966 ) , S. 174 , 178. Siehe Spoto , S. 410. Vgl. Spoto , S. 530. Siehe Spoto , S. 299. Vgl. Truffaut ( 1966 ) , S. 289. Siehe Spoto , S. 90. Vgl. Spoto , S. 88 , 443. 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. 53.Vgl . Foster Hirsch , The Dark Side of the Screen : Film Noir . Da Capo Press , Boston 2008 , unpaginiert ( Auszug ) . Siehe Truffaut ( 1966 ) , S. 220. Donald Spoto : Alfred Hitchcock – Die dunkle Seite des Genies , S. 586. Vgl. u. a. Spoto , S. 439 , 447f . Vgl. Spoto , S. 530ff . In dem Film No Bail for the Judge , den er 1960 mit Audrey Hepburn inszenieren wollte , in einem Film namens Frenzy über einen psychopathischen Frauenmörder , den er 1966 drehen wollte ( und der nichts mit dem gleichnamigen Film von 1972 zu tun hat ) und in seinem letzten Projekt The Short Night , das er ab 1978 verfolgte und nicht mehr zu Ende bringen konnte . Vgl. Spoto , S. 389. Vgl. Spoto , S. 26ff . Vgl. Spoto , S. 301ff . Vgl. Spoto , S. 455 , 503. Vgl. Spoto , S. 334 , 611. Vgl. Krohn , S. 91f . Vgl. Krohn , S. 42ff . Vgl. Krohn , S. 215ff . Hitchcock selbst nannte es die „ impertinenteste Schlusseinstellung , die ich je gemacht habe “ : s. Truffaut ( 1966 ) , S. 137. Siehe Spoto , S. 571 Taylor über die Zusammenarbeit bei Vertigo , siehe Spoto , S. 459. Siehe Truffaut ( 1966 ) , S. 281siehe Spoto , 1984 , S. 596f Vgl. Truffaut ( 1966 ) , S. 281ff 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. 308f , 596 John Michael Hayes über die Zusammenarbeit an Das Fenster zum Hof in Spoto , S. 407 So geschah dies mit Evan Hunter , Ernest Lehman oder Anthony Shaffer – drei Autoren , mit denen Hitchcock zuvor erfolgreich zusammengearbeitet hatte . Vgl. Spoto , S. 550 , 614f und 632 Siehe Spoto , S. 487f 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. 371 Vgl. u. a. Truffaut ( 1966 ) , S. 95f , 135 , 186 , 293. Siehe Duncan , S. 10 Siehe Spoto , S. 382Klangbeispiele und umfangreiche Informationen zur Zusammenarbeit von Hitchcock mit Herrmann finden sich im Artikel Hitchcocks Hofkomponist : Bernard Herrmann ( moviepilot.de ) Siehe Vgl. Spoto , S. 156 , 368 , 500Vgl . u. a. Harris / Lasky , Seite 256Laut 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 129.000 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. 434ff Vgl. Spoto , S. 437ff , 577 ; Taylor , S. 269ff Siehe hitchcock.tv . Vgl. Duncan , S. 46. 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. 516vgl . de Baecque / Toubiana , S. 374Weitere Beispiele : Die Wendeltreppe von Robert Siodmak ( 1945 ) , Es geschah am hellichten Tag von Ladislao Vajda ( 1958 ) und Do You Like Hitchcock ? von Dario Argento ( 2005 ) Vgl. Spoto , S. 522. 
+
+Die Auteur-Theorie ( von frz. „ Auteur “ = Autor ) ist eine Filmtheorie und die theoretische Grundlage für den Autorenfilm – insbesondere den französischen – in den 1950er 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 1940er 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 1950er 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 1954 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 l'auteur ( 1968 , 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 1967 in ihrem Aufsatz Bakhtine , le mot , le dialogue et le roman ( Bachtin , das Wort , der Dialog und der Roman , 1972 ) aufbrachte .
+Für den europäischen Film blieb die Auteur-Theorie aber noch bis in die 1970er 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 1990er 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 ( 1958 ) , 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 1962 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 1968 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 ( un ) abhä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
@@ -2132,4143 +1315,2642 @@
 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
+Literatur François Truffaut : Une certaine tendance du cinéma français . In : Cahiers du cinéma . 1954,31 ( Januar ) .
+Übersetzung : A Certain Tendency of the French Cinema . In : Bill Nichols ( Hrsg. ) : Movies and Methods . Berkeley 1976 , S. 224–237 . Jean-Luc Godard : Godard / Kritiker . München 1974 , S. 38–56 . Jean-Luc Godard : Einführung in eine wahre Geschichte des Kinos . Hanser 1981 , ISBN 3446132821 . Andrew Sarris : Towards a Theory of Film History . In : Bill Nichols ( Hrsg. ) : Movies and Methods . Berkeley 1976 , S. 237–251 . Peter Wollen : The Auteur Theory . In : Signs and Meaning in the Cinema . London 1969 , S. 74–115 . Roland Barthes : Der Tod des Autors . In : Fotis Jannidis , Gerhard Lauer , Mathias Martinez , Simone Winko ( Hrsg. ) : Texte zur Theorie der Autorschaft . Stuttgart 2000 , S. 185–193 . Timothy Corrigan : A Cinema without Walls .
+Movies and Culture after Vietnam .
+New Brunswick 1991 , S. 101–136 . Dana Polan : Auteur Desire . In : Nr. 12 ( „ Auteurism 2001 “ )
+Jan Distelmeyer : Vom auteur zum Kulturprodukt .
+Entwurf einer kontextorientierten Werkgeschichtsschreibung .
+In : Andrea Nolte ( Hrsg. ) : Mediale Wirklichkeiten . Dokumentation des 15. Film- und Fernsehwissenschaftlichen Kolloquiums .
+Marburg 2003 , S. 86–97 . Jean-Luc Godard : Einführung in eine wahre Geschichte des Kinos . Hanser 1981 , ISBN 3446132821 . S. 34 
+
+Datei : Aki Kaurismäki at Berlinale 2017.jpg Aki Olavi Kaurismäki ( * 4. April 1957 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 1979 bis 1984 Filmkritiken für das Magazin Filmihullu .
+Das erste Drehbuch folgte 1980 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 1986 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 1988 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 1986 auf den Grenzland-Filmtagen kennengelernt hatte .
+Dem breiten deutschen Publikum bekannt wurde der finnische Regisseur durch seine Teilnahme an der Berlinale 1988 .
+Für großes Aufsehen sorgte Kaurismäki im Herbst 2006 , 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 .
+1989 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 “ 2006 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 2006 als „ Aki Kaurismäki DVD-Collection “ 14 Spielfilme und fünf Kurzfilme ( mit digital restaurierten Bildern ) in vier Boxen erschienen .
+2011 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 2017 eine Einladung in den Wettbewerb der 67. 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 3. Februar 2017 in die finnischen Kinos .
+Filmografie Regisseur 1981 : The Saimaa Gesture ( Saimaa-ilmiö ) – Dokumentarfilm mit seinem Bruder Mika 1983 : Crime and Punishment ( Rikos ja rangaistus )
+1984 : Der Clan – Geschichte der Frösche ( Klaani – tarina Sammakoitten suvusta ) – Co-Autor seines Bruders Mika 1985 : Calamari Union 1986 : Rock'y VI – Kurzfilm 1986 : Schatten im Paradies ( Varjoja paratiisissa )
+1987 : Hamlet goes Business ( Hamlet liikemaailmassa )
+1987 : Thru The Wire – Kurzfilm 1987 : Rich Little Bitch – Kurzfilm 1988 : Ariel
+1989 : Likaiset kädet – Produktion für das finnische Fernsehen
+1989 : Leningrad Cowboys Go America
+1990 : Das Mädchen aus der Streichholzfabrik ( Tulitikkutehtaan tyttö )
+1990 : Vertrag mit meinem Killer ( I Hired a Contract Killer )
+1991 : Those Were The Days – Kurzfilm 1992 : Das Leben der Bohème ( Boheemielämää / La vie de Bohème )
+1992 : These Boots – Kurzfilm 1993 : Tatjana – Take Care Of Your Scarf ( Pidä huivista kiini , Tatjana )
+1993 : Total Balalaika Show
+1994 : Leningrad Cowboys Meet Moses
+1996 : Wolken ziehen vorüber ( Kauas pilvet karkaavat )
+1999 : Juha
+2002 : Der Mann ohne Vergangenheit ( Mies Vailla Menneisyyttä )
+2002 : Dogs Have No Hell – Kurzfilmbeitrag in Ten Minutes Older : The Trumpet
+2006 : Lichter der Vorstadt ( Laitakaupungin valot )
+2011 : Le Havre
+2012 : Juice Leskinen & Grand Slam : Bluesia Pieksämäen asemalla – Kurzfilm 2012 : Tavern Man – Beitrag in Historic Centre
+2017 : Die andere Seite der Hoffnung ( Toivon tuolla puolen )
+Schauspieler 1980 : Der Lügner ( Valehtelija ) – auch Drehbuchautor ( Film seines Bruders Mika ) 1982 : The Worthless ( Arvottomat ) – auch Drehbuchautor und Regieassistent ( Film seines Bruders Mika ) 2004 : Aaltra
+2012 : Estrada de Palha
+2015 : Vandaleyne ( Cameo ) Auszeichnungen DVD Aki Kaurismäki Collection .
+Pandora Film , 2014 , 10 DVDs mit insgesamt 21 Filmen aus den Jahren 1983–2011 . Literatur Peter von Bagh : Kaurismäki über Kaurismäki . Alexander , Berlin 2014 , ISBN 978-3-89581-342-9 . ( Gespräche und Essays mit rund 200 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 1997 , ISBN 3-89602-119-2 ( Fotografien von Marja-Leena Hukkanen , mit Begleittexten von Aki Kaurismäki ) Jochen Werner : Aki Kaurismäki , Mainz , Bender 2005 , 352 S. , 500 s / w-Abb . , ISBN 3-936497-08-7 ( 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 2011 , ISBN 3-89581-255-2 Ralph Eue und Linda Söffker ( Hrsg. ) : Aki Kaurismäki ( film : 13 ) . Mit Beiträgen von Lars-Olav Beier , Harun Farocki , Ulrich Gregor , Anke Leweke und Jan Schulz-Ojala .
+Berlin , Bertz + Fischer Verlag 2006 , 224 S. , 207 s / w-Fotos / Bildsequenzen , ISBN 3-929470-89-6 Reinhold Zwick : Wolken ziehen herauf und vorüber .
+Strukturen des Komischen in der Bibel und bei Aki Kaurismäki ,
+in : St . Orth / J. Valentin / R. Zwick ( Hrsg. ) , Göttliche Komödien .
+Religiöse Dimensionen des Komischen im Kino ( Film und Theologie , Bd. 2 ) , Köln 2001 , S. 69–95 Reinhold Zwick : Selig die Armen in den Wohncontainern .
+Aki Kaurismäki und seine Tragikomödie „ Der Mann ohne Vergangenheit “ ,
+in : Stimmen der Zeit 128 ( 2003 ) , S. 546–560 Reinhold T. Schöffel : Grenzland Filmtage .
+Programm .
+Grenzlandfilmtage e. V. , Wunsiedel 1986 , S. 15–18 Weblinks Aki Kaurismäki , von Stadtbibliothek Orimattila ( finnisch / englisch ) „ Aki Kaurismäki – Die Helden : diesseitig und einsam “ , Dietrich Kuhlbrodt , epd Film 10/1990 „ Begrabt mein Herz an der Müllkippe “ Andreas Kilb , Die Zeit 10/1990 " Wo ich lebe , ist immer ein Schatten " Interview im Stadtmagazin Zitty , 2011 Kino der Lakonik Filmzyklus in Zürich Einzelnachweise Ralph Eue : Biografische Skizze . In : Ralph Eue und Linda Söffker , S. 188–191 Grenzland Filmtage . Programm . Grenzlandfilmtage e. V. , Wunsiedel 1986 , S. 15–18 epd Film 12/2006 , S. 25Eue , S. 189 epd Film 3/2007 , S. 50Hopewell , John : bei variety.com , 21. Mai 2011 ( aufgerufen am 22. Mai 2011 ) Aunimo , Rane : bei demokraatti.fi , 20. April 2016 ( abgerufen am 25. März 2017 ) . Taavitsainen , Iikka : bei savonsanomat.fi ( abgerufen am 27. April 2017 ) . http://www.imdb.com/title/tt0097753/ Rezension von Dietmar Kammerer , taz vom 12. Oktober 2006 , abgerufen 16. September 2012 
+
+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 20. 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 1970er 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 1960er 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 1980er Jahren in den USA und Europa durchgesetzt . Im englischen Sprachraum wurde seit Ende der 1970er 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 1990 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 1960er 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 1960er 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 2000 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 1910er Jahre kamen erste westliche Trickfilme nach Japan .
+Die ersten japanischen Nachahmer sind aus dem Jahr 1917 bekannt , in dem die Pioniere Oten Shimokawa , Jun'ichi Kōuchi und Seitarō Kitayama ihre ersten Filme aufführten .
+Aus dieser Zeit sind nur sehr wenige Werke erhalten .
+Ab den 1920er Jahren nahm die Produktion zu .
+Die entstandenen Kurzfilme waren meist Komödien , Lehrfilme oder zeigten japanische und chinesische Mythen .
+In den 1930er 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 1945 nicht lange vor der Kapitulation in die Kinos .
+Nach Ende des Krieges dauerte es über zehn Jahre , ehe 1958 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 1963 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 1960er 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 1960er und den 1970er Jahren entstanden vor allem Science-Fiction-Serien und mit ihnen wuchs die erste Generation an Fans auf , die ab den 1980er Jahren selbst als Produzenten in der Anime-Industrie aktiv wurde . Ebenso ab Ende der 1960er Jahre entstanden im bisher männlich dominierten Medium die ersten Serien , die sich an Mädchen richteten .
+Ribon no Kishi ( 1967 ) von Tezuka und Mila Superstar ( 1969 ) 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 1980ern die von sich magisch verwandelnden Mädchen erzählenden Magical-Girl-Serien , in den 1990ern 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 1970er 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 1980er unter anderem mit dem Erfolg des Science-Fiction-Films Akira im Kino , in den 1990ern dann mit den Filmen des Studio Ghibli und mit international erfolgreichen Fernsehserien wie Sailor Moon und Dragon Ball , sodass das Medium um das Jahr 2000 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 1990er 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 ( § 175 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 Girl / Mahō 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 18 bis 30 Jahren .
+Es werden meist anspruchsvollere , erotischere oder gewalthaltigere Inhalte thematisiert .
+Sentai / Super 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 1990er Jahren zunehmend von Computeranimationen verdrängt . Seit den Fernsehserien ab Beginn der 1960er 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 .
+18 unterschiedliche Bilder pro Sekunde sind dafür üblich , 24 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 8 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 500.000 Yen jeweils verkauft .
+Doch auch als ab den 1970er 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 1980er Jahren erstmals Computeranimationen eingesetzt wurden , gehörte die japanische Filmwirtschaft zu den ersten Anwendern .
+Seitdem wurde immer wieder mit 3D-Animation experimentiert .
+Anders als in den USA konnte die Computeranimation aber nicht die traditionelle 2D-Ästhetik ablösen , reine 3D-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 1990er 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 2000er 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 5 Millionen Yen , in früheren Zeiten eher 7 Millionen , und anderthalb Monaten Produktionszeit aufgewendet .
+In den 2000er Jahren wurden jedes Jahr 30 bis 50 Fernsehserien und 10 bis 20 Kinofilme produziert .
+Laut einer im Jahr 2013 durchgeführten Studie arbeiten japanische Anime-Zeichner im Durchschnitt 10 bis 11 Stunden pro Arbeitstag bzw. 263 Stunden pro Monat bzw. 4,6 freie Tage / Monat .
+Animatoren verdienen pro Jahr durchschnittlich ( Mittelwert ) 3,3 Millionen Yen ( ca. 23.000 € ) bzw. am häufigsten ( Modalwert ) 4,0 Mio. Yen ( 28.000 € ) , angefangen bei Einstiegspositionen wie Zwischenzeichnern mit 1,1 Mio. Yen ( 8000 € ) über Schlüsselzeichner mit 2,8 Mio. Yen ( 20.000 € ) und Storyboarder/3D-Animatoren mit 3,8 Mio. Yen ( 26.000 € ) bis zu Regisseuren mit 6,5 Mio. Yen ( 45.000 € ) . 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 Datei : Mahuri.jpg Datei : Vergleich zwischen Manga und Foto.jpg
+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 100 beliebtesten Zeichentrickserien in Japan alle Anime , mit Ausnahme von Tom und Jerry .
+Veröffentlichungsarten Neben Fernsehserien und Kinofilmen werden Animes seit den frühen 1980er 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 2000 gibt es auch Serien direkt für das Internet , Original Net Animation ( ONA ) genannt .
+Fernsehen Anime-Fernsehserien haben für gewöhnlich 12–13 , 24–26 , sowie seltener 52 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 100 Folgen kommen können .
+Im Jahr 1963 wurden sieben Serien gesendet , dies wird generell als der Beginn von Anime-TV-Serien angesehen .
+1978 wurde die 50er-Grenze mit 52 Serien gebrochen .
+1998 wurde die 100er-Grenze mit 132 Serien erreicht .
+Mit 233 Serien wurde die 200er-Grenze im Jahr 2004 erreicht .
+Seitdem hat sich die Anzahl der Serien mehr oder weniger etabliert , jedoch gab es Jahre wie 2006 und 2014 , in denen die 300er-Grenze erreicht wurde .
+Der Anstieg der Anime-Anzahl in den 90ern ist darauf zurückzuführen , dass seit 1996 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 ( , shin ’ ya 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 2 % , während 4 bis 5 % schon außergewöhnlich hoch sind . Einschaltquoten spielen bei Mitternachtsanimes und damit den meisten Animes seit den späten 90ern 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 1990er 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 2006 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 4,8 Mrd.
+Dollar im Jahr 2003 auf 2,8 Mrd.
+Dollar für 2007 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 2009 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 1990er 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 1963 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 und / oder 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 1990er Jahre von der Politik wenig beachtet und wenn überhaupt nur als Problem wahrgenommen wurde , änderte sich dies nach 2000 .
+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 2000 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 1985 unter der Leitung von Hayao Miyazaki Filme produziert , z. B.
+Prinzessin Mononoke 1997 , Chihiros Reise ins Zauberland 2001 oder Das wandelnde Schloss 2004 .
+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 2002 den Goldenen Bären auf der Berlinale und im Jahr 2003 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 1960er Jahre .
+Weitere bekannte Anime-Studios : A-1 Pictures ( Fairy Tail , Sword Art Online ) Bee Train ( El Cazador , . hack / / SIGN , Madlax , Noir , Tsubasa – Reservoir Chronicle ) Bones ( Eureka Seven , Fullmetal Alchemist , Ouran High School Host Club , Soul Eater , Wolf ’ s Rain ) GAINAX ( FLCL , Gurren Lagann , He Is My Master , Die Macht des Zaubersteins , Neon Genesis Evangelion ) J. C. Staff ( 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 I. G ( 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 1960er 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 90ern 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 80ern sowie Avatar – Der Herr der Elemente , Monsuno und Teen Titans in den 2000ern 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 4Kids ( 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 16. März 1961 der Film Der Zauberer und die Banditen von Toei Animation aus dem Jahr 1959 in den Kinos gezeigt .
+Die erste Anime-Serie im deutschen Fernsehen war Speed Racer , von der 1971 aber nur einige Folgen gezeigt wurden ehe sie wegen Protesten abgesetzt wurde .
+Ähnliches geschah zu Erstausstrahlung von Captain Future in den 1980er Jahren .
+Entsprechend wurden in den 1970er und 80er 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 1975 auf sogenannten TED-Bildplatten .
+In den 1980er 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 2000 von vielen eng mit pornografischen oder stark gewalthaltigen Werken verknüpft wurden .
+Mit Beginn der 1990er Jahre sind im deutschen Kino häufiger Anime-Filme gezeigt worden , darunter Akira ( 1991 ) , Ghost in the Shell ( 1997 ) sowie einige Produktionen von Studio Ghibli wie Prinzessin Mononoke ( 2001 ) und Chihiros Reise ins Zauberland ( 2003 ) .
+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 1999 erhielten Animes den Programmblock Moon Toon Zone bei RTL 2.
+Dieser Block bestand aus Sailor Moon , Dragon Ball und Pokémon und wurde mit Anime@RTL2 ab 2001 und PokitoTV im Jahr 2004 ausgebaut . Durch den Erfolg der RTL-2-Ausstrahlungen begann das bewusste Lizenzieren von Anime durch RTL2 und andere Fernsehsender .
+K-Toon , MTV , VIVA und VOX sendeten Animes für ein älteres Publikum .
+Ab 2007 ging dieses Angebot von Animes im Fernsehen wieder deutlich zurück .
+2013 wurde das Programm bei RTL II vollständig abgesetzt . Von 2007 bis Juni 2016 gab es mit Animax Deutschland ein eigener Pay-TV-Sender für den deutschsprachigen Raum .
+Heute senden nur noch ProSieben MAXX ( seit 2013 ) 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 1995 .
+Um 2000 kamen immer mehr Label auf den Markt , von denen sich jedoch viele nicht halten konnten .
+Erst ab 2010 traten neue Unternehmen dazu , von denen einige seit 2015 auch regelmäßige Anime-Festivals veranstalten .
+Als erste deutsche Videoplattform startete im September 2007 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.1 Media gehörende MyVideo sein 2011 gestartete Angebot 2016 wieder ein . Seit 2013 bedient das amerikanische Portal Crunchyroll auch den deutschen Markt .
+Eine Fanszene entwickelte sich ab den 1980er 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 1994 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 1996 ) und Kimba , der weiße Löwe ( vier Jahre vor der Deutschen Ausstrahlung ) im Jahr 1974 aufgetaucht .
+Ähnlich wie bei Wickie und die starken Männer und Die Biene Maja gab es französisch-japanische Koproduktionen ( Barbapapa , Odysseus 31 und Die geheimnisvollen Städte des Goldes ) .
+Mit der Toei-Produktion Grendizer ( auch genannt Goldorak ) wurde 1978 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 .
+TF1 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 RTL2 insgesamt etwa 60 Serien zeigte , waren es auf TF1 weit über 100. AB Productions hat die Serien jedoch als billiges Kinderprogramm angesehen und diese Massen an Serien dann so im Schnitt und Dialog zusammengestutzt . 1997 wurde das Programm auf TF1 nach Protesten und einen Konflikt über Anime , der über 15 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 .
+2004 wurde Ghost in the Shell 2 : Innocence bei den Internationalen Filmfestspielen von Cannes 2004 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 70ern und 80ern nur knapp 20 Serien gezeigt wurden , waren es in Italien bereits über 200.
+Der Grund für diese Massenimporte war , dass Italien bereits 1976 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 70ern , 80ern und 90ern 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 .
+1999 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 , D ’ Artagnan und die drei MuskeTiere und Roy , the Little Cid sind entstanden .
+Mit dem Aufkommen des Privatfernsehens im Jahre 1990 startete der Sender Telecinco .
+Er setzte Saint Seiya fort und importierte fast 100 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 1/2 ) und wurden 1999 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 1980er Jahren in kleinerem Maße in den USA und Frankreich .
+ie japanische Fanszene entstand ab den 1970er 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 Gainax . M 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 2000 herum wuchs , war sie noch sehr jung .
+Einer Umfrage von Sozioland aus dem Jahr 2005 sowie einer Untersuchung des französischen Centre d'Études et de Recherches Internationales zufolge waren die meisten zwischen 14 und 25 Jahren alt .
+Nur wenige waren über 25 , spielten jedoch in der Fanszene eine wichtige Rolle , gründeten die ersten Magazine und Veranstaltungen .
+70 bis 85 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 230.000 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
+Literatur Gilles Poitras : The Anime Companion : What ’ s Japanese in Japanese Animation ? Stone Bridge Press , ISBN 1-880656-32-9 , ( englisch ) . , 1998 Jonathan Clements , Helen McCarthy : The Anime Encyclopedia : A Guide to Japanese Animation Since 1917 .
+Stone Bridge Press , 2001 , ISBN 1-880656-64-7 , ( englisch ) .
+Patrick Drazen : Anime Explosion !
+– The What ?
+Why ?
+& Wow !
+of Japanese Animation .
+Stone Bridge Press , ISBN 1-880656-72-8 , ( englisch ) . , 2002 Deutsches Filminstitut – DIF / Deutsches Filmmuseum & Museum für angewandte Kunst ( Hrsg. ) ( 2008 ) : ga-netchû !
+Das Manga Anime Syndrom .
+Henschel Verlag , ISBN 978-3-89487-607-4 . Jonathan Clements : Anime – A History .
+Palgrave Macmillan , 2013 , ISBN 978-1-84457-390-5 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 1 einer 3-teiligen Reihe über ihren Einfluss auf den Westen , Themen , Bildsprache von Rüdiger Suchsland auf Telepolis Einzelnachweise Jonathan Clements : Anime – A History . Palgrave Macmillan 2013 . S. 1. ISBN 978-1-84457-390-5 . Darin Verweis auf : Ōtsuka Yasuo : Sakuga Asemamire . Tokuma Shoten , 2001 . S. 29. Und : Tsugata Nobuyuki : Nihon Hatsu no Animation Sakka Kitayama Seitarō . Rinsen Shoten , 2007 . S. 57. Alexander Zahlten : Something for Everyone – Anime und Politik in ga-netchû ! Das Manga Anime Syndrom S. 79. Henschel Verlag , 2008 . 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 , 2008 . S. 24. Fred Patten : What's Wrong with Japanese Animation ? In : Watching Anime , Reading Manga - 25 Years of Essays and Reviews . Stone Bridge Press , 2004 . S. 19. Fred Patten : “ Anime ” Versus “ Japanimation ” In : Watching Anime , Reading Manga - 25 Years of Essays and Reviews . Stone Bridge Press , 2004 . S. 85f.Clements , 2013 . S. 1f , 4–8 . Susan J. Napier : Anime from Akira to Princess Mononoke : Experiencing Contemporary Japanese Animation . Palgrave 2001 . S. 6f . Fred Patten : Letter to the Editor : “ Anime ” as Pejorative In : Watching Anime , Reading Manga - 25 Years of Essays and Reviews . Stone Bridge Press , 2004 . S. 108–110 . 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 , 2008 . S. 51–63 . ISBN 978-3-89487-607-4 . 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. 89–93 . Henschel Verlag , 2008 . Dinah Zank : Girls only !? - Japanische Mädchenkultur im Spiegel von Manga und Anime . In : ga-netchû ! Das Manga Anime Syndrom . Henschel Verlag , 2008 . S. 149–154 . 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. 156. Henschel Verlag , 2008 . 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 , 2008 . S. 50f , 56f . ISBN 978-3-89487-607-4 . Thomas Lamarre : Full Limited Animation in Ga-netchū - Das Manga Anime Syndrom . Henschel Verlag , 2008 , S. 106–119 . 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 , 2008 . S. 50f , 56f . ISBN 978-3-89487-607-4 . Alexander Zahlten : Something for Everyone – Anime und Politik in ga-netchû ! Das Manga Anime Syndrom S. 76–85 . Henschel Verlag , 2008 . 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 , 2008 . S. 96f . ISBN 978-3-89487-607-4 . Joachim Friedmann : Sometimes Good Guys Don't wear White . In : Deutsches Filminstitut – DIF / Deutsches Filmmuseum & Museum für angewandte Kunst ( Hrsg. ) : ga-netchû ! Das Manga Anime Syndrom . Henschel Verlag , 2008 . S. 230–233 . ISBN 978-3-89487-607-4 . 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 , 2008 . S. 24–26 . ISBN 978-3-89487-607-4 . Joachim Friedmann : Sometimes Good Guys Don't wear White . In : Deutsches Filminstitut – DIF / Deutsches Filmmuseum & Museum für angewandte Kunst ( Hrsg. ) : ga-netchû ! Das Manga Anime Syndrom . Henschel Verlag , 2008 . S. 230–232 . ISBN 978-3-89487-607-4 . 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 , 2008 , S. 26 , 214 ff. 
+
+Datei : Stunt Pyrotechnics Luc Viatour.jpg 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 1960er-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 1950er-Jahren Aktion und explizite Darstellung von physischer Gewalt zunehmend an Bedeutung gewann , etwa in Stanley Kubricks Die Rechnung ging nicht auf ( 1956 ) .
+Alfred Hitchcock präsentierte in Der unsichtbare Dritte ( 1959 ) 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 ( 1967 ) und Sam Peckinpahs The Wild Bunch – Sie kannten kein Gesetz ( 1969 ) .
+Hochphase 1970–1990er Datei : Action film actors.jpeg 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 1980er 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 1990er Jahren wurde das Genre zunehmend ironisiert und spiegelte sich selbst , etwa in Filmen wie Last Action Hero ( John McTiernan , 1993 ) und True Lies ( James Cameron , 1994 ) .
+McTiernans Stirb-langsam-Reihe ( 1988 bis 2013 ) 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 1990ern 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 1970er 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 2000 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 2010ern verschwanden klassische Actionfilme als Blockbuster weitgehend aus dem Kino , und Fortsetzungen wie Stirb Langsam 5 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 Datei : Female action hero actresses.jpg Weibliche Hauptfiguren waren bis Ende der 1990er 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 , 1971 ) , Bullitt ( Peter Yates , 1968 ) oder Dirty Harry ( Don Siegel , 1971 ) .
+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 ) , der / die 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 90er : Actionhelden in der Krise - Essay ( 5 Seiten ) film-zeit.de , Ines Walk vom 10. Januar 2010 
+
+Datei : Manglehorn 07 ( 15085911640 ) . jpg Alfredo James „ Al “ Pacino ( * 25. April 1940 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 , „ Pacino ’ s Lounge “ . Das Pacino ’ s wurde in wirtschaftlich schweren Zeiten in den frühen 90er Jahren geschlossen ; heute trägt es den Namen Citrus Grill . Salvatore Pacino starb am 1. Januar 2005 im Alter von 82 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 17 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 Datei : Al Pacino Cannes 1996.jpg Pacino wurde durch den späteren Filmproduzenten Martin Bregman bei einem Off-Broadway-Auftritt entdeckt . 1969 wirkte er in seiner ersten Hollywood-Produktion Ich , Natalie mit .
+1971 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 ( 1972 ) ebnete und ihm 1973 seine erste Oscar-Nominierung einbrachte .
+Nach Hundstage wurde es stiller um Pacino .
+Erst in den 1980er Jahren brachte er sich durch Filme wie Brian De Palmas Scarface ( 1983 ) und Sea of Love – Melodie des Todes ( 1989 ) wieder ins Gespräch .
+Nach einer erneuten Zusammenarbeit mit Coppola in Der Pate III ( 1990 ) folgte der Thriller Heat ( 1995 ) 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 ( 2003 ) 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 1970er Jahren – insbesondere in der Der Pate – dabei zumeist minimalistisch und zurückhaltend war , änderte es sich mit seinem Comeback in den 1980er 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 2010/2011 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 1996 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 .
+Datei : Al Pacino Roma Film Fest cropped.jpg
+Auszeichnungen und Ämter Al Pacino war insgesamt acht Mal für einen Oscar nominiert .
+Seine erste Nominierung erhielt er 1973 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 .
+1993 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 1973 bei den Filmfestspielen in Cannes die Auszeichnung als bester Darsteller .
+Am 7. Juni 2007 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 4. September 2011 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 2. Februar 2013 erhielt er die Goldene Kamera für sein Lebenswerk .
+2014 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 , * 2001 ) mit Beverly D ’ Angelo .
+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 ( 1983 ) Frank Glaubrecht die Synchronisation des Schauspielers .
+Seit 1995 ist Glaubrecht alleiniger Sprecher ( Heat , City Hall , Insomnia etc. ) und er kann mittlerweile als Pacinos Standardstimme bezeichnet werden .
+In den frühen 1990er Jahren wurde Pacino auch von Joachim Kammer ( Dick Tracy ) , Gottfried Kramer ( Der Pate 3 ) und Klaus Kindler ( Carlito's Way ) gesprochen .
+Filmografie Darsteller 2003 : Der Einsatz ( The Recruit )
+2003 : Liebe mit Risiko – Gigli ( Gigli )
+2003 : Engel in Amerika ( Angels in America , Fernsehserie ) 2004 : Der Kaufmann von Venedig ( The Merchant of Venice )
+2005 : Das schnelle Geld ( Two for the Money )
+2007 : 88 Minuten ( 88 Minutes )
+2007 : Ocean ’ s 13 ( Ocean ’ s Thirteen )
+2008 : Kurzer Prozess – Righteous Kill ( Righteous Kill )
+2009 : Salomaybe ?
+2010 : Ein Leben für den Tod ( You Don ’ t Know Jack )
+2011 : Ein Cop mit dunkler Vergangenheit – The Son of No One
+2011 : Wilde Salome 2011 : Jack und Jill ( Jack and Jill )
+2012 : Stand Up Guys
+2013 : Der Fall Phil Spector ( Phil Spector )
+2014 : Manglehorn 2014 : Der letzte Akt ( The Humbling )
+2015 : Mr. Collins ' zweiter Frühling ( Danny Collins )
+2016 : Ruf der Macht – Im Sumpf der Korruption ( Misconduct )
+2017 : The Pirates of Somalia
+2017 : Hangman – The Killing Game ( Hangman )
+2018 : Paterno ( Fernsehfilm ) 2019 : Once Upon a Time in Hollywood
+Regisseur 1996 : Al Pacino ’ s Looking for Richard ( Looking for Richard )
+2000 : Chinese Coffee 2009 : Salomaybe ?
+2011 : Wilde Salome 2013 : Salomé Produzent 1990 : The Local Stigmatic ( Kurzfilm ) 1996 : Al Pacino ’ s Looking for Richard ( Looking for Richard )
+2014 : The Humbling Drehbuchautor 1996 : Al Pacino ’ s Looking for Richard ( Looking for Richard )
+2011 : Wilde Salome Auszeichnungen Oscar
+1973 : Nominierung als bester Nebendarsteller ( Der Pate )
+1974 : Nominierung als bester Hauptdarsteller ( Serpico )
+1975 : Nominierung als bester Hauptdarsteller ( Der Pate – Teil II )
+1976 : Nominierung als bester Hauptdarsteller ( Hundstage )
+1980 : Nominierung als bester Hauptdarsteller ( … und Gerechtigkeit für alle )
+1991 : Nominierung als bester Nebendarsteller ( Dick Tracy )
+1993 : Bester Hauptdarsteller ( Der Duft der Frauen )
+1993 : 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
+1973 : Nominierung bester Hauptdarsteller – Drama ( Der Pate )
+1974 : Bester Hauptdarsteller – Drama ( Serpico )
+1975 : Nominierung als bester Hauptdarsteller – Drama ( Der Pate – Teil II )
+1976 : Nominierung als bester Hauptdarsteller – Drama ( Hundstage )
+1978 : Nominierung als bester Hauptdarsteller – Drama ( Bobby Deerfield )
+1980 : Nominierung als bester Hauptdarsteller – Drama ( … und Gerechtigkeit für alle )
+1983 : 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
+)
+1984 : Nominierung als bester Hauptdarsteller – Drama ( Scarface ) 1990 : Nominierung als bester Hauptdarsteller – Drama ( Sea of Love – Melodie des Todes ) 1991 : Nominierung als bester Hauptdarsteller – Drama ( Der Pate – Teil III ) 1991 : Nominierung als bester Nebendarsteller ( Dick Tracy ) 1993 : Bester Hauptdarsteller – Drama ( Der Duft der Frauen ) 1993 : Nominierung als bester Nebendarsteller ( Glengarry Glen Ross ) 2001 : Cecil B. DeMille Award für sein Lebenswerk 2004 : Bester Hauptdarsteller – Mini-Serie oder TV-Film ( Engel in Amerika ) 2011 : Bester Hauptdarsteller – Mini-Serie oder TV-Film ( Ein Leben für den Tod ) 2016 : Nominierung als bester Hauptdarsteller – Komödie oder Musical ( Danny Collins ) British Academy Film Award 1973 : Nominierung als bester Nachwuchsdarsteller ( Der Pate ) 1975 : Nominierung als bester Hauptdarsteller ( Serpico ) 1976 : Bester Hauptdarsteller ( Hundstage ) 1991 : Nominierung als bester Nebendarsteller ( Dick Tracy ) National Board of Review 1973 : Bester Nebendarsteller ( Der Pate ) 1974 : Bester Hauptdarsteller ( Serpico ) Emmy 2004 : Bester Hauptdarsteller – Mini-Serie oder TV-Film ( Engel in Amerika ) 2010 : Bester Hauptdarsteller – Mini-Serie oder TV-Film ( Ein Leben für den Tod ) Screen Actors Guild Awards 2004 : Bester Hauptdarsteller – Mini-Serie oder TV-Film ( Engel in Amerika ) 2010 : Bester Hauptdarsteller – Mini-Serie oder TV-Film ( Ein Leben für den Tod ) National Society of Film Critics 1973 : Bester Hauptdarsteller ( Der Pate ) American Film Institute 2007 : AFI Life Achievement Award Goldene Himbeere 1986 : Nominierung als schlechtester Darsteller für Revolution 2004 : Nominierung als schlechtester Nebendarsteller für Gigli 2009 : Nominierung als schlechtester Darsteller für 88 Minutes und Righteous Kill 2012 : Schlechtester Nebendarsteller für Jack und Jill 2012 : Schlechtestes Leinwandpaar ( Adam Sandler und entweder Katie Holmes , Al Pacino oder Adam Sandler ) für Jack und Jill Goldene Kamera 2013 : Auszeichnung Lebenswerk international Weblinks – Interview mit Bruno Lester in der Frankfurter Rundschau , 2. Januar 2009 , S. 40 – Würdigung Al Pacinos zum 75. Geburtstag in Spiegel Online , 15. April 2015 Einzelnachweise https://www.nzz.ch/robert_de_niro_und_al_pacino_langweilen_sich-1.1668095 https://www.schwarzkopf-verlag.net/store/p642/AL_PACINO.html https://www.tv-media.at/top-storys/al-pacino-76-geburtstag https://www.moviepilot.de/people/al-pacino http://www.whoswho.de/bio/alfredo-james-pacino.html | url = http://www.playbill.com/news/article/150689-Ellen-Barkin-Patina-Miller-John-Larroquette-Jim-Parsons-Tony-Sheldon-and-More-Win-Theatre-World-Awards | wayback = 20110513131558 | text = ' ' Ellen Barkin , Patina Miller , John Larroquette , Jim Parsons , Tony Sheldon and More Win Theatre World Awards ' ' Playbill.com , online , ( englisch ) , abgerufen am 25. Oktober 2011 vgl. Auszeichnungsliste der Biennale bei labiennale.org , abgerufen am 15. Juni 2012 ( englisch ) 
+
+Datei : Alkohol - Alcohol.svg Datei : Alcohol general.svg 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 , sp3-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-sp3-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. 16 zu den „ sehr schwachen Säuren “ zählen , gehören normale Phenole mit einem pKs-Wert von 10 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 1957 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 .
+Datei :P rim . sec. tert. Alcohols V.1.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 Gruppe ( n ) an .
+Dies gilt auch für einwertige Alkohole , zum Beispiel ( Trivialname Isopropanol ) .
+Ethanol . png | Strukturformel des Ethanols1,2-propandiol numbered.svg | Strukturformel 1,3-propandiol numbered.svg | Strukturformel 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 sp2-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-alcohol.png | Strukturformel des Allylalkohols ( 2-Propen-1-ol ) Strukturformel von 2-Butin-1,4 -diol.svg | Strukturformel des Butindiols L-Ascorbic acid.svg | Strukturformel 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 22 ( Behenylalkohol ) Kohlenstoffatomen . Sie werden meist durch Reduktion der aus Fettsäuren gewonnen .
+Die höheren primären Alkohole mit 24 bis 36 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 Datei : H-bonding alcohol.svg Datei :D iagramm-Abhängigkeit des Sdp von Anzahl OH-Gruppen.png 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 ( C2H6 ) ( M = 30 ) einen Siedepunkt von − 89 ° C , während Methanol ( CH3OH ) ( M = 32 ) diesen erst bei 65 ° 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 16 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 : Datei : Methanol saeure base.svg
+Spektroskopie Im IR-Spektrum von Alkoholen ist deutlich die breite Bande der O–H-Valenzschwingung im Bereich von 3200–3650 cm − 1 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 3620–3650 cm − 1 zu finden .
+Chemische Eigenschaften Reaktion mit konzentrierter Schwefelsäure Unterhalb von 140 ° C bildet sich der Ester der Schwefelsäure .
+Bei etwa 140 ° C findet die Kondensationsreaktion zu einem Ether statt .
+Oberhalb von 170 ° 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 Chrom ( VI ) - 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 Chrom ( VI ) - 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.Datei : Alkohol - Aldehyd - Carbonsäure.svg 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äure / zum Keton : Jones-Oxidation ( Chrom ( VI ) - oxid in Schwefelsäure unter Anwesenheit von Aceton ) Kaliumdichromat in Schwefelsäure Rutheniumtetroxid
+Oxidation zum Aldehyd / zum Keton : Collins-Reagenz ( CrO3 · py2 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 > 3 < / 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 , 2-Propanol und - Butanol .
+Im Jahr 2011 wurden weltweit etwa 6,4 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 ( Chrom ( III ) - Ionen ) und kann spektralphotometrisch gemessen werden .
+Certest Eine weitere Möglichkeit besteht in der Umsetzung mit Ammoniumcer ( IV ) - nitrat .
+Hierbei wird eine konzentrierte Lösung von Ammoniumcer ( IV ) - 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 Alkohol / Phenol mit dem Sauerstoffatom am Cer ( IV ) koordiniert .
+Durch die Veränderung der Ligandensphäre verändert sich die Farbe des Cer ( IV ) von hellgelb zu rot / grün / braun .
+Leicht oxidierbare Alkohole / Phenole können einen negativen Nachweis ergeben , indem sie das Cer ( IV ) zu Cer ( III ) 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 Homologe Reihe der einwertigen , primären , linearen , unverzweigten AlkoholeC-AtomeMolare Masse g · mol − 1Systematischer NameTrivialnameSchmelzpunkt ° CSiedetemperatur ° CLöslichkeit g · l − 1132,0MethanolHolzgeist , Methylalkohol − 97,864,7Siegfried Hauptmann : Organische Chemie , 2. Auflage , VEB Deutscher Verlag für Grundstoffindustrie , Leipzig 1985 , ISBN 3-342-00280-8 , S. 312.
+∞ 246,1EthanolAlkohol , Ethylalkohol , Weingeist − 114,178,3 ∞ 3 60,1Propan-1-oln - Propylalkohol − 126,297,2 ∞ 474,1Butan-1-oln - Butylalkohol − 89,3117,379588,2Pentan-1-oln - Amylalkohol − 78,2138Hans Beyer und Wolfgang Walter : Organische Chemie , S. Hirzel Verlag , Stuttgart , 22. Auflage , 1991 , S. 120 , ISBN 3-7776-0485-2.236102,2Hexan-1-oln - Hexylalkohol − 48,6157,5Hans Beyer und Wolfgang Walter : Organische Chemie , S. Hirzel Verlag , Stuttgart , 22. Auflage , 1991 , S. 124 , ISBN 3-7776-0485-2.67116,2Heptan-1-ol − 34,0176Hans Rudolf Christensen : Grundlagen der organischen Chemie , Verlag Sauerländer Aarau , 1. Auflage , 1970 , S. 166.28130,2Octan-1-ol − 14,9194,50,59144,3Nonan-1-ol − 6 | ZVG = 490177 | CAS = 143-08-8 | Datum = 13. April 2008.214 –216 | 806866 | Name = 1-Nonanol | Datum = 1. November 2010010158,3Decan-1-ol 7 | ZVG = 22300 | CAS = 112-30-1 | Datum = 4. Januar 2008.228011172,3Undecan-1-ol 15,9 | Auflage = 90 | Titel = | Kapitel =3 | Startseite = 517 | Endseite = 243012186,3Dodecan-1-olLaurylalkohol24259013200,4Tridecan-1-ol 31,7 | Auflage = 90 | Titel = | Kapitel =3 | Startseite = 496 | Endseite = 274014214,4Tetradecan-1-olMyristylalkohol39 –40 Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-507 , ISBN 0-8493-0740-6.289015228,4Pentadecan-1-ol 44270016242,4Hexadecan-1-olCetylalkohol50Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-301 , ISBN 0-8493-0740-6.3440 … 18270,5Octadecan-1-olStearylalkohol56 –59 Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-496 , ISBN 0-8493-0740-6.3360 … 26382,7Hexacosan-1-olCerylalkohol79 –81240 ( 13 Pa ) 0 … 30438,8Triacontan-1-olMyricylalkohol88Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-355 , ISBN 0-8493-0740-6 . 0Einwertige Alkohole : sekundär und tertiär , primär mit verzweigten KettenC-AtomeMolare Masse g · mol − 1Systematischer NameTrivialnameSchmelzpunkt ° CSiedetemperatur ° CLöslichkeit g · l − 1360,1Propan-2-olIsopropylalkohol , Isopropanol − 88,582,3 ∞ 474,1Butan-2-olSekundärer Butylalkohol − 114,799,5Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-169 , ISBN 0-8493-0740-6.125474,12-Methylpropan-1-olIsobutylalkohol − 108108Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-446 , ISBN 0-8493-0740-6.100474,12-Methylpropan-2-olTertiärer Butylalkohol , Trimethylcarbinol25,5Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-447 , ISBN 0-8493-0740-6.82,3 ∞ 588,2Pentan-2-olsek - n-Amylalkohol − 50118,9Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-396 , ISBN 0-8493-0740-6.166588,2Pentan-3-olDiethylcarbinol − 8116,1Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-397 , ISBN 0-8493-0740-6.55 ( 30 ° C ) 588,22-Methylbutan-1-ol − 70129Robert C. Weast ( Hrsg. ) : CRC Handbook of Chemistry and Physics , 1st Student Edition , 1988 , CRC Press Baton Rouge , Florida , S. C-168 , ISBN 0-8493-0740-6.36588,23-Methylbutan-1-olIsoamylalkohol − 117130,820588,22-Methylbutan-2-ol − 8,4102 588,23-Methylbutan-2-ol 112,9 583,22,2-Dimethylpropan-1-olneo - Pentylalkohol , tertiärer Amylalkohol − 12102125Mehrwertige AlkoholeC-AtomeMolare Masse g · mol − 1Systematischer NameTrivialnameSchmelzpunkt ° CSiedetemperatur ° CLöslichkeit g · l − 1262,1Ethan-1,2-diolEthylenglycol , 1,2-Glycol − 15,6197,2 ∞ 376Propan-1,2-diolPropylenglycol − 68188 ∞ 376Propan-1,3-diolTrimethylenglycol − 32215 ∞ 490Butan-1,2-diol1,2-Butylenglycol − 114192 ∞ 490Butan-1,3-diol1,3-Butylenglycol < − 50207,5 ∞ 490Butan-1,4-diolTetramethylenglycol16230 ∞ 490Butan-2,3-diol2,3-Butylenglycol34 ( meso ) 183 ( meso ) ∞ 5104Pentan-1,5-diolPentamethylenglycol − 16241 ∞ 6118Hexan-1,6-diolHexamethylenglycol39 –42253 –26050008146 Octan-1,8-diolOctamethylenglycol58 –61 171–173 ( 27 hPa ) 9160Nonan-1,9-diolNonamethylenglycol45 –46288910174 Decan-1,10-diolDecamethylenglycol722970,73104Propan-1,2,3-triolGlycerin , Glycerol18290 ∞ Weitere AlkoholeC-AtomeMolare Masse g · mol − 1Systematischer NameTrivialnameSchmelzpunkt ° CSiedetemperatur ° CLöslichkeit g · l − 1586,13Cyclopentanol − 1914113 | 96-41-3 | Cyclopentanol | Datum =3 1. Juli 2018 oder früher6100,2Cyclohexanol 25,2161,5363 = 58Prop-2-en-1-olAllylalkohol − 12997 ∞ 4 = 71But-2-en-1-olCrotylalkohol − 30118166470,093-Butin-1-ol − 63128,9698,142-Hexin-1-ol66 –67698 , 143-Hexin-1-ol63–64698 , 143-Hexin-2-ol79–80698 , 145-Hexin-1-ol73–75698 , 145-Hexin-3-ol7108,14Phenylmethanol , ( Hydroxymethyl ) benzolBenzylalkohol − 15205,4397114,19Cyclohexylmethanol19187 –1888126 , 203-Octin-1-ol8808126,207-Octin-1-ol708122,141-Phenylethan-1-ol , ( 1-Hydroxyethyl ) benzol ( C6H5CH ( OH ) CH3 ) α-Phenylethylalkohol2120508122,142 - Phenylethan-1-ol , ( 2-Hydroxyethyl ) benzol ( C6H5CH2CH2OH ) β-Phenylethylalkohol − 272211610158,293-Decanol21310158,294-Decanol − 11210–21111164 , 254-tert-Butylbenzylalkohol139–14013184 , 23Diphenylmethanol ( C6H5 ) 2CHOHDiphenyltricarbinol , Benzhydrol69298019260,33Triphenylmethanol ( C6H5 ) 3COHTriphenylcarbinol162,5 > 3600Zum Vergleich das Phenol und Alkohole mit ähnlichen molaren MassenC-AtomeMolare Masse g · mol − 1Systematischer NameTrivialnameSchmelzpunkt ° CSiedetemperatur ° CLöslichkeit g · l − 1694,1PhenolCarbolsäure , Benzenol 41181,784588,2Pentan-1-oln - Amylalkohol − 78,2128,0236102,2Hexan-1-oln - Hexylalkohol − 48,6157,16586,13Cyclopentanol − 19141136100,2Cyclohexanol 25,2161,536Anmerkung : = Doppelbindungenbei Siedepunkt : Die Substanz zersetzt sich vor Erreichen des Siedepunktes .
+Werte in Klammern geben den Siedepunkt bei 20 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 1965 , S. 44. Science Vision , Jg. 3 , Nr. 25 , März 2000 ( ) . Wissenschaft-Online-Lexika : Eintrag zu Alkanole / Alkohole im Lexikon der Chemie , abgerufen am 1. Juli 2008 . Paula Yurkanis Bruice : Organische Chemie , Pearson Education Inc . , 2007 , 5. Auflage , S. 829 , ISBN 978-3-8273-7190-4 . Paula Yurkanis Bruice : Organische Chemie , Pearson Education Inc . , 2007 , 5. Auflage , S. 830–831 , ISBN 978-3-8273-7190-4Ceresana : Markstudie Lösungsmittel , 2. Auflage ( UC-3505 ) , April 2012 . Paula Yurkanis Bruice : Organische Chemie , Pearson Education Inc . , 2007 , 5. Auflage , S. 412 , ISBN 978-3-8273-7190-4 . N / A 
+
+Aluminium ( im angloamerikanischen Sprachraum vielfach auch Aluminum ) ist ein chemisches Element mit dem Elementsymbol Al und der Ordnungszahl 13. Im Periodensystem gehört Aluminium zur dritten Hauptgruppe und zur 13. 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 99,0 % Al ) , Reinstaluminium ( min 99,7 % 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 19. Jahrhundert .
+Im frühen 20. 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 .
+2016 wurden weltweit 115 Mio. Tonnen Aluminiumoxid ( Al2O3 ) produziert . Daraus hat man 54,6 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 40 % .
+Geschichte 1782 vermutete Lavoisier als erster , dass es sich bei der 1754 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 1825 dem Dänen Hans Christian Ørsted durch Reaktion von Aluminiumchlorid ( AlCl3 ) mit Kaliumamalgam , wobei Kalium als Reduktionsmittel diente :
+Davy , der sich lange Zeit ebenfalls an der Darstellung des neuen Elements versucht hatte , führte ab 1807 die Namensvarianten alumium , aluminum und aluminium ein , von welchen die letzten beiden im Englischen bis heute nebeneinander fortbestehen .
+1827 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 1846 und publizierte ihn 1859 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 .
+1886 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 .
+1889 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 19. Jahrhunderts stand das Metall in solchem Ansehen , dass man daraus gefertigte Metallschiffe auf den Namen Aluminia taufte .
+Vorkommen Aluminium ist mit einem Anteil von 7,57 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 53 Prozent den höchsten Aluminiumanteil einer Verbindung .
+Einen ähnlich hohen Aluminiumanteil haben die noch selteneren Minerale Akdalait ( etwa 51 Prozent ) und Diaoyudaoit ( etwa 50 Prozent ) .
+Insgesamt sind bisher ( Stand : 2017 ) 1156 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 60 Prozent Aluminiumhydroxid ( Al ( OH ) 3 und AlO ( OH ) ) , etwa 30 Prozent Eisenoxid ( Fe2O3 ) und Siliciumdioxid ( SiO2 ) .
+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 5 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 1978 durch B. V. Oleinikov , A. V. Okrugin , N. V. Leskova in Mineralproben aus der Billeekh Intrusion und dem Dyke OB-255 in der Republik Sacha ( Jakutien ) im russischen Föderationskreis Ferner Osten . Insgesamt sind weltweit bisher rund 20 Fundorte ( Stand 2019 ) 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-20-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 : 1980-085a ) . Gemäß der Systematik der Minerale nach Strunz ( 9. Auflage ) wird Aluminium unter der System-Nummer 1.AA.05 ( Elemente – Metalle und intermetallische Verbindungen – Kupfer-Cupalit-Familie – Kupfergruppe ) eingeordnet .
+In der veralteten 8. Auflage der Strunz ’ schen Mineralsystematik ist Aluminium dagegen noch nicht aufgeführt .
+Nur im zuletzt 2018 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 .
+I / A.3-05 . Die vorwiegend im englischsprachigen Raum verwendete Systematik der Minerale nach Dana führt das Element-Mineral unter der System-Nr .
+01.01.01.05 .
+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 ) Datei : Aluminium - Trend Förderung.svg
+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 ( Al2O3 ) 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 1200 ° C kalziniert und das entstehende Natriumaluminat anschließend mit Natronlauge gelöst .
+Datei : Schmelzflusselektrolyse von Aluminium.svg 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 963 ° 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 .
+Datei : Aluwagen.jpg Datei : Tovarna glinice in aluminija Kidričevo - kupi aluminija 1968.jpg
+Aufgrund der hohen Bindungsenergie durch die Dreiwertigkeit des Aluminiums ist der Prozess recht energieaufwändig .
+Pro produziertem Kilogramm Rohaluminium müssen 12,9 bis 17,7 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 800 ° 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 CaF2 ) abgedeckt ( siehe dazu Aluminiumrecycling ) .
+Dabei entsteht als Nebenprodukt Salzschlacke , die noch ca. 10 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 300 bis 500 Kilogramm Salzschlacke , verunreinigt mit Dioxinen und Metallen , entsteht , deren mögliche Wiederverwertung aber Stand der Technik ist .
+Eigenschaften Physikalische Eigenschaften Datei : Aluminum Spectra.jpg Datei : Aluminium bar surface etched.jpg Datei : Macroetched Aluminium.JPG
+Mikrostruktur Aluminium erstarrt ausschließlich in einem kubisch flächenzentrierten Raumgitter in der .
+Der Gitterparameter beträgt bei Reinaluminium 0,4049 nm ( entspricht 4,05 Å ) bei 4 Formeleinheiten pro Elementarzelle .
+Leerstellen kommen mit einer Dichte von 1,3 × 10 − 4 bei 500 ° C vor , bei Raumtemperatur sind es nur noch 10 − 12.
+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 10 − 4 erhöht werden .
+Die Versetzungs ­ dichte liegt bei 10 − 7 , 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 103 bis 200 ( 10 − 7 J / cm - ) 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 2,6989 g / cm ³ ( 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 + 3 % bis − 2 % ab .
+Spezielle Legierungen mit Lithium haben eine 15 % 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 45 N / mm - , die Streckgrenze bei 17 N / mm - und die Bruchdehnung bei 60 % , während bei handelsüblich reinem Aluminium die Zugfestigkeit bei 90 N / mm - liegt , die Streckgrenze bei 34 N / mm - und die Bruchdehnung bei 45 % . Die Zugfestigkeit seiner Legierungen liegt dagegen bei bis zu 710 N / mm - ( Legierung 7068 ) .
+Sein Elastizitätsmodul liegt bei etwa 70 GPa , einem häufig angegebenen Wert .
+Für Reinaluminium wird ein Wert von 66,6 GPa angegeben , die Werte schwanken jedoch von 60 bis 78 GPa .
+Der G-Modul liegt bei 25,0 kN / mm - , die Querkontraktionszahl ( Poissonzahl ) bei 0,35 .
+Thermische Eigenschaften Die Schmelztemperatur liegt bei 660,2 ° C und die Siedetemperatur bei 2470 ° C.
+Die Schmelztemperatur ist deutlich niedriger als die von Kupfer ( 1084,6 ° C ) , Gusseisen ( 1147 ° C ) und Eisen ( 1538 ° C ) , was Aluminium zu einem guten Gusswerkstoff macht .
+Bei einer Sprungtemperatur von 1,2 K wird reines Aluminium supraleitend .
+Die Wärmeleitfähigkeit liegt mit 235 W / ( K 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 23,1 µm · m − 1 · K − 1 recht hoch .
+Die Schwindung , also die Volumenabnahme beim Erstarren liegt bei 7,1 % .
+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 0,62 × 10 − 9 m ³ / kg , womit Aluminium praktisch gesehen unmagnetisch ist .
+Chemische Eigenschaften Datei : Alkorrosion.webm 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 4 bis 9 sehr korrosionsbeständig , sie erreicht eine Dicke von etwa 0,05 µ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 2. 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 1 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 500 µ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 27Al vor ; Aluminium gehört damit zu den Reinelementen .
+Dieses Isotop , das stabil ist und im Kern 14 Neutronen und 13 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 26Al mit einer Halbwertszeit von einer Million Jahren .
+Durch Elektroneneinfang oder Beta-Zerfall entsteht daraus 26Mg , durch Einfangen eines Neutrons und anschließenden Gamma-Zerfall 27Al .
+Die Isotope 24Al bis 29Al ( Außer 26Al und 27Al ) haben Halbwertszeiten zwischen wenigen Sekunden und einigen hundert Sekunden .
+23Al zerfällt mit einer Halbwertszeit von nur 0,13 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 75 % und werden weiter unterteilt nach dem Hauptlegierungselement ( en ) in Reinaluminium mit Aluminiumgehalten von 99,0 % bis 99,9 % .
+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 ( AlMg ( Mn ) ) .
+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 ( AlZnMg ( Cu ) ) haben hohe Festigkeiten – im Falle 7075 über 500 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 150 bis 190 ° C.
+Typische aushärtbare Aluminiumknetlegierungen sind : AlMgSi , AlCuMg , AlZnMg .
+Die erste hochfeste , aushärtbare Aluminiumlegierung AlCuMg bekam 1907 die Handelsbezeichnung Duraluminium , kurz „ Dural “ genannt .
+Wirtschaftliche Bedeutung Aluminium ist nach Stahl der zweitwichtigste metallische Werkstoff .
+2016 wurden weltweit 115 Mio. Tonnen produziert .
+Datei : Al-Cu-spotprice.svg Der Aluminiumpreis bewegte sich am Weltmarkt seit 1980 um den Wert von 2000 Dollar pro Tonne ( Reinheit von 99,7 % ) .
+Er ist jedoch relativ volatil , 2016 fiel er auf um die 1500 Dollar pro Tonne , während er 2017 wieder bei annähernd 2000 Dollar lag .
+Verwendung Konstruktionswerkstoff allgemein Datei : Aldruckguss.jpg 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 3 kg schweres Gussstück , galt bis 1884 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 2010 mit ca. 35 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 50 % des Aluminiums im Fahrzeugbau verwendet ( Stand : 2015 ) .
+Autos Bei Autos werden Aluminiumwerkstoffe verwendet für verschiedene Motor ­ komponenten – 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 1950ern und das Strangpressen von Großprofilen .
+Die Verwendung von Aluminium hat die gesamte Bauweise von Schienenfahrzeugen verändert .
+Bis etwa 1970 waren Konstruktionen aus Stahlrohren üblich , danach vermehrt verschweißte Profile aus Aluminium .
+Flugzeuge Bereits in der Anfangsphase der Luftfahrt wurden Aluminiumwerkstoffe genutzt , 1903 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 1915 , bestand allerdings aus Stahlblechen in Schalenbauweise .
+Die entscheidende Entwicklung zur Verwendung von Aluminium im Flugzeugbau stammt von 1906 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 60 % 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 Datei : Kurzschlussl.jpg 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 A380 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 Datei : Transistoroffen.jpg 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 2000er-Jahre ausschließlich Aluminium als Leiterbahnmaterial eingesetzt .
+Bis in die 1980er-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 2000er-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-k + Metal-Gate-Technik hat Aluminium nach gut 25 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 Datei : Moka2.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 .
+2017 entfielen 17 % der europäischen Aluminiumverwendung auf Verpackungen .
+Tolkki20091027.jpg | Getränkedose Optik und Lichttechnik Datei : Image-Metal-reflectance.png 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 1000 ° C Hitze was ungeachtet der Brandschutzklasse Löcher in die Aluminiumlegierung brennt , die zwischen 600 ° C und 660 ° C nach unten fließt oder tropft .
+Imperial War Museum 2008cropped.jpg | Das Imperial War Museum von AußenLibeskindSpaceFrameTower.jpg | Dachkonstruktion aus Aluminium beim Imperial War MuseumAluminium heat reflector with hole melted through by high temperatures.jpg | Aluminiumblech , punktuell über 600 ° C erhitzt .
+Weitere Anwendungen In der Raketentechnik besteht der Treibstoff von Feststoffraketen zu maximal 30 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 Eisen ( III ) - oxid umgesetzt wird .
+Bei dieser stark exothermen Reaktion entstehen Temperaturen bis zu 2500 ° 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-6Al-4V , der Sorte die etwa 50 % aller Titanlegierungen ausmacht . Dort ist Aluminium mit 6 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 Datei : Materialprobe BBS.jpg Datei :D atenschieber für den Aluminium Guss.jpg
+Das Gießen von Aluminium wird als Aluminiumguss bezeichnet .
+Es gehört aufgrund seines vergleichsweise geringen Schmelzpunktes von 660 ° C ( Gusseisen etwa 1150 ° C , Stahl 1400 ° C bis 1500 ° 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 577 ° C. Der Massenanteil von Aluminium aller in Gießereien erzeugten Produkte beträgt etwa 11 % ( Gusseisen 76 % , Stahlguss 9 % ) und ist damit in der Gießerei das mit Abstand wichtigste Nichteisenmetall ( NE-Metalle ) noch vor Kupfer mit 1,5 % . Der Anteil am NE-Metallguss von Aluminium beträgt etwa 87 % .
+In Deutschland wurden 2011 etwa 840.000 Tonnen Aluminium in Gießereien verarbeitet ; Etwa 76 % 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 1930er-Jahren kommt der Strangguss vermehrt zum Einsatz .
+Dafür gibt es spezielle Anlagen die bis zu 96 Rundbarren gleichzeitig herstellen können mit Gießlängen zwischen 3 und 7 Metern teils bis zu 10 Metern .
+Die Durchmesser liegen bei 75 bis 700 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 60 % spart .
+Umformende Verfahren Etwa 74 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 800.000 Tonnen pro Jahr .
+Verarbeitet werden Barren mit bis zu 30 Tonnen Masse .
+Sie haben Abmessungen von bis zu 8,7 Metern Länge , 2,2 Metern Breite und 60 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 20 bis 30 mm vor .
+Anschließend folgt das Kaltwalzen auf Enddicke .
+Kaltwalzwerke haben Kapazitäten von 300.000 bis 400.000 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 Datei : Extruded aluminium section x3.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örper ­ profilen 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 450 bis 500 ° 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 Datei : SchruppenDrehen.jpg
+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 50 bis 150 Milligramm Aluminium . Diese verteilen sich zu ungefähr 50 Prozent auf das Lungengewebe , zu 25 Prozent auf die Weichteile und zu weiteren 25 Prozent auf die Knochen .
+Aluminium ist damit ein natürlicher Bestandteil des menschlichen Körpers .
+99 bis 99,9 Prozent der üblicherweise in Lebensmitteln aufgenommenen Menge von Aluminium ( 10 bis 40 mg pro Tag ) werden unresorbiert über den Kot wieder ausgeschieden .
+Chelatbildner ( Komplexbildner ) wie Citronensäure können die Resorption auf 2 bis 3 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 1 ‰ beziehungsweise 3 ‰ 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 1–2 % der reorbierten Dosis sich im Körper anhäufen . In einem Leben häuft man etwa 35 mg Aluminium im Körper an .
+Im Blut ist Al3 + überwiegend ( zu etwa 80 % ) an Transferrin gebunden .
+16 Prozent liegen als [ Al ( PO4 ) ( OH ) ] − , 1,9 Prozent als Citrat-Komplex , 0,8 Prozent als Al ( OH ) 3 und 0,6 Prozent als [ Al ( OH ) 4 ] − vor . Das Blut Neugeborener enthält bereits Aluminiumionen , die aus dem materalen Kreislauf stammen . Die Serumkonzentrationen von etwa 6–10 μg / l 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 5,0 , werden Al3 + - 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 Al3 + 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 1960er-Jahren die Seen übersäuert , wodurch mehr Al3 + - Ionen in Lösung gingen und empfindliche Fische verendeten . Auch in Norwegen wurde dieser Zusammenhang bei einem Forschungsprojekt in den 1970er-Jahren festgestellt .
+Bei pH-Werten über 5,0 ist Aluminium als polymeres Hydroxykation an der Oberfläche von Silicaten gebunden .
+Bei pH-Werten von 4,2 bis 5 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 5 mg / kg 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 1042 mg / kg 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 3,5 mg / Tag / Person 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 0,2 –0 , 4 mg / l 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 0,2 mg / l 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 1,6 und 13 mg Aluminium pro Tag über die Nahrung auf . Dies entspricht einer wöchentlichen Aufnahme von 0,2 bis 1,5 mg Aluminium pro kg Körpergewicht bei einem 60 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 15 μg / l 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 1 mg Aluminium pro kg Körpergewicht fest .
+Aluminium ist als Lebensmittelzusatzstoff unter der Bezeichnung E 173 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 1970er Jahren bei langjährigen Hämodialysepatienten durch starke Aluminiumzufuhr beobachtet ( „ Dialysis Encephalopathy Syndrome “ ) . imp 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 2007 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 2014 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 2008 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 3777 Personen im Alter ab 65 Jahren seit 1988 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 : 0,01 mg / l Aluminium im Blut gilt als Normalwert , Werte über 0,06 mg / l sprechen für übermäßige Belastung und Werte über 0,2 mg / l im Blut gelten als toxisch .
+Aspekte der Ökobilanz Datei : Aluminium foam.jpg Datei : Recycling-Code-41.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 12,9 und 17,7 kWh elektrische Energie benötigt . Bei der Stromerzeugung für die Produktion von einem Kilogramm Aluminium werden im deutschen Kraftwerkspark 8,4 kg CO2 freigesetzt , im weltweiten Durchschnitt etwa 10 kg .
+Es ist aber auch zu bedenken , dass aufgrund des Kostenfaktors Energie die Elektrolyse verstärkt an Orten erfolgt , an denen auf billige , CO2-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 CO2-frei , da der bei der Schmelzflusselektrolyse entstehende Sauerstoff mit dem Kohlenstoff der Elektroden zu CO2 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. 16,5 kg CO2 pro kg Aluminium-Konsumgut .
+Die europaweite Recyclingrate von Aluminium liegt bei 67 Prozent .
+In Österreich gelangen ( laut einer Studie aus dem Jahr 2000 ) 16.000 Tonnen Aluminium pro Jahr über Verpackungen in den Konsum , ebenso gelangen 16.000 Tonnen Aluminium ohne Wiederverwertung in den Hausmüll ( dabei sind unter anderem auch die Aluminiumhaushaltsfolien eingerechnet , die nicht als „ Verpackung “ gelten ) .
+66 Prozent der Verpackungen im Restmüll sind Aluminium [ getränke ] dosen .
+Diese liegen nach der Müllverbrennung in der Asche noch metallisch vor und machen in Europa durchschnittlich 2,3 Prozent der Asche aus . In der EU werden durchschnittlich 70 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-41 ( ALU ) ) . Aluminium ist dabei besser rezyklierbar als Kunststoffe , wegen Downcycling bei nicht sortenreiner Erfassung jedoch etwas schlechter wiederverwertbar als Stahl .
+Beim Aluminiumrecycling wird nur 5 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 ( Co ( NO3 ) 2 ) auf der Magnesia-Rinne nach .
+Dabei entsteht das Pigment Thénards Blau , ein Cobaltaluminiumspinell mit der Formel CoAl2O4 .
+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 Al ( OH ) 3 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 Na3 [ AlF6 ] freigesetzt werden , eine erneute Rotfärbung des Phenolphthaleins .
+Nachweis als fluoreszierender Morinfarblack Datei : Aluminium-Morin-Reaktion.svg 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 , CH3COOH ) an , so ist unter UV-Strahlung ( λ = 366 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 Al ( III ) in neutralen sowie essigsauren Lösungen in Verbindung mit Morin eine fluoreszierende kolloidale Suspension bildet .
+Verbindungen Datei :C orundum-215245.jpg Datei : Hybridschaltung.jpg Datei : Kaaliumi maarjase monikristallid2.JPG
+Aluminiumoxid Al2O3 ( 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 Al ( OH ) 3 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 NaAl ( OH ) 4 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 , KAl ( SO4 ) 2 · 12H2O ) .
+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 ( LiAlH4 ) 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 ( PO4 3 − ) , unter bestimmten Bedingungen Wasser abzuspalten und infolgedessen zu polymerisieren , sind verschiedene Aluminiumphosphate bekannt : Aluminiumorthophosphat ( AlPO4 ) Aluminiummetaphosphat ( Al ( PO3 ) 3 ) Monoaluminiumphosphat ( Al ( H2PO4 ) 3 ) Aluminiumpolyphosphat
+In der Natur treten Aluminiumphosphate meist in Form von Doppelsalzen auf .
+Beispiele hierfür sind etwa der Wavellit ( Al3 ( PO4 ) 2 ( F , OH ) 3 · 5H2O ) oder der Türkis , ein Mischphosphat aus Kupfer und Aluminium / Eisen : Cu ( Al , Fe ) 6 ( PO4 ) 4 ( OH ) 8 · 4 H2O . 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
+Literatur Zur Geschichte
+Hans Joliet ( Hrsg. ) : Aluminium – Die ersten hundert Jahre . VDI Verlag , 1988 , ISBN 3-18-400802-9 . Deutsche Fachliteratur
+Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage .
+Springer , 2014 , ISBN 978-3-662-43806-0 . Aluminium-Taschenbuch .
+Aluminium-Verlag , Düsseldorf : Band 1 : Grundlagen und Werkstoffe , 16. Auflage , 2002 . Band 2 : Umformen von Aluminium-Werkstoffen , Gießen von Aluminium-Teilen , Oberflächenbehandlung von Aluminium , Recycling und Ökologie , 15. Auflage 1999 , 672 S. Band 3 : Weiterverarbeitung und Anwendung , 16. Auflage , 2003 , 863 S. Luitgard Marschall : Aluminium .
+Metall der Moderne .
+Oekom , München 2008 , ISBN 978-3-86581-090-8 . Englische Fachliteratur
+George E. Totten , D. Scott MacKenzie : Handbook of Aluminum .
+Marcel Dekker , Yew York , Basel : Band 1 : Physical Metallurgy and Processes .
+2003 , 1296 S. Band 2 : Alloy Production and Materials Manufacturing .
+2003 , 724 S. Joseph R. Davis ( Hrsg. ) : Aluminum and Aluminum Alloys .
+4. Auflage , 1998 , 784 S. Weblinks MATERIAL ARCHIV : Aluminium – Umfangreiche Materialinformationen und Bilder .
+Newsseite des Gesamtverbands der Aluminiumindustrie Lars Fischer : Wie gefährlich ist Aluminium ? Spektrum.de , 14. Juli 2014 . Einzelnachweise Norman N. Greenwood , Alan Earnshaw : Chemie der Elemente . Wiley-VCH , Weinheim 1988 , ISBN 3-527-26169-9 . N. A. Figurowski , Die Entdeckung der chemischen Elemente und der Ursprung ihrer Namen , in deutscher Übersetzung von Leo Korniljew / Ernst Lemke , Moskau 1981 , ISBN 3-7614-0561-8 , S. 64. Norman N. Greenwood , Alan Earnshaw : Chemistry of the Elements . 2. Auflage . Butterworth–Heinemann , 1997 , ISBN 0-08-037941-9 , S. 217. auf Webmineral ( englisch ) . Fundortliste für Aluminium beim Mineralienatlas und bei Mindat IMA / CNMNC List of Mineral Names ; November 2018 ( PDF 1,7 MB ; Aluminium siehe S. 7 ) IMA / CNMNC List of Mineral Names ; 2009 ( PDF 1,8 MB , Aluminium siehe S. 7 ) . Rudolf Debar : Die Aluminium-Industrie . 2. Auflage . Springer 1925 , S. 55 ff. ( ) . ( PDF , Seminararbeit ; 527 kB ) S. 10. Matthias Dienhart : ( PDF ; 1,3 MB ) Dissertation . Rheinisch-Westfälischen Technischen Hochschule Aachen , Juni 2003 , S. 7. Rainer Quinkertz : Optimierung der Energienutzung bei der Aluminiumherstellung . Dissertation . Rheinisch-Westfälische Technische Hochschule Aachen , 2002 , S. 75–77 . 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 2000 , ISBN 3-85457-534-3 . ( umweltbundesamt.at PDF ) Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 71–78 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 212. Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 212–213 . D. R. Askeland : Materialwissenschaft . Spektrum , Heidelberg 1996 , ISBN 3-86025-357-3 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 79. Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 77. Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 214. Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 212–214 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 212 , 214. Der Technologie-Leitfaden von ELB . In : Eloxalwerk Ludwigsburg . Website des Luftfahrt-Bundesamtes.George E. Totten , D. Scott MacKenzie : Handbook of Aluminum Band 1 : Physical Metallurgy and Processes . Marcel Dekker , Yew York , Basel . 2003 , S. 33–34 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 98–99 , 167–168 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 189–190 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 167–168 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 99. Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 117–118 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 102–103 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 152–153 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 125–126 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 142–143 . Aluminium-Taschenbuch – Band 1 , 16. Auflage , Aluminium-Verlag , Düsseldorf 2002 , S. 153. Preisindex an der London Metall Exchange D. R. Askeland : Materialwissenschaft . Spektrum , Heidelberg 1996 , S. 364. D. R. Askeland : Materialwissenschaft . Spektrum , Heidelberg 1996 , S. 362. world-aluminium.org : The Global Aluminium Industry 40 years from 1972 ( PDF ; 308 kB ) , abgerufen am 17. November 2013 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 34–39 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 39–41 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 52–57 . vgl. Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 63–64 . Verheilung von Aluminium : Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 65. https://www.spotlightmetal.com/how-environmentally-friendly-is-the-european-aluminium-industry-gal-691065/?p=3 Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 57–59 . N / A Bernd Leitenberger : In : Bernd Leitenbergers Web Site . Aluminium auf Feuerwerk-Wiki : www.feuerwerk.net . Eberhard Roos , Karl Maile : Werkstoffkunde für Ingenieure , 4. bearbeitete Auflage , 2011 , Springer , S. 252. A. Herbert Fritz , Günter Schulze : Fertigungstechnik . 10. Auflage . Springer , Berlin 2012 , ISBN 978-3-642-29785-4 , S. 36. Rüdiger Bähr : Urformen in : Molitor , Grote , Herold , Karpuschewski : Einführung in die Fertigungslehre , Shaker , 2008 , S. 19. Heiko Lickfett : Wirtschaftliche Bedeutung der Gießereiindustrie in : Andreas Bühring-Polaczek , Walter Michaeli , Günter Spur ( Hrsg. ) : Handbuch Urformen , Hanser , 2014 , S. 13–16 . Bernhard Ilschner , Robert F. Singer : Werkstoffwissenschaften und Fertigungstechnik : Eigenschaften , Vorgänge , Technologien . 5. Auflage . Springer , Berlin 2010 , S. 449–450 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 419–422 . Fritz Klocke , Wilfried König : Fertigungsverfahren 4 : Umformen . 5. Auflage . Springer , Heidelberg , S. 89–90 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 441–450 . Friedrich Ostermann : Anwendungstechnologie Aluminium . 3. Auflage . Springer , 2014 , S. 451–462 . Eberhard Roos , Karl Maile : Werkstoffkunde für Ingenieure : Grundlagen , Anwendung , Prüfung . 4. Auflage . Springer , Berlin 2011 , S. 240. Wilfried König , Fritz Klocke : Fertigungsverfahren 1 : Drehen , Bohren , Fräsen . 8. Auflage . Springer 2008 , ISBN 978-3-540-23458-6 , S. 319. Thorsten Zurell : Absaugung von Aluminium-Schleifstäuben und - Schweißrauchen im Automobilbau mit ex-geschützten Filtersystemen . In : Gefahrstoffe – Reinhalt . Luft . 62 , Nr. 11/12 , 2002 , S. 455–460 . Udo M. Spornitz : Anatomie und Physiologie . Lehrbuch und Atlas für Pflege- und Gesundheitsfachberufe . Springer , Berlin 2010 , ISBN 978-3-642-12643-7 . Wilfried Puwein : Das „ Waldsterben “ in Österreich und seine ökonomischen Folgen . Nr. 11 , 1989 ( wifo.ac.at PDF ; 792 kB ) . Aluminium in Lebensmitteln : lebensmittel.org . 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 . 754 , 2008 , S. 1–34 ; doi : 10.2903/j . efsa.2008.754 . Aluminium in der Datenbank für Lebensmittelzusatzstoffe . Chemisches und Veterinäruntersuchungsamt Karlsruhe : ( PDF ) 2004 . H. Eschnauer : Die Verwendung von Aluminium in der Weinwirtschaft . Vitis , 1 , 1958 , S. 313–320 , zitiert von S. 319 , vitis-vea.de ( PDF ; 729 kB ) . H. E. Müller , W. Dünnleder , W. Mühlenberg , R. Ruckdeschel : Legionellen – ein aktives Problem der Sanitärhygiene . 3. Auflage . expert-Verlag , ISBN 978-3-8169-2725-9 , S. 14 ( ) . H. J. Gitelman : Physiology of Aluminum in Man. In : Aluminum and Health . CRC Press , 1988 , ISBN 0-8247-8026-4 , S. 90 ( ) . Bundesinstitut für Risikobewertung ( Hrsg. ) : ( PDF ; 106 kB ) 22. Juli 2007 . Bundesinstitut für Risikobewertung ( Hrsg. ) : ( PDF ; 144 kB ) 26. Februar 2014 . The Alzheimer ’ s Society . Abgerufen am 30. Januar 2009 . H. Lüllmann , K. Mohr , M. Wehling , L. Hein : Pharmakologie und Toxikologie , Thieme Verlag , 2016 , ISBN 978-3-13-368518-4 , S. 622–623 . auf staufenbiel.de ( PDF ) S. 16. 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 , 2000 ( rma . at PDF ) . International Aluminium Journal . Nr. 6 , 2013 , S. 81 ff. International Aluminium Journal . Nr. 91 , 2015 , S. 53. Uwe Kerkow , Jens Martens , Axel Müller : ( PDF ) Aachen / Bonn / Stuttgart 2012 , ISBN 978-3-943126-07-5 , S. 29. Manfred Sietz , Stefan Seuring : Ökobilanzierung in der betrieblichen Praxis . Eberhard Blottner , Taunusstein 1997 , S. 103 ( ) . In : The Economist . 2007 . J. Strähle , E. Schweda : Jander · Blasius – Lehrbuch der analytischen und präparativen anorganischen Chemie , 16. Auflage , Hirzel , Stuttgart 2006 , ISBN 3-7776-1388-6 , S. 626. 
+
+Antimon [ ] ( von lateinisch Antimonium , vermutlich von arabisch „ al-ithmîd ( un ) “ ( , Antimonsulfid bzw. Stibnit ) ) ist ein chemisches Element mit dem Elementsymbol Sb ( von ‚ ( Grau- ) Spießglanz ‘ ) und der Ordnungszahl 51. Im Periodensystem steht es in der 5. Periode und der 5. Hauptgruppe , bzw. 15. 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 11. Jahrhundert findet sich der lateinische Begriff für die mineralische Arzneidroge antimonium zur innerlichen Therapie von Krankheiten dann bei Constantinus Africanus .
+Im 17. 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 Datei : Antimony-201382.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 . 1.CA.05 als Mineral anerkannt .
+Weltweit konnte gediegenes Antimon bisher ( Stand : 2011 ) an rund 300 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 264 Antimon-Minerale bekannt ( Stand : 2010 ) . Industriell genutzt wird überwiegend das Sulfid-Mineral Stibnit Sb2S3 ( Grauspießglanz ) mit einem Gehalt von maximal 71,7 % Sb.
+Das Mineral mit dem höchsten Sb-Gehalt in einer chemischen Verbindung ist die natürliche Antimon-Arsen-Legierung Paradocrasit ( max. 92 % ) .
+Allerdings kommt sie mit nur drei Fundorten , im Gegensatz zum Stibnit ( rund 2500 Fundorte ) , sehr viel seltener vor .
+Weitere Quellen für Antimon sind die Minerale Valentinit Sb2O3 ( Weißspießglanz ) , Breithauptit NiSb ( Antimonnickel , Nickelantimonid ) , Kermesit Sb2S2O ( Rotspießglanz ) und Sb2S5 ( Goldschwefel ) .
+Gewinnung und Darstellung Datei : Antimon - Trend Förderung.svg 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 21. Jahrhunderts zwischen 110.000 und 160.000 Tonnen pro Jahr an Antimon gefördert .
+Seit 1900 hat sich damit die Fördermenge mehr als verzehnfacht .
+87 % der Antimonproduktion findet in China statt ( Stand : 2015 ) .
+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 = 431 pm und c = 1127 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 SbH3 .
+Von Luft und Wasser wird Antimon bei Raumtemperatur nicht angegriffen .
+Oberhalb des Schmelzpunkts verbrennt es in Luft mit bläulich-weißer Flamme zu Antimon ( III ) - 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 + 3 und + 5 vor .
+In Metallantimoniden wie Kaliumantimonid K3Sb bildet es Sb3 − - Ionen .
+Isotope Es existieren zwei stabile Antimon-Isotope : 121Sb und 123Sb .
+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 16. und 17. Jahrhundert zu einem ( iatrochemischen ) „ Leitarzneimittel “ , war aber – wie auch andere paracelsische Medikamente – umstritten und in Frankreich zwischen 1615 und 1688 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 19. 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 Datei : Streichholz.jpg
 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
+Antimontrisulfid in Bremsbelägen von Fahrzeugen Antimon ( V ) - 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 ( Antimon ( III ) - 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 ( Nd : YAG ) .
+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 200 bis 1200 mg tödlich sein .
+In der Toxikologie sind drei Antimon-Formen bekannt , von denen das gasförmige Antimonhydrid ( Stiban , SbH3 ) 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 95 % 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 90 % innerhalb des ersten Tages nach Aufnahme ausgeschieden , die übrigen 10 % aufgrund einer langsameren Eliminationskinetik über 16 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 Antimon ( III ) - oxid als möglicherweise krebserzeugende Substanz ein .
+In der EU gilt für Trinkwasser ein Grenzwert von 5 µg / l.
+Untersuchungen von in PET-Flaschen abgefüllten Fruchtsäften ( für die keine Richtlinien existieren ) ergaben Antimonkonzentrationen bis zu 44,7 µg / l in unverdünnten Saftkonzentraten .
+Antimon wurde 2016 von der EU gemäß der Verordnung ( EG ) Nr. 1907/2006 ( 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 2018 und wird von Deutschland durchgeführt .
+Nachweis Datei : FlammenfärbungSb.png 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 Sb ( III ) , Sb ( V ) und Sb ( III ) / ( V ) zu metallischem Antimon : 2 Sb3 + + 3 Fe → 2 Sb + 3 Fe2 +
+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 SbH3 genannt.Giftiges Gas , das sich aus Antimon und einwirkenden Säuren bildet .
+Distiban ( Sb2H4 ) Halogenverbindungen Antimon ( V ) - fluorid ( SbF5 ) bildet ( nach VSEPR ) eine quadratische Pyramide aus und hybridisiert dabei zu sp3d Antimon ( V ) - chlorid ( SbCl5 ) Antimon ( III ) - fluorid ( SbF3 ) Antimon ( III ) - chlorid ( SbCl3 ) Antimon ( III ) - bromid ( SbBr3 ) Antimon ( III ) - iodid ( SbI3 ) Sauerstoffverbindungen Antimon ( III ) - oxid ( Antimontrioxid , Sb2O3 ) Antimon ( III , V ) - oxid ( Antimontetroxid , Sb2O4 ) Antimon ( V ) - oxid ( Antimonpentaoxid , Sb2O5 ) antimonige Säure / Antimontrihydroxid ( H3SbO3/Sb ( OH ) 3 ) antimonige Säure / Antimon ( III ) - Säure , SbOOH bzw. HSbO2
+Antimonsäure ( HSb ( OH ) 6 ) Schwefelverbindungen Antimontrisulfid , auch Antimonglanz genannt ( Sb2S3 ) 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 ( Sb2S5 ) Sonstige Verbindungen Antimon ( V ) - chloridfluorid ( SbCl4F ) ( 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 . 9 ) .
+Arlesheim / Schwäbisch Gmünd 1976 . Weblinks Mineralienatlas : Antimon ( Wiki ) Chemie im Alltag : Mozart – Opfer einer Antimonvergiftung ? Einzelnachweise Willem F. Daems : Zu Helmut Gebelein : Alchemie . München : Eugen Diederichs 1991 . In : Würzburger medizinhistorische Mitteilungen . Band 11 , 1993 , S. 405–407 , hier : S. 406. Doris Schwarzmann-Schafhauser : Antimonstreit . In : Werner E. Gerabek u. a. ( Hrsg. ) : Enzyklopädie Medizingeschichte . De Gruyter , Berlin / New York 2005 , ISBN 3-11-015714-4 , S. 72. Mindat – Sala Silver Mine , Sala , Västmanland , Sweden . IMA / CNMNC List of Mineral names – Antimony ( englisch , PDF 1,8 MB , S. 14 ) . Mindat – Localities for Antimony ( englisch ) . . auf www.geoscience.org.za ( englisch ) . Webmineral - Mineral Species sorted by the element Sb ( Antimony ) . Mindat – Paradocrasite . Mindat – Stibnite . ddc . arte.tv Lautenschläger u. a. : Taschenbuch der Chemie . Verlag Harri Deutsch , Frankfurt am Main 2001 . Ulrich Arndt : Der „ Magnet der Weisen “ - Alchemistische Transmutation des Antimon . In : Paracelsus . November 2005 , S. 12–17 . ( Online-Version ) . Wolf-Dieter Müller-Jahncke , Christoph Friedrich : Geschichte der Arzneimitteltherapie . Deutscher Apothekerverlag , Stuttgart 1996 , ISBN 3-7692-2038-2 , S. 65–66 . Doris Schwarzmann-Schafhauser : Antimonstreit . In : Werner E. Gerabek u. a. ( Hrsg. ) : Enzyklopädie Medizingeschichte . De Gruyter , Berlin / New York 2005 , ISBN 3-11-015714-4 , S. 72. Katja Bauer : In : badische-zeitung.de , 4. Juni 2016 . Wendy Macías Konstantopoulos , Michele Burns Ewald , Daniel S. Pratt : Case 22-2012 : A 34-Year-Old Man with Intractable Vomiting after Ingestion of an Unknown Substance . In : New England Journal of Medicine . 367 , 2012 , S. 259–268 . Bundesamt für Gesundheit Schweiz ( BAG ) : ( PDF ) 23. August 2007 . Hollemann-Wiberg : Lehrbuch der anorganischen Chemie . 90. Auflage . S. 483. 
+
+Argon ( griechisch „ träge “ ) ist ein chemisches Element mit dem Symbol Ar ( bis 1957 nur A ) und der Ordnungszahl 18. Im Periodensystem steht es in der 8. Hauptgruppe bzw. der 18. 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 0,934 % .
+Damit ist Argon der dritthäufigste Bestandteil der Erdatmosphäre , nach Stickstoff und Sauerstoff .
+Dies ist großteils auf den Zerfall des Kaliumisotops 40K zurückzuführen , bei dem 40Ar 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 1894 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 Datei : John William Strutt.jpg Einen ersten Hinweis auf das später entdeckte Argon fand Henry Cavendish , der 1783 die Reaktivität der Luft erforschte .
+Er erzeugte elektrische Entladungen in einer bestimmten Menge Luft , die mit Sauerstoff im Verhältnis von 5 :3 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 , 3. Baron Rayleigh 1892 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 N3 , 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 1894 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 31. Januar 1895 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 1898 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 36Ar und 38Ar , während das dritte stabile Isotop , 40Ar , dort nur in geringer Menge vorkommt .
+Das Verhältnis von 36Ar zu 38Ar beträgt etwa 5,7 .
+Auf der Erde ist Argon dagegen das häufigste Edelgas .
+Es macht 0,934 % 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 99 % aus dem Isotop 40Ar , das durch Zerfall des Kaliumisotops 40K 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 3–5 % Sauerstoff und 1 % Stickstoff enthält .
+Anschließend wird das Rohargon in weiteren Stufen gereinigt .
+Das Gasgemisch wird zunächst auf Raumtemperatur erwärmt und auf 4–6 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 99,9999 % ( Argon 6.0 ) 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 Datei : Argon ice 2.jpg Datei : Face-centered cubic.svg
+Argon ist bei Normalbedingungen ein einatomiges , farbloses und geruchloses Gas , das bei 87,15 K ( − 186 ° C ) kondensiert und bei 83,8 K ( − 189,3 ° C ) erstarrt .
+Wie die anderen Edelgase außer dem Helium kristallisiert Argon in einer kubisch dichtesten Kugelpackung mit dem Gitterparameter a = 526 pm bei 4 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 1,784 kg/m3 bei 0 ° C und 1013 hPa ist Argon schwerer als Luft , es sinkt also ab .
+Im Phasendiagramm liegt der Tripelpunkt bei 83,8 K und 689 hPa , der kritische Punkt bei 150,86 K , 4896 kPa sowie einer kritischen Dichte von 0,536 g/cm3 .
+In Wasser ist Argon etwas löslich .
+In einem Liter Wasser können sich bei 0 ° C und Normaldruck maximal 5,6 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 7,5 K gewonnen wird und anhand neuer Linien im Infrarotspektrum identifiziert wurde .
+Oberhalb von 27 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 FArSiF3 mit einer Argon-Silicium-Bindung .
+Argon bildet einige Clathrate , in denen es physikalisch in Hohlräume eines umgebenden Kristalls eingeschlossen ist .
+Bei − 183 ° 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 − 78 ° C. Stabil ist auch ein Clathrat von Argon in Hydrochinon .
+Isotope Insgesamt sind 23 Isotope sowie ein weiteres Kernisomer von Argon bekannt .
+Von diesen sind drei , nämlich die Isotope 36Ar , 38Ar und 40Ar , stabil und kommen in der Natur vor .
+Dabei überwiegt bei weitem 40Ar mit einem Anteil von 99,6 % am natürlichen irdischen Isotopengemisch .
+36Ar und 38Ar sind mit einem Anteil von 0,34 % beziehungsweise 0,06 % selten .
+Von den instabilen Isotopen besitzen 39Ar mit 269 Jahren und 42Ar mit 32,9 Jahren die längsten Halbwertszeiten .
+Alle anderen Isotope besitzen kurze Halbwertszeiten im Bereich von unter 10 ps bei 30Ar bis 35,04 Tagen bei 37Ar .
+40Ar wird für die Altersbestimmung von Gesteinen genutzt ( Kalium-Argon-Datierung ) .
+Dabei wird ausgenutzt , dass instabiles 40K , das in diesen enthalten ist , langsam zu 40Ar zerfällt .
+Je mehr Kalium zu Argon zerfallen ist , desto älter ist das Gestein . Das kurzlebige Isotop 41Ar kann zur Überprüfung von Gasleitungen verwendet werden .
+Durch das Durchleiten von 41Ar 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 24 bar wirkt es narkotisierend .
+Verwendung Datei : Argon.jpg Als günstigstes und in großen Mengen verfügbares Edelgas wird Argon in vielen Bereichen verwendet .
+Die Produktion betrug 1998 weltweit etwa 2 Milliarden m ³ bzw. 2 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 938 ) 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 Helium ­ haltigen 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 2014 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 : Ullmann's Encyclopedia of Industrial Chemistry . Wiley-VCH , Weinheim 2006 , doi : 10.1002/14356007.a17_485 .
+Weblinks N / A William H. Brock : Viewegs Geschichte der Chemie . Vieweg , Braunschweig 1997 , ISBN 3-540-67033-5 , S. 211–216 . John Meurig Thomas : Argon und das nichtinerte Paar : Rayleigh und Ramsay . In : Angew . Chem. 116 , 2004 , S. 6578–6584 , doi : 10.1002/ange.200461824.William Ramsay : The Rare Gases of the Atmosphere . Nobelpreisrede , 12. Dezember 1904 . Fritz Von Schröter : Die Bedeutung der Edelgase für die Elektrotechnik . In : Naturwissenschaften . 8 , 32 , 1920 , S. 627–633 , doi : 10.1007/BF02448916 . A. G. W. Cameron : Abundances of the elements in the solar system . In : Space Science Reviews . 15 , 1970 , S. 121–146 ( 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. 105 , 2000 , S. 15061–15071 ( Abstract ) . David R. Williams : Earth Fact Sheet . NASA , Greenbelt , Stand 20. Mai 2009 . Chris J. Ballentine : Geochemistry : Earth holds its breath . In : Nature . 449 , 2007 , S. 294–296 , doi : 10.1038/449294a . 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 : Ullmann's Encyclopedia of Industrial Chemistry . Wiley-VCH , Weinheim 2006 , doi : 10.1002/14356007.a17_485 . K. Schubert : Ein Modell für die Kristallstrukturen der chemischen Elemente . In : Acta Crystallographica Section B. 30 , 1974 , S. 193–204 , doi : 10.1107/S0567740874002469 . A. L. Gosman , R. D. McCarty , J. G. Hust : Thermodynamic Properties of Argon from the Triple Point to 300 K at Pressures to 1000 Atmospheres . In : Nat. Stand . Ref. Data Ser. Nat. Bur. Stand . 27 , 1969 , ( NIST webbook ) . Leonid Khriachtchev , Mika Pettersson , Nino Runeberg , Jan Lundell , Markku Räsänen : A stable argon compound . In : Nature . 406 , 2000 , S. 874–876 , doi : 10.1038/35022551 . Arik Cohen , Jan Lundell , R. Benny Gerber : First compounds with argon–carbon and argon–silicon chemical bonds . In : J. Chem. Phys. 119 , 2003 , S. 6415–6417 , doi : 10.1063/1.1613631 . R. M. Barrer , D. J. Ruzicka : Non-stoichiometric clathrate compounds of water . Part 4. – Kinetics of formation of clathrate phases . In : Transactions of the Faraday Society . 58 , 1962 , S. 2262–2271 , doi : 10.1039/TF9625802262 . G. Audi , F. G. Kondev , Meng Wang , W. J. Huang , S. Naimi : The NUBASE2016 evaluation of nuclear properties . In : Chinese Physics C. 41 , 2017 , S. 030001 , ( Volltext ) . Sicherheitsdatenblatt Argon ( PDF ; 71 kB ) , Linde AG , Stand 1. Juni 2006 . Walter J. Moore , Dieter O. Hummel : Physikalische Chemie . 4. Auflage . de Gruyter , 1986 , ISBN 3-11-010979-4 , S. 284. Zusatzstoff-Zulassungsverordnung : . Jörg Niederstraßer : Kapitel 4 : ( PDF ; 121 kB ) , Dissertation . Universität Duisburg , 2002 . Ausrüstung : Argon . bei dir-m.com , abgerufen am 20. August 2013 . In : Pharmazeutische Zeitung . 21. Mai 2014 . 
+
+Arsen [ ] ist ein chemisches Element mit dem Elementsymbol As und der Ordnungszahl 33. Im Periodensystem der Elemente steht es in der 4. Periode und der 5. Hauptgruppe , bzw. 15. 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 20. Jahrhunderts als Durchbruch in der Behandlung der Syphilis .
+Heute wird Arsentrioxid als letzte Behandlungsoption in der Therapie der Promyelozytenleukämie angewendet .
+Geschichte Datei : AlbertusMagnus.jpg Der Name Arsen geht unmittelbar auf zurück , der antiken Bezeichnung des Arsenminerals Auripigment .
+Sie findet sich schon bei Dioskurides im 1. 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ännlich / stark übersetzen lässt .
+Erst seit dem 19. Jahrhundert ist die Bezeichnung Arsen gebräuchlich .
+Das Elementsymbol wurde 1814 von Jöns Jakob Berzelius vorgeschlagen .
+Der erste Kontakt von Menschen mit Arsen lässt sich aus dem 3. 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 ( As2S3 ) und Realgar ( As4S4 ) bekannt , die etwa von dem Griechen Theophrastos , dem Nachfolger Aristoteles , beschrieben wurden .
+Auch der griechische Philosoph Demokrit hatte im 5. Jahrhundert v. Chr. nachweislich Kenntnisse über Arsenverbindungen .
+Der Leidener Papyrus X aus dem 3. 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 1. 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 .
+Arsen ( III ) - sulfid kam als Malerfarbe und Enthaarungsmittel zum Einsatz sowie zur äußerlichen als auch inneren Behandlung von Lungenkrankheiten .
+Datei : Arsenic alchemical symbol.svg Im Mittelalter wurde Arsenik ( Arsen ( III ) - oxid ) im Hüttenrauch ( staubbeladenes Abgas metallurgischer Öfen ) gefunden .
+Albertus Magnus beschrieb um 1250 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 16. Jahrhundert in die Heilkunde ein .
+Etwa zur gleichen Zeit wurden Arsenpräparate in der chinesischen Enzyklopädie Pen-ts ' ao Kang-mu des Apothekers Li Shi-zhen beschrieben .
+Dieser Autor hebt insbesondere die Anwendung als Pestizid in Reisfeldern hervor .
+Im 17. 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 Arsen ( III ) - oxid umwandelt und von der Leinwand bröckelt , entstehen Schwierigkeiten bei der Restaurierung .
+Ab 1740 wurden Arsenpräparate in Europa mit Erfolg als Beizmittel im Pflanzenschutz eingesetzt .
+Diese Nutzung verbot man jedoch 1808 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 19. 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 19. 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 Datei : Arsen gediegen - St. Andreasberg , Harz.JPG Datei : Arsenic-4jg33a.jpg Arsen kommt in geringen Konzentrationen von bis zu 10 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 1,7 ppm vor , wobei es durch seinen lithophilen Charakter ( = Silikat liebend ) in der oberen Kruste angereichert ist ( 2 ppm gegenüber 1,3 ppm in der unteren Kruste ) ; damit liegt Arsen in der Tabelle der häufigsten Elemente an 53. 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 ( 9. Auflage ) wird Arsen unter der System-Nr .
+1.CA.05 ( Elemente – Halbmetalle ( Metalloide ) und Nichtmetalle – Arsengruppen-Elemente ) ( 8. Auflage : I / B.01-10 ) eingeordnet .
+Die im englischsprachigen Raum ebenfalls geläufige Systematik der Minerale nach Dana führt das Element-Mineral unter der System-Nr .
+01.03.01.01 .
+Weltweit sind zurzeit ( Stand : 2011 ) rund 330 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 : 2011 ) 565 Arsenminerale bekannt . Die höchsten Konzentrationen an Arsen enthalten dabei unter anderem die Minerale Duranusit ( ca. 90 % ) , Skutterudit und Arsenolith ( jeweils ca. 76 % ) , 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 2009 waren China , Chile , Marokko und Peru .
+Arsen ist nur schwer wasserlöslich und findet sich daher nur in geringen Spuren , etwa 1,6 ppb ( Milliardstel Massenanteilen ) in Meeren und Ozeanen .
+In der Luft findet man Arsen in Form von partikulärem Arsen ( III ) - oxid .
+Als natürliche Ursache dafür hat man Vulkanausbrüche identifiziert , die insgesamt jährlich geschätzte 3000 Tonnen in die Erdatmosphäre eintragen .
+Bakterien setzen weitere 20.000 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 1990 in der Bundesrepublik Deutschland 120 Tonnen ( 20 Tonnen in den alten , 100 Tonnen in den neuen Bundesländern ) .
+Die Außenluftkonzentration von Arsen liegt zwischen 0,5 und 15 Nanogramm pro Kubikmeter .
+Gewinnung und Darstellung Datei : ArsenbergwerkRotgueldensee.jpg
+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 Arsen ( III ) - oxid mit Koks oder Eisen und durch Erhitzen von Arsenkies ( FeAsS ) oder Arsenikalkies ( FeAs2 ) 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 .
+FeAs2_ { ( s ) } -> FeAs_ { ( s ) } { } + As_ { ( g ) } Arsenikalkies zersetzt sich in Eisenarsenid und elementares Arsen .
+Für die Halbleitertechnik wird Arsen , dessen Reinheit über 99,99999 Prozent betragen muss , durch Reduktion von mehrfach destilliertem Arsen ( III ) - chlorid im Wasserstoffstrom hergestellt : 2AsCl3 + 3H2 -> 6HCl + 2As 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 Blei ( II ) - sulfid gebunden .
+Die hierbei erzielten Reinheiten von über 99,999 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 600 ° C in Arsen und Wasserstoff .
+Eigenschaften Datei : Arsenkomplexe.png Datei : Arsen 1.jpg Arsen bildet mit Stickstoff , Phosphor , Antimon und Bismut die 5. Hauptgruppe des Periodensystems und nimmt wegen seiner physikalischen und chemischen Eigenschaften den Mittelplatz in dieser Elementgruppe ein .
+Arsen hat eine relative Atommasse von 74,92159 .
+Der Radius des Arsen-Atoms beträgt 124,5 Pikometer .
+In kovalent gebundenem Zustand ist er etwas kleiner ( 121 Pikometer ) .
+Aufgrund der Abgabe der äußeren Elektronen ( Valenzelektronen ) bei der Ionisierung reduziert sich der Radius beträchtlich auf 34 Pikometer ( As5 + ; das äußerste p- und das äußerste s-Atomorbital bleiben unbesetzt ) beziehungsweise 58 Pikometer ( As3 + ; nur das p-Orbital ist unbesetzt ) .
+In chemischen Komplexverbindungen ist das As5 + - Kation von vier Bindungspartnern ( Liganden ) , As3 + 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 0 ( Metalle ) bis 4 ( Nichtmetall ) reichenden Skala bei 2,18 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 302,7 kJ / mol , also die Energie , die aufgebracht werden muss , um ein einzelnes Arsen-Atom aus einem Arsen-Festkörper herauszulösen , zwischen der des Nichtmetalls Stickstoff ( 473,02 kJ / mol ; kovalente Bindung ) und des Metalls Bismut ( 207,2 kJ / mol ; metallische Bindung ) liegt .
+Unter Normaldruck sublimiert Arsen bei einer Temperatur von 613 ° C , geht also aus dem festen Aggregatzustand direkt in die Gasphase über .
+Arsendampf ist zitronengelb und setzt sich bis ungefähr 800 ° C aus As4-Molekülen zusammen .
+Oberhalb von 1700 ° C liegen As2-Moleküle vor .
+Arsen zeigt je nach Verbindungspartner Oxidationsstufen zwischen − 3 und + 5.
+Mit elektropositiven Elementen wie Wasserstoff oder Metallen bildet es Verbindungen , in denen es eine Oxidationsstufe von − 3 einnimmt .
+Beispiele dafür sind Monoarsan ( AsH3 ) und Arsenkupfer ( Cu3As ) .
+In Verbindungen mit elektronegativen Elementen wie den Nichtmetallen Sauerstoff , Schwefel und Chlor besitzt es die Oxidationsstufe + 3 oder + 5 ; 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 As2-Moleküle instabil und Arsen bildet stattdessen kovalente Netzwerke aus .
+Graues Arsen Datei : Grauesarsen.png Graues oder metallisches Arsen ist die stabilste Form. Es hat eine Dichte von 5,73 g/cm3 .
+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 As4-Tetraeder vorliegt , schnell abgekühlt , so bildet sich das metastabile gelbe Arsen mit einer Dichte von 1,97 g/cm3 .
+Es besteht ebenfalls aus tetraedrischen As4-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 100 bis 200 ° 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 4,7 bis 5,1 g/cm3 .
+Oberhalb 270 ° C wandelt sich das schwarze Arsen in die graue Modifikation um .
+Wird glasartiges , amorphes schwarzes Arsen bei Anwesenheit von metallischem Quecksilber auf 100 bis 175 ° 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 Arsen ( III ) - oxid .
+4As + 3O2 -> 2As2O3 Arsen reagiert mit Sauerstoff zu Arsen ( III ) - oxid .
+Ohne äußere Wärmezufuhr findet die Reaktion mit Chlor unter Feuererscheinung zu Arsen ( III ) - chlorid statt .
+2As + 3Cl2 -> 2AsCl3 Arsen reagiert mit Chlor zu Arsentrichlorid .
+Eine weitere Oxidation ist möglich .
+AsCl3 + Cl2 -> AsCl5 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 + 5HNO3 -> 5NO2 + H2O + H3AsO4 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 .
+2As + 3H2SO4 -> 3SO2 + 2H3AsO3 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 + 2H3O + -> Zn ^ 2 + + H2 + 2 H2O Zink reagiert mit Wasserstoffionen zu Zinkionen und neutralem Wasserstoff .
+2As + 3H2 -> 2AsH3 Arsen reagiert mit Wasserstoff zu Monoarsan .
+Mit basischem Natriumhydroxid bildet sich das entsprechende Arsenitsalz .
+2As + 6NaOH -> 2Na3AsO3 + 3H2 Arsen reagiert mit Natriumhydroxid zu Natriumarsenit und elementarem Wasserstoff .
+Isotope Vom Arsen sind künstlich hergestellte , radioaktive Isotope mit Massenzahlen zwischen 65 und 87 bekannt .
+Die Halbwertszeiten liegen zwischen 96 Millisekunden ( 66As ) und 80,3 Tagen ( 73As ) .
+Natürlich vorkommendes Arsen besteht zu 100 Prozent aus dem Isotop 75As , es ist daher ein anisotopes Element .
+Der entsprechende Arsen-Kern besteht also aus genau 33 Protonen und 42 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 3/2 .
+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 .
+Datei : Wafer 2 Zoll bis 8 Zoll.jpg In der Elektronik spielt es als mindestens 99,9999 Prozent reines Element für Gallium-Arsenid-Halbleiter , sogenannte III-V-Halbleiter ( aufgrund der Kombination von Elementen aus der 3. und 5. 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 2004 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 Arsen ( III ) - 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 18. Jahrhundert wurde eine Mischung aus Kaliumarsenit und Lavendelwasser als Fowler ’ sche Lösung bekannt , die lange als medizinisches Wundermittel galt und als Fiebersenker , Heilwasser und sogar als Aphrodisiakum Anwendung fand .
+Kaliumarsenit war als Bestandteil der Fowler ’ schen Lösung bis in die 1960er Jahre in Deutschland als Mittel zur Behandlung der Psoriasis im Einsatz .
+Constantinus Africanus ( 1017–1087 ) empfahl eine Arsenapplikation zur Bekämpfung von Zahnschmerzen .
+Bereits um 2700 vor Christus soll die Anwendung von Arsen zur Behandlung eines schmerzenden Zahnes in der chinesischen Heilkunst beschrieben worden sein .
+In dem Mitte des 10. Jahrhunderts erschienenen Werk „ Liber Regius “ empfahl der arabische Arzt Haly Abbas ( ʿAli ibn al-ʿAbbās ; † 944 ) ebenfalls den Einsatz von Arsenik zur Devitalisation der Pulpa . Arsen ( III ) - oxid wurde bis in die Neuzeit zur Devitalisation der Zahnpulpa verwendet und verschwand in den 1970er 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 20. Jahrhunderts .
+Harold Wolferstan Thomas und Anton Breinl konnten 1905 beobachten , dass das arsenhaltige Präparat Atoxyl Trypanosomen , zu denen die Erreger der Schlafkrankheit gehören , abtötet .
+1920 wurde eine Weiterentwicklung , das Tryparsamid , in der Zeit von 1922 bis 1970 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 1950er 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 1910 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 2000 wurde ein arsenikhaltiges Präparat unter dem Namen Trisenox in den USA zur Behandlung der akuten Promyelozytenleukämie ( APL ) zugelassen .
+Seit 2002 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 1868 bis 1996 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 5 und 50 µ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 175 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 24 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 8 ppb Arsen , in den anderen Organen des Körpers wie etwa den Knochen hat es einen Anteil von zwischen 0,1 und 1,5 ppm , in Haaren liegt der Anteil bei etwa 1 ppm .
+Der Gesamtgehalt von Arsen im Körper eines Erwachsenen liegt im Durchschnitt bei etwa 7 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 17. Jahrhundert verzehrten manche der dortigen Bewohner lebenslang zweimal wöchentlich bis zu 250 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 1875 vor der in Graz versammelten deutschen Fachwelt eine Dosis von 400 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-1 wurde 2010 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 ) .
+Arsen ( III ) - und Zink ( II ) - 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 60 bis 170 Milligramm Arsenik gilt für Menschen als tödliche Dosis ( LD < sub > 50 < / sub > = 1,4 mg / kg 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 0,6 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 ( LD50 = 763 mg / kg 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 ( [ AsO3 ] 3 − ) und Arsenat ( [ AsO4 ] 3 − ) 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 100 Millionen Menschen belastetes Wasser .
+Besonders in Indien , Bangladesh und Thailand , wo im 20. 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 Datei : Weltkarte arsenrisikogebiete.gif Die Weltgesundheitsorganisation ( WHO ) empfiehlt seit 1992 einen Grenzwert für Arsen im Trinkwasser von 10 Mikrogramm pro Liter .
+Der Wert wird in vielen Staaten Europas und in den USA immer noch überschritten .
+In Deutschland wird er dagegen seit 1996 eingehalten .
+Eine Richtlinie der Europäischen Union ( EU ) von 1999 schreibt einen Höchstwert von 10 Mikrogramm pro Liter Trinkwasser EU-weit vor . Die USA verpflichteten sich im Jahre 2001 , diesen Grenzwert ab 2006 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 20 und 900 Mikrogramm Arsen pro Kilogramm . Im Jahr 2005 senkte die chinesische Regierung den zulässigen Gehalt anorganischer Arsenverbindungen von 700 auf 150 Mikrogramm pro Kilogramm Lebensmittel , im Juli 2014 beschloss die Codex Alimentarius-Kommission erstmals einen Höchstwert von 200 Mikrogramm für polierten Reis . Die für Lebensmittelsicherheit zuständige EU-Kommission diskutiert für Erzeugnisse aus Puffreis einen um 15 Prozent höheren Grenzwert und für spezielle Produkte für Kleinkinder einen nur halb so hohen ( d. h.
+100 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 3 , höchstens aber 4,4 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 2005 verbietet im Anhang 4 die „ gewerbliche “ ( nicht private ) Verarbeitung von arsenhaltigen Mitteln und Zubereitungen , die mehr als 0,3 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 460 ° C bis 480 ° 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 ( 99,995 Reinheitsgrad , DIN-1179-Reinheitsgrad ) mit weniger als 0,0004 Gewichts- % ausgewiesen waren und nach Zugabe von 450 Gramm dieses hochreinen Zinks in die Zinkschmelze zu einem Anstieg der Cd- / As-Konzentration von 3 bis 7 µg/m3 Luft auf über 3000 µg/m3 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 25 bis 68 µg / l Urin gemessen , im Vergleich zu unbelasteter Bevölkerung mit 0,1 µg Arsen / l 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 75 bis 90 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 ( =D MPS ) , 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 Arsen ( III ) - oxid oder gelbem Arsentrisulfid wieder niederschlagen .
+Die so genannte Marshsche Probe ist die klassische Nachweisreaktion in der Chemie und Gerichtsmedizin für Arsen : As2O3 + 6Zn + 12H3O + -> 2AsH3 + 6Zn ^ 2 + + 15H2O Bei der Bettendorfschen Probe oxidiert Arsen in konzentrierter Salzsäure unabhängig von der Oxidationsstufe zweiwertige Zinn-Ionen .
+Dabei fällt elementares Arsen aus : 2As ^ 3 + + 3Sn ^ 2 + -> 3Sn ^ 4 + + 2As Gibt man zu einer ammoniakalischen , ammoniumchloridhaltigen Lösung von Arsenat Magnesium-Ionen , so erhält man einen kristallinen Niederschlag von Magnesiumammoniumarsenat-Hexahydrat : AsO4 ^ 3- + Mg ^ 2 + + NH4 + + 6H2O -> MgNH4AsO4.6H2O Arsenat reagiert mit Magnesiumionen , Ammoniumionen und Wasser zu Magnesiumammoniumarsenat-Hexahydrat .
+Eine weitere Nachweisreaktion von Arsen ( at ) 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 : H2AsO4- + 22H3O + + 3NH4 + + 12MoO4 ^ 2- -> ( NH4 ) 3 [ As ( Mo3O { 10 } ) 4.aq ] + 34H2O 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 189,0 nm beziehungsweise 193,8 nm durchgeführt .
+Nachweisgrenzen bis zu 1 µg / ml wurden beschrieben .
+Häufig wird das Arsen auch mit Hilfe von NaBH4 in das gasförmige Arsin ( AsH3 ) überführt ( Hydridtechnik ) .
+In der Quarzrohrtechnik wird AsH3 zuerst bei rund 1000 ° 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 0,01 µg / l. Eine weitere Methode ist die sog. Graphitrohrtechnik , bei der das Arsen einer festen Probe bei 1700 ° C und höher verflüchtigt und anschließend die Extinktion bei 193,8 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 AsH3 wird dabei im Plasma atomisiert und mit einem Laser zur Emission angeregt .
+Mit dieser Methode wurden Nachweisgrenzen von 0,04 ng / mL 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 0,2 µg / l wurde für Arsenit beschrieben .
+Photometrie Weitverbreitet ist die photometrische Erfassung von As als Arsenomolybdänblau .
+As ( V ) reagiert zunächst mit ( NH4 ) 2MoO4 .
+Danach folgt eine Reduktion mit SnCl2 oder Hydrazin zu einem blauen Komplex .
+Die Photometrie erfolgt bei 730 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-75 enthält , wird das schwerere Isotop Arsen-76 gebildet , das jedoch instabil ist und sich unter einem β-Zerfall in Selen-76 umwandelt .
+Gemessen werden dabei die β-Strahlen , über die ein Rückschluss auf die Menge des Arsens möglich ist .
+^ { 75 }_{ 33 } As + ^ { 1 }_{ 0 } n -> ^ { 76 }_{ 33 } As -> ^ { 76 }_{ 34 } Se + e- Biosensoren Bei Biosensoren wird die Biolumineszenz bei Kontakt von in Wasser gelöstem Arsen mit genetisch modifizierten Bakterien ( z. B.
+Escherichia coli K12 ) 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 AsH3 ist eine wichtige Ausgangssubstanz zur Herstellung von Galliumarsenid in der Halbleiterindustrie .
+Diarsan ( As2H4 ) Triarsan ( As3H5 ) Halogenverbindungen Arsen bildet mit Halogenen binäre Verbindungen vom Typ AsX3 , AsX5 und As2X4 ( X bezeichnet das entsprechende Halogen ) .
+Arsen ( III ) - fluorid ( AsF3 ) Arsen ( V ) - fluorid ( AsF5 ) Arsen ( III ) - chlorid ( AsCl3 ) Arsenpentachlorid ( AsCl5 ) Arsentribromid ( AsBr3 ) Arsentriiodid ( AsI3 ) Diarsentetraiodid ( As2I4 ) Sauerstoffverbindungen Wichtige Sauerstoffsäuren sind : Arsensäure ( 2 H3AsO4 · H2O ) , deren Salze als Arsenate oder Arsenate ( V ) bezeichnet werden und den Phosphaten ähneln .
+Beispiele sind Calciumarsenat ( Ca3 ( AsO4 ) 2 · 3H2O ) und Bleihydrogenarsenat ( PbHAsO4 ) , die als Pflanzenschutzmittel verwendet wurden Arsenige Säure ( H3AsO3 ) , deren Salze als Arsenite oder Arsenate ( III ) bezeichnet werden .
+Das wichtigste Arsenoxid ist Arsen ( III ) - oxid ( Arsentrioxid auch Arsenik oder Weißarsenik , As2O3 , das Anhydrid der Arsenigen Säure ) , das in der Gasphase in Form von Doppelmolekülen mit der Formel As4O6 vorliegt .
+Es ist amphoter und weist damit auf den Halbmetallcharakter des Arsens hin .
+Neben As2O3 kennt man As2O5 ( Arsenpentaoxid , das Anhydrid der Arsensäure ) und das gemischte Anhydrid der Arsenigen Säure und Arsensäure As2O4 ( Arsentetraoxid ) Ein historisch wichtiges Färbe- und Pflanzenschutzmittel ist ein Kupfer-Arsen-Oxid mit dem Trivialnamen Schweinfurter Grün ( Cu ( AsO2 ) 2 · Cu ( CH3COO ) 2 ) .
+Schwefelverbindungen Es bestehen zwei wichtige Arsensulfide , die beide als Minerale in der Natur vorkommen .
+Arsenmonosulfid ( Realgar , As4S4 ) Arsen ( III ) - sulfid ( Auripigment , As2S3 ) 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 ( AsH ( CH3 ) 2 ) Trimethylarsin ( As ( CH3 ) 3 ) , eine übelriechende Flüssigkeit , die zur Behandlung bakterieller Infektionen und als Pilzschutzmittel Anwendung fand .
+Zu den Arsoranen , Verbindungen vom Typ R5As , wobei R5 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 ( AsR4 ) + bezeichnet .
+Datei :Po lyzyklisches Arsen.png
+Analog zu den Carbonsäuren lassen sich zwei Klassen arseno-organischer Säuren bilden : Arsinsäuren ( RR'AsOOH ) Arsonsäuren ( RAsO ( OH ) 2 ) 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 .
+Datei :Po lyarsin.png
+Auch homocyclische Arsenverbindungen existieren .
+Beispiele sind Pentamethylcyclopentaarsen ( AsCH3 ) 5
+Hexamethylcyclohexaarsen ( AsCH3 ) 6
+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 ( AsCH3 ) 2n ergibt , wobei die natürliche Zahl n weit über 100 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 17. 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 15 Menschen zu Tode .
+Aufsehen erregte auch der Fall der Serienmörderin Anna Margaretha Zwanziger zu Beginn des 19. Jahrhunderts .
+Die Urheber der Morde blieben jedoch meist unerkannt , da Arsen bis 1836 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 19. und 20. 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 1840 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 1927 und 1949 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 1954 letztendlich freigesprochen werden .
+Datei : The Imperial Portrait of Emperor Guangxu2.jpg Datei : Napoleon - 1.jpg Jahrelang glaubte die Fachwelt , dass der Tod des ehemaligen französischen Kaisers Napoleon Bonaparte mit 51 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
+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 1980 in einem Notizbuch aufgefundene Materialprobe schlüssig belegt .
+Der berühmte Philosoph René Descartes starb 1650 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 1900 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 70 Menschen erlagen ihren Vergiftungen .
+In den Jahren 2010 und 2011 starben in Österreich zwei Männer an einer Arsenvergiftung .
+Am 11. April 2013 wurde am Landesgericht Krems eine 52-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 1950er 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 2002 , ISBN 3-11-017439-1 . Dietmar Ritter : Charakterisierung und Einsatz alternativer Arsen- und Phosphor-Quellen für die Metallorganische Molekularstrahlepitaxie von InP und GaInAs . Shaker , Aachen 1998 , ISBN 3-8265-4489-7 . Giulio Morteani , Lorenz Eichinger : Arsen im Trinkwasser und Dearsenierung .
+Gesetzliche Vorschriften , Toxikologie , Hydrochemie .
+In : Wasser , Luft , Boden . Vereinigte Fachverlag , Mainz 48. 6 , 2004 , S. 24–26 . Nicholas C. Norman : Chemistry of Arsenic , Antimony and Bismuth . Blackie , London 1998 , ISBN 0-7514-0389-X . Andrew A Meharg : Venomous Earth : How arsenic caused the world ’ s worst mass poisoning . Macmillan Science .
+Die bremische Gesina . In : Hans Heinrich : Frau-Geschichten . WM-Literatur-Verlag , Weilheim 2002 , ISBN 3-9808439-0-4 , S. 62–72 . Weblinks Mineralienatlas : Arsen Enzymatischer Abbau von Arsenkampfstoffen wissenschaft.de – Arsen im Trinkwasser begünstigt Arteriosklerose Arsenic and Human Health , Environmental Health & Toxicology , Specialized Information Services , National Library of Medicine ( englisch ) ( PDF , 295 KiB ) Einzelnachweise Jorma Maeki-Paakkanen , Päivi Kurttio , Anna Paldy , Juha Pekkanen : . ( PDF ) In : Environmental and Molecular Mutagenesis . 32 , Nr. 4 , 1998 , S. 301–313 . 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 . 6 , Nr. 2 , 2013 , S. 119–126 , doi : 10.1007/s12349-013-0127-1 . Bernhard Fischer : Ueber Todesfälle nach Salvarsan . In : Deutsche Medizinische Wochenschrift . Band 42 , 1916 , S. 106 f. , 908–910 , 939–942 und 976–978 . J. Elfenbein : Der erste Krimi der Weltgeschichte . Teil 3 : Die Machtergreifung des König Darius . In : Borsuye . Zeitschrift für Medizin u. Kultur . 10 , 39 , 1998 , S. 10 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 2005 , ISBN 3-11-015714-4 , S. 101. K. H. Wedepohl : The composition of the continental crust . In : Geochimica et Cosmochimica Acta . 59/7 , 1995 , S. 1217–1232 . IMA / CNMNC List of Mineral Names – Gold . ( PDF ; 1,8 MB ) S. 17 ( englisch ) . Localities for Arsenic . Mindat . Mineral Species sorted by the element As ( Arsenic ) . Webmineral . G. Brauer ( Hrsg. ) : Handbook of Preparative Inorganic Chemistry . 2. Auflage . vol. 1 , Academic Press 1963 , S. 591–592 . N / A J. M. Hyson : A history of arsenic in dentistry . In : Journal of the California Dental Association . Band 35 , Nummer 2 , Februar 2007 , S. 135–139 . PMID 17494382 . M. Hülsmann : Risiken und Nebenwirkungen bei der Devitalisierung permanenter Zähne . In : Zahnärztl . Mitt. 86 , 1996 , S. 338–345 . Ernst Sieburg : Zur Biologie aromatischer Arsenverbindungen . In : Hoppe-Seyler ’ s Zeitschrift für physiologische Chemie . Band 97 , 1916 , S. 53–108 . Vgl. auch Florian G. Mildenberger : Kein Heil durch Arsen ? Die Salvarsandebatte und ihre Konsequenzen . In : Fachprosaforschung – Grenzüberschreitungen . Band 8/9 , 2012/2013 ( 2014 ) , S. 327–390 . Fernando Marte , Amandine Pequinot , David W. Von Endt : ( PDF ; 159 kB ) Gerhard Schröder : Das Sammeln , Konservieren von Wirbeltieren . 1936 . Rudolf Piechocki , Joachim Händel : Mikroskopische Präparationstechnik . Teil II , 4. Auflage . 1996.Felix Divo : . Jugend-forscht-Arbeit von 2011 . John Emsley : Parfum , Portwein , PVC … . Wiley Verlag , Weinheim 2003 , S. 274–275 . 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 3 , Juli 2013 , S. 2195 , doi : 10.1038/srep02195 . PMID 23873074 . 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 . 2010 , doi : 10.1126/science.1197258 . Erika Check Study challenges existence of arsenic-based life : Study challenges existence of arsenic-based life . In : nature news . 20. Januar 2012 , doi : 10.1038/nature.2012.9861 . M. L. Reaves , S. Sinha , J. D. Rabinowitz , L. Kruglyak , R. J. Redfield : Absence of arsenate in DNA from arsenate-grown GFAJ-1 cells . 19. April 2012 , . Johann Mutschmann , Fritz Stimmelmayr : Taschenbuch der Wasserversorgung . Vieweg+Teubner , 2007 , ISBN 978-3-8348-0012-1 . Arsenic Removal Using Nanoscale Magnetite . Richtlinie 98/83/EG des Rates vom 3. November 1998 über die Qualität von Wasser für den menschlichen Gebrauch . ( , eur-lex.europa.eu ) . DPA-Meldung auf merkur-online.de vom 17. Juli 2014 , abgerufen am 2. November 2014 . auf der Webseite der FAO , abgerufen am 2. November 2014 ( englisch ) . ( PDF ) ec. europa.eu ; abgerufen am 2. November 2014 ( englisch ) . Keiligh Baker : In : Daily Mail . 2. November 2014 , abgerufen am 2. November 2014 ( englisch ) . Nadja Podbregar : In : wissenschaft.de . 7. April 2013 , abgerufen am 3. November 2014 . In : Washington Post . 19. Mai 2014 , abgerufen am 3. November 2014 ( englisch ) . auf der Webseite des LGL Bayern , aktualisiert am 3. Mai 2012 , abgerufen am 3. November 2014 . T. K. Morris : Cadmium exposures at three nonferrous foundries : an unexpected trace source . In : J Occup Environ Hyg . 1 ( 1 ) , Jan 2004 , S. 39–44 . 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 , 1997 . P. Liang , L. Peng , P. Yan : Speciation of As ( III ) and As ( V ) in water samples by liquid-liquid microextraction separation and determination by graphite furnace atomic absorption spectrometry . In : Microchimica Acta . 166 , 1999 , S. 47–52 and darin genannte Zitationen . Y. Jiang , J. Liu , X. Xia , D. Wang : Ammonium pyrrolidinedithiocarbamate-modified activated carbon micro-column extraction for the determination of As ( III ) in water by graphite furnace atomic absorption spectrometry . In : Microchimica Acta . 161 , 2008 , S. 137–142 . D. Hung , O. Nekrassova , R. Compton : Analytical Methods for Inorganic Arsenic in Water : A Review . In : Talanta . 64 , 2004 , S. 269–277 . J. Mattusch , R. Wennrich : Novel Analytical Methodologies for the Determination of Arsenic and other Metalloid Species in Solids , Liquids and Gases . In : Microchimica Acta . 151 , 2005 , S. 137–139 . S. Londesborough , J. Mattusch , R. Wennrich : Separation of organic and inorganic arsenic species by HPLC-ICP-MS . In : Fresenius Journal of Analytical Chemistry . 363 , 1999 , S. 577–581 . G. Schwedt : Analytische Chemie . 2. Auflage . Wiley-VCH , 2008 , S. 352. ( PDF ) Helmholtz-Zentrum für Umweltforschung . Escherichia coli Bakterien in Arsen Detektoren 23. März 2012 . 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. 2013 Nov 23. pii : S0946-672X ( 13 ) 00167-3 . PMID 24332310 . V. Dembitsky , D. Levitsky : Arsenolipides . In : Progress in Lipid Research . 43 , 2004 , S. 403–448 . Theodor Ebert ( Philosoph ) : Interview zu seinem Buch Der rätselhafte Tod des René Descartes . Alibri , Aschaffenburg 2009 . orf . at : Lebenslange Haft im Arsen-Prozess , abgerufen am 12. April 2013 . 
+
+Astat [ ] ( von : „ unbeständig , unstet “ ) ist ein radioaktives chemisches Element mit dem Elementsymbol At und der Ordnungszahl 85. Im Periodensystem steht es in der 7. Hauptgruppe bzw. der 17. 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 Datei : Segre.jpgEmilio 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
+Im Jahre 1931 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 1937 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 85 im Jahr 1940 ankündigte .
+Er änderte im Jahr 1942 jedoch seinen Vorschlag in Anglohelvetium .
+Bestätigt werden konnte die Entdeckung des Astat ( altgriechisch ἀστατέω = „ unbeständig sein “ , aufgrund des radioaktiven Zerfalls ) erstmals im Jahre 1940 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 26 bis 29 MeV hergestellt .
+Man erhält dabei die relativ langlebigen Isotope 209At bis 211At , die dann im Stickstoff strom bei 450 bis 600 ° 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 2013 das Ionisationspotenzial von Astat mit 9,31751 ( 8) Elektronenvolt bestimmt .
+Isotope Astat hat etwa 20 bekannte Isotope , die alle radioaktiv sind ; das langlebigste ist 210At mit einer Halbwertszeit von 8,3 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 At ( Py ) 2 ( Py =P yridin ) , 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 , 2013 Einzelnachweise Weblinks Wolfgang W. Merkel : , in Welt.de Datum : 3. September 2011 ; abgerufen am 4. September 2011 . Fred Allison , Edgar J. Murphy , Edna R. Bishop , Anna L. Sommer : Evidence of the Detection of Element 85 in Certain Substances . In : Phys. Rev. 1931 , 37 , S. 1178–1180 , . R. F. Trimble : What happened to alabamine , virginium , and illinium ? In : J. Chem. Educ . 1975 , 52 , S. 585. 85 Astatine . Alice Leigh-Smith , Walter Minder : Experimental Evidence of the Existence of Element 85 in the Thorium Family . In : Nature . 1942 , 150 , S. 767–768 , . D. R. Corson , K. R. MacKenzie , E. Segrè : Artificially Radioactive Element 85. In : Phys. Rev. 1940 , 58 , S. 672–678 , . Berta Karlik , Traude Bernert : Eine neue natürliche α-Strahlung . In : Naturwissenschaften . 1943 , 31 , 25–26 , S. 289–299 , . Berta Karlik , Traude Bernert : Das Element 85 in den natürlichen Zerfallsreihen . In : Zeitschrift für Physik . 1943 , 123 , 1–2 , S. 51–72 , . Welt der Physik : ( Deutsche Physikalische Gesellschaft e. V. über das Ionisationspotential von Astat ) 2013 . 
+
+Als Alkalimetalle werden die chemischen Elemente Lithium , Natrium , Kalium , Rubidium , Caesium und Francium aus der 1. 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 1807 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 Datei : Alkalimetalle.jpg
+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 ( 671 nm ) .
+Natrium und seine Salze färben die Flamme gelb ( 589 nm ) .
+Kalium und seine Salze färben die Flamme violett ( 768 und 404 nm ) .
+Rubidium und seine Salze färben die Flamme rot ( 780 und 421 nm ) .
+Caesium und seine Salze färben die Flamme blauviolett ( 458 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 : 2 Me + H_2 -> 2 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 ) : 4 Li + O_2 -> 2 Li_2O 2 Na + O_2 -> Na_2O_2 4 Na + O_2 -> Na_2O M + O_2 -> MO_2 ( M = K , Rb , Cs ) Datei :Po tassium water 20.theora . ogv Die Reaktion mit Wasser zu Alkalimetallhydroxiden erfolgt unter Freisetzung von Wasserstoff : 2 M + 2 H_2O -> 2 MOH + H_2 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 0,5 g Natrium explosiv mit Wasser reagieren , was eigentlich durch die an der Kontaktfläche der Edukte entstehenden Reaktionsprodukte , Wasserstoff und Alkalimetalhydroxid , gehemmt werden sollte .
+Hoch ­ geschwindigkeits ­ aufnahmen 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 : 2 Me + X_2 -> 2 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_4 + 4 Na -> 4 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 1. 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 1 % aus zweiatomigen Molekülen .
+Literatur A. G. Sharpe et al. : Inorganic Chemistry , second edition – ISBN 0-13-039913-2 – Kapitel 10 Group 1 : the alkali metals .
+Handbuch der experimentellen Chemie Sekundarbereich II , Band 2 , 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 ( Thunderf00t ) 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 7 , Nummer 3 , März 2015 , S. 250–254 , , PMID 25698335 
+
+Actinoide [ ] ( „ Actiniumähnliche “ ; griech. : Endung - οειδής ( - oeides ) „ ähnlich “ ) ist eine Gruppenbezeichnung bestimmter ähnlicher Elemente .
+Zugerechnet werden ihr das Actinium und die 14 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 ( 93 ) sind auch Transurane .
+Als Transactinoide bezeichnet man die Elemente mit Ordnungszahlen ab 104 ( 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 225 , 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 1934 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 > 92 , also Transurane , gebildet werden könnten .
+Tatsächlich synthetisierten Edwin M. McMillan und Philip H. Abelson erstmals im Jahr 1940 die ersten nicht in der Natur vorkommenden Actinoid-Nuklide 239U , 239Np und 239Pu durch Beschuss von Uran mit Neutronen .
+Da im Jahr 1940 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 1941 , 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 1940 stellten sie das Plutonium-Isotop 238Pu durch Beschuss des Uran-Isotops 238U mit Deuteronen her , die in einem Zyklotron beschleunigt worden waren .
+Nachdem der eindeutige Nachweis für das Element 94 erbracht worden war , erhielt es 1941 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 4 µg wurde 1942 isoliert .
+Datei : Stagg Field reactor.jpg Ende 1942 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,2n ) - Reaktionen .
+Dieses Verfahren ist auf nicht allzu massereiche Actinoid-Nuklide beschränkt , etwa bis zu Massenzahlen von A = 252.
+Rechnerisch ( s. u ) werden meist nur Nuklide bis A < 248 einbezogen .
+Americium zum Beispiel wurde in einem Zweistufenprozess entdeckt .
+In der ersten Stufe werden synthetische Actinoide in einem Kernreaktor gebildet , zum Beispiel 239Pu .
+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 85 MW High-Flux-Isotope Reactor am Oak Ridge National Laboratory in Tennessee , USA ist auf die Herstellung von Transcuriumelementen ( Z > 96 ) speziell ausgelegt .
+Die massereichen Elemente Einsteinium und Fermium wurden durch den Test der ersten amerikanischen Wasserstoffbombe , Ivy Mike , am 1. November 1952 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 16 Neutronen von einem Kern von 238U 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 .
+238U wurde mit 14N-Ionen , die an einem Zyklotron erzeugt wurden , bombardiert .
+Auf diesem Wege wurde zunächst Einsteinium synthetisiert und in der Publikation auf die Entdeckung von 1952 verwiesen .
+Ähnlich verfuhr man mit Fermium , das durch Beschuss mit 239Pu mit 14N-Ionen erzeugt wurde .
+Wie die Tabelle zeigt , führten Schwerionenreaktionen auch zu den Elementen Mendelevium , Nobelium und Lawrencium mit den Ordnungszahlen 101 bis 103.
+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 235U angereichertes Uran .
+In einem Leistungsreaktor sind Aktinoidmassen in der Größenordnung von 100 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 Datei : Actinide Buildup Chart 03a.png
+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 2014 .
+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,2n ) - 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,3n ) - 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 236Np wandelt sich zu 86 % durch Elektroneneinfang und zu 14 % durch Beta-Minus-Zerfall ( hellblaue Ecke ) um .
+Ebenfalls zwei Zerfallsarten , aber in nahezu umgekehrtem Verhältnis ( 83 % Beta-Minus-Zerfall , 17 % Elektroneneinfang ) zeigt auch der Grundzustand von 242Am ( rosa Ecke ) .
+Dieses Nuklid besitzt außerdem einen langlebigen metastabilen Zustand ( weiß hinterlegt ) , der in der Regel durch 242m1Am 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 ( T1/2 ) bei Bildung und Zerfall der Actinoide während der Aufenthaltsdauer des Brennstoffs in einem Leistungsreaktor ( max. ca. 3 Jahre ) so gut wie keine Rolle .
+Ausnahmen sind die beiden relativ kurzlebigen Nuklide 242Cm ( T1/2 = 163 d ) und 236Pu ( T1/2 = 2.9 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 NUBASE2012 , abgerufen über den Nukleardaten-Viewer JANIS 4. 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 1973 , OrigenArp , ein Programm zur Berechnung der Teilchendichten von Nukliden in Abhängigkeit vom Abbrand aus dem Jahr 2010 , 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 Datei : Actinide Masses 03a.png
+Die Abbildung Entwicklung der Massen der Actinoiden ... zeigt die Zu- oder Abnahme der Massen der 14 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 2005 mit dem Programmsystem HELIOS 1.8 ausgeführt . Als Anfangsanreicherung des Nuklids 235U wurde für dieses Beispiel 4 % 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 135Xe und 149Sm 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 10 g pro eingesetzter Tonne Schwermetall nach einem Abbrand von maximal 80 MWd / kg gebildet werden .
+Wie die Abbildung zeigt , nehmen die Massen der drei anfangs vorhandenen Uranisotope 238U , 235U und 234U 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 239Pu am stärksten zu .
+Damit wächst auch die Anzahl der Spaltungen der Kerne des Nuklids 239Pu .
+Ab einem Abbrand von ca. 45 MWd / kg nimmt dessen Masse wieder geringfügig ab .
+Würde man die Ordinate nach unten auf einen Massenanteil von mindestens 1 g pro eingesetzter Tonne Schwermetall herabsetzen , kämen auf der Abbildung ab einem Abrand von ca. 45 MWd / kg das Nuklid 242m1Am und ab einem Abrand von ca. 60 MWd / kg das Nuklid 243Cm hinzu .
+Zusammengefasst : In einem Druckwasserreaktor mit Uran-Brennelementen ( ohne MOX-Brennelemente ) werden aus den ursprünglich vorhandenen Actinoid-Nukliden 235U und 238U ( und einem geringen Anteil 234U ) maximal 13 synthetische Actinoid-Nuklide innerhalb der üblichen Betriebszeiten gebildet , deren Anteil größer als 1 g je Tonne Startmasse Schwermetall ( SM ) ist , also 1 ppm . Das sind die Nuklide 236U , 237Np , 238Pu , 239Pu , 240Pu , 241Pu , 242Pu , 241Am , 242m1Am , 243Am , 242Cm , 243Cm und 244Cm .
+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. 0,00024 bei einem ( gegenwärtig üblichen ) Abbrand von 60 MWd / kg : , wobei die Masse des Curiums und die Startmasse des Schwermetalls bedeuten .
+In einem Leistungsreaktor beträgt die anfängliche Schwermetallmasse ca. , verteilt auf 193 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. 24 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 60 MWd / kg um insgesamt nur ca. 6 % .
+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 232Th , 234U , 235U und 238U kommen natürlich vor .
+Ihre Quadrate sind in der obigen Nuklidkarte durch eine dickere Umrandung hervorgehoben .
+Mit Ausnahme von 234U 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 244Pu spielt im Kernreaktor keine Rolle .
+Sein Massenanteil in einigen Erzen liegt bei 10 − 18.
+Im Jahr 2000 waren mehr als 200 synthetisch erzeugte Actinoid-Nuklide bekannt . Die meisten besitzen kurze Halbwertszeiten .
+Nur 45 haben Halbwertszeiten T1/2 > 40 d.
+Von 41 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 233U , 235U , 238U , 239Pu , 240Pu und 241Pu 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 3. 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 > 2 < / sub > - Typ ( Fluorit ) mit der und den Koordinationszahlen An [ 8 ] , O [ 4 ] .
+Halogenide Die dreiwertigen Chloride der Actinoide kristallisieren im hexagonalen Kristallsystem .
+Die Struktur des Uran ( III ) - 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 2006 , ISBN 1-4020-3555-1 : Harold W. Kirby , Lester R. Morss : Actinium , S. 18–51 ; .
+Mathias S. Wickleder , Blandine Fourest , Peter K. Dorhout : Thorium , S. 52–160 ; .
+Boris F. Myasoedov , Harold W. Kirby , Ivan G. Tananaev : Protactinium , S. 161–252 ; .
+Ingmar Grenthe , Janusz Drożdżynński , Takeo Fujino , Edgar C. Buck , Thomas E. Albrecht-Schmitt , Stephen F. Wolf : Uranium , S. 253–698 ; .
+Zenko Yoshida , Stephen G. Johnson , Takaumi Kimura , John R. Krsul : Neptunium , S. 699–812 ; .
+David L. Clark , Siegfried S. Hecker , Gordon D. Jarvinen , Mary P. Neu : Plutonium , S. 813–1264 ; .
+Wolfgang H. Runde , Wallace W. Schulz : Americium , S. 1265–1395 ; .
+Gregg J. Lumetta , Major C. Thompson , Robert A. Penneman , P. Gary Eller : Curium , S. 1397–1443 ; .
+David E. Hobart , Joseph R. Peterson : Berkelium , S. 1444–1498 ; .
+Richard G. Haire : Californium , S. 1499–1576 ; .
+Richard G. Haire : Einsteinium , S. 1577–1620 ; .
+Robert J. Silva : Fermium , Mendelevium , Nobelium , and Lawrencium , S. 1621–1651 ; .
+James E. Huheey : Anorganische Chemie .
+de Gruyter , Berlin 1988 , ISBN 3-11-008163-6 , S. 873–900 . Norman N. Greenwood , Alan Earnshaw : Chemie der Elemente .
+1. Auflage .
+VCH , Weinheim 1988 , ISBN 3-527-26169-9 , S. 1601–1641 . dtv-Atlas zur Chemie , Teil 1. 1981 , S. 222–229 . Weblinks Ida Noddack : Das Periodische System der Elemente und seine Lücken , in : Angewandte Chemie , 1934 , 47 ( 20 ) , S. 301–305 ( doi : 10.1002/ange.19340472002 ) . E. McMillan , P. H. Abelson : Radioactive Element 93 , in : Physical Review , 1940 , 57 , S. 1185–1186 ( doi : 10.1103/PhysRev.57.1185.2 ) . B. B. Cunningham , L. B. Werner : The First Isolation Of Plutonium . In : Journal of the American Chemical Society . 71 ( 5 ) , 1949 , S. 1521–1528 ( doi : 10.1021/ja01173a001 ) . High Flux Isotope Reactor , Oak Ridge National Laboratory ; abgerufen am 18. November 2017 . Albert Ghiorso : , Chemical & Engineering News , 2003 . Die Schwermetallmasse ist nicht für jeden Leistungsreaktor leicht zu finden . Im Artikel wird die Schwermetallmasse mit 103 t angegeben , verteilt auf 193 Brennelemente . Das dürfte auch auf die anderen Leistungsreaktoren der Bauform näherungsweise zutreffen . Janis 4 – Java-based Nuclear Data Information System . RK : PWR-Calculations with the Code-System HELIOS 1.8 , Studsvik 2005 International User ’ s Group Meeting , Charlotte , NC , USA , June 1-3 , 2005 . Die Zusammenfassung findet sich im INIS Repository https://inis.iaea.org/search/search.aspx?orig_q=RN:31056505 Wolfgang Liebscher , Ekkehard Fluck : Die systematische Nomenklatur der anorganischen Chemie . Springer , Berlin 1999 , ISBN 3-540-63097-X . Neil G. Connelly ( Red. ) : Nomenclature of inorganic chemistry – IUPAC recommendations 2005 . Royal Society of Chemistry , Cambridge 2005 , ISBN 0-85404-438-8 . Guttmann , Hengge : Anorganische Chemie . VCH , Weinheim / New York / Basel / Cambridge 1990 . dtv-Atlas zur Chemie 1981 , Teil 1 , S. 224. Die Werte der atomaren und physikalischen Eigenschaften sind , wenn nicht anders angegeben , aus www.webelements.com entnommen . Lester R. Morss , Norman M. Edelstein , Jean Fuger ( Hrsg. ) : The Chemistry of the Actinide and Transactinide Elements : Bd. 3 , 2006 , Springer , ISBN 1-4020-3555-1 . 
+
+Americium ist ein chemisches Element mit dem Elementsymbol Am und der Ordnungszahl 95. Im Periodensystem steht es in der Gruppe der Actinoide ( 7. 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 1944 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 100 g des Elements .
+Es wird als Quelle ionisierender Strahlung eingesetzt , z. B.
+in der Fluoreszenzspektroskopie und in Ionisationsrauchmeldern .
+Das Americiumisotop 241Am wurde wegen seiner gegenüber Plutonium ( 238Pu ) wesentlich längeren Halbwertszeit von 432,2 Jahren zur Befüllung von Radionuklidbatterien ( RTG ) für Raumsonden vorgeschlagen , welche dann hunderte Jahre lang elektrische Energie zum Betrieb bereitstellen würden .
+Geschichte Datei : Glenn Seaborg - 1964.jpg Datei : Berkeley 60-inch cyclotron.gif
+Americium wurde im Spätherbst 1944 von Glenn T. Seaborg , Ralph A. James , Leon O. Morgan und Albert Ghiorso im 60-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 1940 entdeckt wurde ; das um eine Ordnungszahl höhere Curium wurde als drittes schon im Sommer 1944 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 239Pu ) auf eine Platinfolie von etwa 0,5 cm2 aufgetragen ; die Lösung danach eingedampft und der Rückstand dann zum Oxid ( PuO2 ) 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 : 241Am , 242Am , 239Am und 238Am .
+Als erstes Isotop isolierten sie 241Am aus einer Plutonium-Probe , die mit Neutronen bestrahlt wurde .
+Es zerfällt durch Aussendung eines α-Teilchens in 237Np .
+Die Halbwertszeit dieses α-Zerfalls wurde zunächst auf 510 ± 20 Jahre bestimmt ; der heute allgemein akzeptierte Wert ist 432,2 a.
+Die angegebenen Zeiten sind Halbwertszeiten .
+Als zweites Isotop wurde 242Am durch erneuten Neutronenbeschuss des zuvor erzeugten 241Am gefunden .
+Durch nachfolgenden raschen β-Zerfall entsteht dabei 242Cm , das zuvor schon entdeckte Curium .
+Die Halbwertszeit dieses β-Zerfalls wurde zunächst auf 17 Stunden bestimmt , der heute als gültig ermittelte Wert beträgt 16,02 h.
+Erstmals öffentlich bekannt gemacht wurde die Entdeckung des Elements in der amerikanischen Radiosendung Quiz Kids am 11. November 1945 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 ( 241Am und 242Am ) und seine Produktion wurde später unter dem Namen „ Element 95 and method of producing said element “ patentiert , wobei als Erfinder nur Glenn T. Seaborg angegeben wurde .
+In elementarer Form wurde es erstmals im Jahr 1951 durch Reduktion von Americium ( III ) - 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 241Am entsteht als Zerfallsprodukt ( u. a.
+in abgebrannten Brennstäben ) aus dem Plutoniumisotop 241Pu .
+Eine Tonne abgebrannten Kernbrennstoffs enthält durchschnittlich etwa 100 g verschiedener Americiumisotope . Es handelt sich dabei hauptsächlich um die α-Strahler 241Am und 243Am , 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 1962 soll der Preis für Americium ( IV ) - oxid mit dem Isotop 241Am bei etwa 1500 US-Dollar pro Gramm liegen . Das Americiumisotop 243Am entsteht in geringeren Mengen im Reaktor aus 241Am und ist deshalb mit 160 US-Dollar pro Milligramm 243Am noch wesentlich teurer .
+Americium wird über das Plutoniumisotop 239Pu in Kernreaktoren mit hohem 238U-Anteil zwangsläufig erbrütet , da es aus diesem durch Neutroneneinfang und zwei anschließende β-Zerfälle ( über 239U und 239Np ) entsteht .
+Die angegebenen Zeiten sind Halbwertszeiten .
+Danach wird , wenn es nicht zur Kernspaltung kommt , aus dem 239Pu , neben anderen Nukliden , durch stufenweisen Neutroneneinfang ( n , γ ) und anschließenden β-Zerfall 241Am oder 243Am erbrütet .
+Das Plutonium , welches aus abgebrannten Brennstäben von Leistungsreaktoren gewonnen werden kann , besteht zu etwa 12 % aus dem Isotop 241Pu . Deshalb erreichen erst 70 Jahre , nachdem der Brutprozess beendet wurde , die abgebrannten Brennstäbe ihren Maximalgehalt von 241Am ; danach nimmt der Gehalt wieder ( langsamer als der Anstieg ) ab .
+Aus dem so entstandenen 241Am kann durch weiteren Neutroneneinfang im Reaktor 242Am entstehen .
+Bei Leichtwasserreaktoren soll aus dem 241Am zu 79 % 242Am und zu 10 % 242m Am entstehen :
+zu 79 % : zu 10 % : Für die Erbrütung von 243Am ist ein vierfacher Neutroneneinfang des 239Pu erforderlich : Darstellung elementaren Americiums Metallisches Americium kann durch Reduktion aus seinen Verbindungen erhalten werden .
+Zuerst wurde Americium ( III ) - fluorid zur Reduktion verwendet .
+Dieses wird hierzu in wasser- und sauerstofffreier Umgebung in Reaktionsapparaturen aus Tantal und Wolfram mit elementarem Barium zur Reaktion gebracht .
+2 AmF3 + 3 Ba -> 2 Am + 3 BaF2 Auch die Reduktion von Americium ( IV ) - oxid mittels Lanthan oder Thorium ergibt metallisches Americium .
+3 AmO2 + 4 La -> 3 Am + 2 La2O3 Eigenschaften Datei : Americium microscope.jpg Datei :C losest packing ABAC.png Im Periodensystem steht das Americium mit der Ordnungszahl 95 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 1176 ° C , der Siedepunkt liegt bei 2607 ° C.
+Die Dichte beträgt 13,67 g · cm − 3 . Es tritt in zwei Modifikationen auf .
+Die bei Standardbedingungen stabile Modifikation α-Am kristallisiert im hexagonalen Kristallsystem in der mit den Gitterparametern a = 346,8 pm und c = 1124 pm sowie vier Formeleinheiten pro Elementarzelle .
+Die Kristallstruktur besteht aus einer doppelt-hexagonal dichtesten Kugelpackung ( d. h. c. p. ) 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 = 489 pm , was einem kubisch flächenzentrierten Gitter ( f. c. c. ) beziehungsweise einer kubisch dichtesten Kugelpackung mit der Stapelfolge ABC entspricht .
+Die Lösungsenthalpie von Americium-Metall in Salzsäure bei Standardbedingungen beträgt − 620,6 ± 1,3 kJ · mol − 1.
+Ausgehend von diesem Wert erfolgte die erstmalige Berechnung der Standardbildungsenthalpie ( Δf H 0 ) von Am3 + ( aq ) auf − 621,2 ± 2,0 kJ · mol − 1 und des Standardpotentials Am3 + / Am0 auf − 2,08 ± 0,01 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 + 3 , die Am ( III ) - 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 + 2 sowie + 4 , + 5 , + 6 und + 7 zu finden .
+Je nach Oxidationszahl variiert die Farbe von Americium in wässriger Lösung ebenso wie in festen Verbindungen : Am3 + ( gelbrosa ) , Am4 + ( gelbrot ) , AmVO2 + ( gelb ) , AmVIO2 2 + ( zitronengelb ) , AmVIIO6 5 − ( dunkelgrün ) .
+Im Gegensatz zum homologen Europium – Americium hat eine zu Europium analoge Elektronenkonfiguration – kann Am3 + in wässriger Lösung nicht zu Am2 + reduziert werden .
+Verbindungen mit Americium ab Oxidationszahl + 4 aufwärts sind starke Oxidationsmittel , vergleichbar dem Permanganat-Ion ( MnO4 − ) in saurer Lösung .
+Die in wässriger Lösung nicht beständigen Am4 + - Ionen lassen sich nur noch mit starken Oxidationsmitteln aus Am ( III ) darstellen .
+In fester Form sind zwei Verbindungen des Americiums in der Oxidationsstufe + 4 bekannt : Americium ( IV ) - oxid ( AmO2 ) und Americium ( IV ) - fluorid ( AmF4 ) .
+Der fünfwertige Oxidationszustand wurde beim Americium erstmals 1951 beobachtet . In wässriger Lösung liegen primär AmO2 + - Ionen ( sauer ) oder AmO3 − - Ionen ( alkalisch ) vor , die jedoch instabil sind und einer raschen Disproportionierung unterliegen :
+3 AmO2 ^ + + 4 H ^ + -> 2 AmO2 ^ 2 + + Am ^ 3 + + 2 H2O Zunächst ist von einer Disproportionierung zur Oxidationsstufe + 6 und + 4 auszugehen : 2 Am ( V ) -> Am ( VI ) + Am ( IV ) Etwas beständiger als Am ( IV ) und Am ( V ) sind die Americium ( VI ) - Verbindungen .
+Sie lassen sich aus Am ( III ) 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 Silber ( I ) - 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 2M Na2CO3.jpg | Americium ( III ) in 2 M Na2CO3-Lösung Americium IV in 2M Na2CO3.jpg | Americium ( IV ) in 2 M Na2CO3-Lösung Americium IV VI in 2M Na2CO3.jpg | Americium ( IV ) und ( VI ) in 2 M Na2CO3-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 242m1Am hat mit rund 5700 barn den höchsten bisher ( 10/2008 ) gemessenen thermischen Spaltquerschnitt . Damit geht eine kleine kritische Masse einher , weswegen 242m1Am 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 242m1Am-Kugel beträgt etwa 9–14 kg .
+Die Unsicherheiten der verfügbaren Wirkungsquerschnitte lassen derzeit keine genauere Aussage zu .
+Mit Reflektor beträgt die kritische Masse noch etwa 3–5 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 242m1Am gebaut , was mit der geringen Verfügbarkeit und dem hohen Preis begründet werden kann .
+Aus denselben Gründen wird 242m1Am 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 , 241Am und 243Am können in einem schnellen Reaktor eine Kettenreaktion aufrechterhalten .
+Die kritischen Massen sind hier jedoch sehr hoch .
+Sie betragen unreflektiert 57,6 –75 , 6 kg bei 241Am und 209 kg bei 243Am so dass sich durch die Verwendung keine Vorteile gegenüber herkömmlichen Spaltstoffen ergeben .
+Entsprechend ist Americium rechtlich nach Abs. 1 des Atomgesetzes nicht den Kernbrennstoffen zugeordnet .
+Es existieren jedoch Vorschläge , sehr kompakte Reaktoren mit einem Americium-Inventar von lediglich knapp 20 g zu konstruieren , die in Krankenhäusern als Neutronenquelle für die Neutroneneinfangtherapie verwendet werden können .
+Isotope Von Americium sind 16 Isotope und 11 Kernisomere mit Halbwertszeiten zwischen Bruchteilen von Mikrosekunden und 7370 Jahren bekannt .
+Es gibt zwei langlebige α-strahlende Isotope 241Am mit 432,2 und 243Am mit 7370 Jahren Halbwertszeit .
+Außerdem hat das Kernisomer 242m1Am mit 141 Jahren eine lange Halbwertszeit .
+Die restlichen Kernisomere und Isotope haben mit 0,64 µs bei 245m1Am bis 50,8 Stunden bei 240Am kurze Halbwertszeiten .
+241Am ist das am häufigsten erbrütete Americiumisotop und liegt auf der Neptunium-Reihe .
+Es zerfällt mit einer Halbwertszeit von 432,2 Jahren mit einem α-Zerfall zu 237Np .
+241Am gibt nur mit einer Wahrscheinlichkeit von 0,35 % die gesamte Zerfallsenergie mit dem α-Teilchen ab , sondern emittiert meistens noch ein oder mehrere Gammaquanten .
+242Am ist kurzlebig und zerfällt mit einer Halbwertszeit von 16,02 h zu 82,7 % durch β-Zerfall zu 242Cm und zu 17,3 % durch Elektroneneinfang zu 242Pu .
+Das 242Cm zerfällt zu 238Pu und dieses weiter zu 234U , das auf der Uran-Radium-Reihe liegt .
+Das 242Pu zerfällt über die gleiche Zerfallskette wie 238Pu .
+Während jedoch 238Pu als Seitenarm beim 234U auf die Zerfallskette kommt , steht 242Pu noch vor dem 238U . 242Pu zerfällt durch α-Zerfall in 238U , den Beginn der natürlichen Uran-Radium-Reihe .
+242m1Am zerfällt mit einer Halbwertszeit von 141 Jahren zu 99,541 % durch Innere Konversion zu 242Am und zu 0,459 % durch α-Zerfall zu 238Np .
+Dieses zerfällt zu 238Pu und dann weiter zu 234U , das auf der Uran-Radium-Reihe liegt .
+243Am ist mit einer Halbwertszeit von 7370 Jahren das langlebigste Americiumisotop .
+Es geht zunächst durch α-Strahlung in 239Np über , das durch β-Zerfall weiter zu 239Pu zerfällt .
+Das 239Pu zerfällt durch α-Strahlung zu Uran 235U , 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 241Am und 243Am von Interesse .
+In der Regel wird es in Form des Oxids ( AmO2 ) verwendet .
+Datei : Americio-alarma.jpg
+Ionisationsrauchmelder Die α-Strahlung des 241Am wird in Ionisationsrauchmeldern genutzt . Es wird gegenüber 226 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 241Am „ endet “ für den Verwendungszeitraum quasi direkt nach dessen α-Zerfall bei 237 Np , das eine Halbwertszeit von rund 2,144 Millionen Jahren besitzt .
+Radionuklidbatterien 241Am wurde wegen seiner gegenüber 238Pu wesentlich längeren Halbwertszeit zur Befüllung von Radionuklidbatterien ( RTG ) von Raumsonden vorgeschlagen .
+Dank seiner Halbwertszeit von 432,2 Jahren könnte ein RTG mit 241Am-Füllung hunderte Jahre lang – anstatt nur einige Jahrzehnte ( wie mit einer 238Pu-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 2020er-Jahren abgeschlossen werden könnte .
+Neutronenquellen 241Am 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 Datei : Am-241 Brush.jpg Neben dem häufig verwendeten 210Po als Ionisator zur Beseitigung von unerwünschter elektrostatischer Aufladung kam auch 241Am 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 242Am entsteht zu 82,7 % Curium ( 242Cm ) und zu 17,3 % Plutonium ( 242Pu ) .
+Im Kernreaktor wird zwangsläufig in geringen Mengen durch Neutroneneinfang aus 243Am das 244Am erbrütet , das durch β-Zerfall zum Curiumisotop 244Cm zerfällt .
+In Teilchenbeschleunigern führt zum Beispiel der Beschuss von 241Am mit Kohlenstoffkernen ( 12C ) beziehungsweise Neonkernen ( 22Ne ) zu den Elementen Einsteinium 247Es beziehungsweise Dubnium 260Db .
+Spektrometer Mit seiner intensiven Gammastrahlungs-Spektrallinie bei 60 keV eignet sich 241Am 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 . 241Am 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 241Am beträgt in den Knochen 50 Jahre und in der Leber 20 Jahre .
+In den Gonaden verbleibt es dagegen offensichtlich dauerhaft .
+Verbindungen → Kategorie : Oxide Von Americium existieren Oxide der Oxidationsstufen + 3 ( Am2O3 ) und + 4 ( AmO2 ) .
+Americium ( III ) - oxid ( Am2O3 ) ist ein rotbrauner Feststoff und hat einen Schmelzpunkt von 2205 ° C.
+Americium ( IV ) - oxid ( AmO2 ) 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 ( UO2 ) bzw. Plutoniumdioxid ( PuO2 ) mit Neutronen .
+Es ist ein schwarzer Feststoff und kristallisiert – wie die anderen Actinoiden ( IV ) - oxide – im kubischen Kristallsystem in der Fluorit-Struktur .
+Halogenide Halogenide sind für die Oxidationsstufen + 2 , + 3 und + 4 bekannt . Die stabilste Stufe + 3 ist für sämtliche Verbindungen von Fluor bis Iod bekannt und in wässriger Lösung stabil .
+Americium ( III ) - fluorid ( AmF3 ) 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 Americium ( IV ) - fluorid ( AmF4 ) ist durch die Umsetzung von Americium ( III ) - fluorid mit molekularem Fluor zugänglich :
+In der wässrigen Phase wurde das vierwertige Americium auch beobachtet .
+Americium ( III ) - chlorid ( AmCl3 ) bildet rosafarbene hexagonale Kristalle .
+Seine Kristallstruktur ist isotyp mit Uran ( III ) - chlorid .
+Der Schmelzpunkt der Verbindung liegt bei 715 ° C. Das Hexahydrat ( AmCl3 · 6 H2O ) weist eine monokline Kristallstruktur auf .
+Durch Reduktion mit Na-Amalgam aus Am ( III ) - Verbindungen sind Am ( II ) - Salze zugänglich : die schwarzen Halogenide AmCl2 , AmBr2 und AmI2 .
+Sie sind sehr sauerstoffempfindlich , und oxidieren in Wasser unter Freisetzung von Wasserstoff zu Am ( III ) - Verbindungen .
+Chalkogenide und Pentelide Von den Chalkogeniden sind bekannt : das Sulfid ( AmS2 ) , zwei Selenide ( AmSe2 und Am3Se4 ) und zwei Telluride ( Am2Te3 und AmTe2 ) .
+Die Pentelide des Americiums ( 243Am ) 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 Americium „ disilicid “ ( AmSix mit : 1,87 < x < 2,0 ) wurden durch Reduktion von Americium ( III ) - fluorid mit elementaren Silicium im Vakuum bei 1050 ° C ( AmSi ) und 1150–1200 ° C ( AmSix ) dargestellt .
+AmSi ist eine schwarze Masse , isomorph mit LaSi .
+AmSix ist eine hellsilbrige Verbindung mit einem tetragonalen Kristallgitter .
+Boride der Zusammensetzungen AmB4 und AmB6 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 , ( η8-C8H8 ) 2Am , 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 2006 ; ISBN 1-4020-3555-1 , S. 1265–1395 ( doi : 10.1007/1-4020-3598-5_8 ) .
+Gmelins Handbuch der anorganischen Chemie , System Nr. 71 , Transurane : Teil A 1 I , S. 30–34 ; Teil A 1 II , S. 18 , 315–326 , 343–344 ; Teil A 2 , S. 42–44 , 164–175 , 185–188 ; Teil B 1 , S. 57–67 . Weblinks Rachel Sheremeta Pepling : Chemical & Engineering News , 2003 . G. T. Seaborg , R. A. James , L. O. Morgan : The New Element Americium ( Atomic Number 95 ) , NNES PPR ( National Nuclear Energy Series , Plutonium Project Record ) , Vol . 14 B The Transuranium Elements : Research Papers , Paper No. 22.1 , McGraw-Hill Book Co. , Inc . , New York , 1949 ( Abstract ; Maschinoskript ( Januar 1948 ) ) . K. Street , Jr. , A. Ghiorso , G. T. Seaborg : The Isotopes of Americium , in : Physical Review , 1950 , 79 ( 3 ) , S. 530–531 ( doi : 10.1103/PhysRev.79.530 ; Maschinoskript ( 11. April 1950 ) ) . Ü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 , 729 , 2003 , S. 3–128 ( ; 1,0 MB ) . Rachel Sheremeta Pepling : Chemical & Engineering News , 2003 . Edgar F. Westrum , Jr. , LeRoy Eyring : The Preparation and Some Properties of Americium Metal , in : J. Am . Chem. Soc . , 1951 , 73 ( 7 ) , S. 3396–3398 ( doi : 10.1021/ja01151a116 ) . Klaus Hoffmann : Kann man Gold machen ? Gauner , Gaukler und Gelehrte . Aus der Geschichte der chemischen Elemente , Urania-Verlag ; Leipzig , Jena , Berlin 1979 , , S. 233. L. H. Baetsle : ( PDF ; 2,4 MB ) , September 2001 . Gabriele Fioni , Michel Cribier , Frédéric Marie : . | text = ' ' Smoke Detectors and Americium . ' ' | url = http://www.world-nuclear.org/info/inf57.html | wayback = 20101112082137 | archiv-bot = 2018-03-25 10:40 :3 4 InternetArchiveBot Informationen zum Element Americium bei www.speclab.com ( engl. ) ; Zugriff : 8. Oktober 2008 . . Akihiro Sasahara , Tetsuo Matsumura , Giorgos Nicolaou , Dimitri Papaioannou : Neutron and Gamma Ray Source Evaluation of LWR High Burn-up UO2 and MOX Spent Fuels , in : Journal of Nuclear Science and Technology , 2004 , 41 ( 4 ) , S. 448–456 ( doi : 10.1080/18811248.2004.9715507 ) . Gmelins Handbuch der anorganischen Chemie , System Nr. 71 , Transurane , Teil B 1 , S. 57–67 . W. Z. Wade , T. Wolf : Preparation and Some Properties of Americium Metal , in : J. Inorg . Nucl . Chem. , 1967 , 29 ( 10 ) , S. 2577–2587 ( doi : 10.1016/0022-1902 ( 67 ) 80183-0 ) . D. B. McWhan , B. B. Cunningham , J. C. Wallmann : Crystal Structure , Thermal Expansion and Melting Point of Americium Metal , in : J. Inorg . Nucl . Chem. , 1962 , 24 ( 9 ) , S. 1025–1038 ( doi : 10.1016/0022-1902 ( 62 ) 80246-2 ) . J. U. Mondal , D. L. Raschella , R. G. Haire , J. R. Peterson : The Enthalpy of Solution of 243Am Metal and the Standard Enthalpy of Formation of Am3 + ( aq ) , in : Thermochim . Acta , 1987 , 116 , S. 235–240 ( doi : 10.1016/0040-6031 ( 87 ) 88183-2 ) . L. B. Werner , I. Perlman : The Pentavalent State of Americium , in : J. Am . Chem. Soc . , 1951 , 73 ( 1 ) , S. 495–496 ( doi : 10.1021/ja01145a540 ) . G. R. Hall , T. L. Markin : The Self-reduction of Americium ( V ) and ( VI ) and the Disproportionation of Americium ( V ) in Aqueous Solution , in : J. Inorg . Nucl . Chem. , 1957 , 4 ( 5–6 ) , S. 296–303 ( doi : 10.1016/0022-1902 ( 57 ) 80011-6 ) . James S. Coleman : The Kinetics of the Disproportionation of Americium ( V ) , in : Inorg . Chem. , 1963 , 2 ( 1 ) , S. 53–57 ( doi : 10.1021/ic50005a016 ) . L. B. Asprey , S. E. Stephanou , R. A. Penneman : A New Valence State of Americium , Am ( VI ) , in : J. Am . Chem. Soc . , 1950 , 72 ( 3 ) , S. 1425–1426 ( doi : 10.1021/ja01159a528 ) . L. B. Asprey , S. E. Stephanou , R. A. Penneman : Hexavalent Americium , in : J. Am . Chem. Soc . , 1951 , 73 ( 12 ) , S. 5715–5717 ( doi : 10.1021/ja01156a065 ) . J. S. Coleman , T. K. Keenan , L. H. Jones , W. T. Carnall , R. A. Penneman : Preparation and Properties of Americium ( VI ) in Aqueous Carbonate Solutions , in : Inorg . Chem. , 1963 , 2 ( 1 ) , S. 58–61 ( doi : 10.1021/ic50005a017 ) . . 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. , 1994 , 14 ( 4 ) , S. 351–367 ( PMID 7917422 ) . E. A. Wurtz , T. H. Sibley , W. R. Schell : Interactions of Escherichia coli and Marine Bacteria with 241Am in Laboratory Cultures , in : Health Phys. , 1986 , 50 ( 1 ) , S. 79–88 ( PMID 3511007 ) . 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 , 1998 , 82 , S. 347–354 ( Abstract und PDF-Download ) . N. Liu , Y. Yang , S. Luo , T. Zhang , J. Jin , J. Liao , X. Hua : Biosorption of 241Am by Rhizopus arrihizus : Preliminary Investigation and Evaluation , in : Appl. Radiat . Isot . , 2002 , 57 ( 2 ) , S. 139–143 ( PMID 12150270 ) . G. Pfennig , H. Klewe-Nebenius , W. Seelmann-Eggebert ( Hrsg. ) : Karlsruher Nuklidkarte , 7. Auflage 2006 . Science daily : , 3. Januar 2001 . H. Dias , N. Tancock , A. Clayton : Critical Mass Calculations for 241Am , 242mAm and 243Am , in : Nippon Genshiryoku Kenkyujo JAERI , Conf , 2003 , S. 618–623 ( Abstract ; PDF ) . Y. Ronen , M. Aboudy , D. Regev : A novel method for energy production using 242mAm as a nuclear fuel , in : Nuclear technology , 2000 , 129 ( 3 ) , S. 407–417 ( Abstract ) . Institut de Radioprotection et de Sûreté Nucléaire : Evaluation of nuclear criticality safety data and limits for actinides in transport , S. 16 ( ) . Y. Ronen , M. Aboudy , D. Regev : Homogeneous 242mAm-Fueled Reactor for Neutron Capture Therapy , in : Nuclear Science and Engineering , 2001 , 138 ( 3 ) , S. 295–304 ( Abstract ) . . ( PDF ; 297 kB ) letzte Seite . Stephen Clark : , in : Spaceflight Now , 9. Juli 2010 . N / A Nuclear Data Viewer 2.4 , NNDC , abgefragt am 11. September 2008 ; Sucheingabe . Lenntech : . Abschnitt 1.5 . Franz Frisch : Klipp und klar , 100 x Energie , Bibliographisches Institut AG , Mannheim 1977 , ISBN 3-411-01704-X , S. 184. . 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. , 1965 , 4 ( 7 ) , S. 985–986 ( doi : 10.1021/ic50029a013 ) . L. B. Asprey : New Compounds of Quadrivalent Americium , AmF4 , KAmF5 , in : J. Am . Chem. Soc . , 1954 , 76 ( 7 ) , S. 2019–2020 ( doi : 10.1021/ja01636a094 ) . L. B. Asprey , R. A. Penneman : First Observation of Aqueous Tetravalent Americium , in : J. Am . Chem. Soc . , 1961 , 83 ( 9 ) , S. 2200–2200 ( doi : 10.1021/ja01470a040 ) . John H. Burns , Joseph Richard Peterson : The Crystal Structures of Americium Trichloride Hexahydrate and Berkelium Trichloride Hexahydrate , in : Inorg . Chem. , 1971 , 10 ( 1 ) , S. 147–151 ( doi : 10.1021/ic50095a029 ) . D. Damien , J. Jove : Americium Disulfide and Diselenide , in : Inorg . Nucl . Chem. Lett . , 1971 , 7 ( 7 ) , S. 685–688 ( doi : 10.1016/0020-1650 ( 71 ) 80055-7 ) . J. W. Roddy : Americium Metallides : AmAs , AmSb , AmBi , Am3Se4 , and AmSe2 , in : J. Inorg . Nucl . Chem. , 1974 , 36 ( 11 ) , S. 2531–2533 ( doi : 10.1016/0022-1902 ( 74 ) 80466-5 ) . D. Damien : Americium Tritelluride and Ditelluride , in : Inorg . Nucl . Chem. Lett . , 1972 , 8 ( 5 ) , S. 501–504 ( doi : 10.1016/0020-1650 ( 72 ) 80262-9 ) . J. P. Charvillat , D. Damien : Americium Monoarsenide , in : Inorg . Nucl . Chem. Lett . , 1973 , 9 ( 5 ) , S. 559–563 ( doi : 10.1016/0020-1650 ( 73 ) 80191-6 ) . F. Weigel , F. D. Wittmann , R. Marquart : Americium Monosilicide and “ Disilicide ” , in : Journal of the Less Common Metals , 1977 , 56 ( 1 ) , S. 47–53 ( doi : 10.1016/0022-5088 ( 77 ) 90217-X ) . Harry A. Eick , R. N. R. Mulford : Americium and Neptunium Borides , in : J. Inorg . Nucl . Chem. , 1969 , 31 ( 2 ) , S. 371–375 ( doi : 10.1016/0022-1902 ( 69 ) 80480-X ) . Christoph Elschenbroich : Organometallchemie , 6. Auflage , Wiesbaden 2008 , ISBN 978-3-8351-0167-8 , S. 589. 
+
+Datei : Helium atom QM DE . svg Datei : Kovalente Atomradien auf Basis der Cambridge Structural Database.svg 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 118 Elemente bekannt , von denen etwa 90 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 6 · 10 − 11 m ( Helium ) bis 5 · 10 − 10 m ( Cäsium ) , ihre Massen in einem Bereich von 1,7 · 10 − 27 kg ( Wasserstoff ) bis knapp 5 · 10 − 25 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 99,9 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 0,06 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 20. 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 20. 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 20. 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 1905 , 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 18. 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 20. Jahrhundert hinein aufrechterhalten .
+In der griechischen Philosophie ist die Atomvorstellung erstmals im 5. 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 18. 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 Datei : A New System of Chemical Philosophy fp.jpg
+Robert Boyle vertrat 1661 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 1740 , 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 18. 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 1789 den heutigen Begriff des chemischen Elements geprägt und die ersten Elemente richtig identifiziert hatte , benutzte 1803 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 1811 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 ) .
+1866 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 1876 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 1895 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 1905 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 1827 bekannte Brownsche Bewegung von Pollen quantitativ erklärt hatte , für deren Ursache schon 1863 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 1897 , 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 1903 von Ernest Rutherford und Frederick Soddy mit Umwandlungen verschiedener Atomsorten ineinander in Verbindung gebracht .
+Sie konnten 1908 nachweisen , dass α-Teilchen , die bei Alphastrahlung ausgesandt werden , Helium-Atome bilden .
+Zusammen mit seiner Forschergruppe beschoss Ernest Rutherford 1909 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 .
+Datei : Mass Spectrometer Schematic DE . svg
+Der Chemiker Frederick Soddy stellte 1911 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 1913 von Margaret Todd vorgeschlagen . Da die Isotope desselben Elements an ihrem chemischen Verhalten nicht zu unterscheiden waren , entwickelte der Physiker J. J. Thomson ein erstes Massenspektrometer zu ihrer physikalischen Trennung .
+Damit konnte er 1913 am Beispiel von Neon nachweisen , dass es auch stabile Elemente mit mehreren Isotopen gibt .
+1918 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 1919 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 1932 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 Datei : Bohr atom model.svg
+1913 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 1859 ) .
+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 .
+1916 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 1916 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 1921 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 .
+Datei : AOs-3D-dots.png Aufbauend auf dem von Louis de Broglie 1924 postulierten Welle-Teilchen-Dualismus entwickelte Erwin Schrödinger 1926 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 1926 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 0,06 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 0,025 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 1938 , 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 1950er Jahren konnten Atome durch die Entwicklung verbesserter Teilchenbeschleuniger und Teilchendetektoren beim Beschuss mit Teilchen sehr hoher Energie untersucht werden . Ende der 1960er 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 .
+1951 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 ) .
+1953 entwickelte Wolfgang Paul die magnetische Ionenfalle ( Paulfalle ) , in der einzelne Ionen gespeichert und mit immer höherer Genauigkeit untersucht werden konnten .
+1985 entwickelte eine Arbeitsgruppe um Steven Chu die Laserkühlung , ein Verfahren , die Temperatur einer Ansammlung von Atomen mittels Laser ­ strahlung 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 1980er 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 1990er Jahren konnten Serge Haroche und David Wineland in Experimenten die Wechselwirkung eines einzelnen Atoms mit einem einzelnen Photon erfolgreich untersuchen .
+In den 2000er 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 Datei :P eriodensystem Z A Name Deutsch.svg Datei : Isotopentabelle Segre.svg
+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 A = Z + N.
+Je nach ihrer Protonenzahl gehören die Atome zu einem der 118 bekannten chemischen Elemente , von Wasserstoff mit Z = 1 bis Oganesson mit Z = 118.
+Davon sind 91 in natürlichen Vorkommen entdeckt worden , 27 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 118 Elemente aus etwa 2800 Isotopen , wovon 2500 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-208 ) .
+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 2003 insgesamt etwa 3200 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 250 Isotope von 80 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 250 stabilen Isotopen 30 Radioisotope gefunden , die sich auf 10 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 100.000-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 1995 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 ( 86 Prozent ) blieben erhalten . Die ersten neutralen Atome mit dauerhaft gebundenen Elektronen wurden erst 380.000 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 Datei : Element-haeufigkeit.svg
+Im beobachtbaren Universum liegen die Atome mit einer mittleren Dichte von 0,25 Atome / m ³ vor .
+Nach dem Urknallmodell ( Lambda-CDM-Modell ) bilden sie etwa 4,9 Prozent der gesamten Energiedichte .
+Der Rest , dessen Natur noch weitgehend unklar ist , setzt sich aus etwa 27 Prozent dunkler Materie und 68 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 104 und 1011 Atome/m3 . Die Sonne befindet sich in der weitgehend staubfreien lokalen Blase , daher ist die Dichte in der Umgebung des Sonnensystems nur etwa 103 Atome/m3 . In festen Himmelskörpern wie der Erde beträgt die Atomdichte etwa 1029 Atome/m3 .
+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 0,06 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 99,9 Prozent der Masse des Atoms .
+Atomkern Aufbau Datei : Binding energy curve - common isotopes DE . svg
+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 1,6 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 2,5 fm Abstand deutlich stärker als die gegenseitige elektrische Abstoßung der Protonen . Unterhalb von etwa 1,6 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 20 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 1 : 1 bis auf etwa 1,5 : 1 , 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 7 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. 106-fache .
+Kerne mit bestimmten Nukleonenzahlen , die als Magische Zahl bezeichnet werden , beispielsweise Helium-4 , Sauerstoff-16 oder Blei-208 , sind besonders stabil , was mit dem Schalenmodell des Atomkerns erklärt werden kann .
+Oberhalb einer Zahl von 82 Protonen ( also jenseits von Blei ) sind alle Kerne instabil .
+Sie wandeln sich durch Ausstoßen eines Kerns He-4 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 43 ( Technetium ) und 61 ( Promethium ) existiert kein stabiler Kern .
+Daher kann es insgesamt nur 80 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 12C ( im Grundzustand inklusive seiner Hüllenelektronen ) eine Masse von exakt 12 u besitzt .
+Damit beträgt 1 u gleich 1,66053904 · 10 − 27 kg . Ein Atom des leichtesten Wasserstoffisotops hat eine Masse von 1,007825 u.
+Das schwerste stabile Nuklid ist das Bleiisotop 208Pb mit einer Masse von 207,9766521 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 6,022 & nbsp ; · & nbsp ; 10 < sup > 23 < / sup > Atome ( oder auch Moleküle oder andere Teilchen ; die betrachtete Teilchenart muss immer mitgenannt werden ) .
+Die Masse von 1 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 g / mol 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 .
+Datei : Nuclear fusion.svg 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-62 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 99,9 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 Wasserstoff ­ atome , 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 32 pm , während eines der größten Atome das Caesium ­ atom ist , das erste Atom der 5. Periode .
+Es hat einen Radius von 225 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 .
+Datei : Fraunhofer lines DE . svg 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 588,99 nm und 589,59 nm , die auch in nebenstehender Abbildung mit D-1 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 1 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 1 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 21-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.
+1868 Helium im Spektrum der Sonne nachgewiesen – über 10 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 Datei : Atomic resolution Au100.JPG Eine direkte Abbildung , die einzelne Atome erkennen lässt , wurde erstmals 1951 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
+Geschichtlicher Überblick zum Atombegriff aus naturphilosophischer Perspektive von Brigitte Falkenburg im Online-Lexikon naturphilosophischer Grundbegriffe .
+Einzelnachweise Charles Kittel : Einführung in die Festkörperphysik . 7. Auflage 1988 , Verlag R. Oldenbourg ( München ) , S. 16. F. Dannemann : Die Naturwissenschaften in ihrer Entwicklung und in ihrem Zusammenhange . Bd. 3 , Verlag W. Engelmann 1922 , S. 198. Loschmidt : Zur Grösse der Luftmoleküle . In : Sitzungsberichte der kaiserlichen Akademie der Wissenschaften Wien . Band 52 , 1866 , Abt. II , S. 395–413 . Walther Kossel : Über Molekülbildung als Frage des Atombaus . Annalen der Physik Bd. 49 , 1916 , S. 229–362 , doi : 10.1002/andp.19163540302 . G. Baur et al. : Production of antihydrogen . In : Physics Letters B. 368 , Nr. 3 , 1996 , S. 251–258 , doi : 10.1016/0370-2693 ( 96 ) 00005-6 ; Preprint online . 
+
+Datei : Auscultation of the anterior Thorax.jpg Datei : Rod of Asclepius2.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 2. 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. Bald ’ s 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 10. 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 13. 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 3. 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 18. 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 1883 .
+2014 war der Anteil der Ärztinnen an der Gesamtzahl der berufstätigen Ärzte bereits auf 45,5 Prozent gestiegen , wenngleich der Anteil der Frauen 2015 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 1,1 –3 , 4 und für Ärztinnen bei 2,5 –3 , 7. 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 1935 ) zu den Freien Berufen und ist ( seit 1887 ) 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 1988 bis Oktober 2004 war zur Erlangung der Vollapprobation zusätzlich eine 18-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 1956 Krankenhäuser , 35,6 % waren 2015 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 2012 waren in Deutschland bei den Landesärztekammern 459.021 Ä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 135.388 Ärzte ( Ende 2008 ) : selbstständige 58.095 Hausärzte und 77.293 Fachärzte . In den Kliniken sind 146.300 Ärzte angestellt .
+Ende 2013 arbeiteten 35.893 ausländische Ärzte in Deutschland , öfter im Osten .
+2013 betrug die Zahl der berufstätigen Ärzte in Deutschland 357.252 .
+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 ( § § 223 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 29. März 2012 weder als Amtsträger i. S. d.
+§ 11 I Nr. 2c StGB noch als Beauftragte der gesetzlichen Krankenkassen i. S. d.
+§ 299 StGB handelten . Die Gesetzeslücke wurde ab 4. Juni 2016 geschlossen , indem StGB ( Bestechlichkeit im Gesundheitswesen ) und StGB ( Bestechung im Gesundheitswesen ) hinzugefügt , sowie § 300 und § 302 StGB geändert wurden .
+Die Erteilung der Approbation hängt seit dem 1. April 2012 nicht mehr von der Staatsangehörigkeit ab ( Änderung des § 3 BAÖ durch § 29 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 1948 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 § 203 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 1971 bis 1990 ) 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 1971 bis 1990 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 30 % niedriger als der europäische Durchschnitt .
+Klinikärzte verbringen rund 44 % ihrer Zeit für Schreibtätigkeiten und Protokolle ( Stand : 2014/2015 ) . Laut einem Projektbericht des Statistischen Bundesamts vom August 2015 wenden Arzt- , Psychotherapeuten- und Zahnarztpraxen jährlich durchschnittlich 96 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 2017 sind 66 % 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. 24 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 2017 , lag der durchschnittliche Reinertrag ( Gesamteinnahmen abzüglich der Kosten ) je niedergelassenem Praxisinhaber im Jahr 2015 bei 192.000 Euro :
+Um einem Mangel an Landärzten entgegenzuwirken , wollte die Bundesregierung 2011 in einem neuen „ Versorgungsgesetz “ das Einkommen von Landärzten erhöhen . Unter einer Vielzahl von Gesetzen war das GKV-Versorgungsstrukturgesetz 2012 und Juni 2015 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 105.
+Deutschen Ärztetag 2002 sind sachliche , berufsbezogene Informationen über ihre Tätigkeit gestattet .
+Hauptkriterium ist dabei das schützenswerte Interesse des mündigen Patienten .
+Umstritten war ab 1998 die Individuelle Gesundheitsleistung eingeführt worden .
+Statistiken Ende 2006 waren in Deutschland ca. 407.000 Ärzte gemeldet , davon 95.700 ohne ärztliche Tätigkeit ( siehe Abb. ) . Die Kassenzulassung besaßen 59.000 Hausärzte und 60.600 Fachärzte .
+In den Krankenhäusern waren 148.300 Ärzte angestellt .
+Im Jahr 2011 wurden in Deutschland rund 342.100 berufstätige Ärzte und rund 107.300 Ärzte ohne ärztliche Tätigkeit gezählt .
+Auf durchschnittlich 239 Einwohner kam ein berufstätiger Arzt .
+Datei : Struktur Aerzteschaft BRD 2006.svg
+Die chronologische Entwicklung kann aus der folgenden Tabelle und der Abbildung abgelesen werden .
+Datei : Entwicklung Ärzteschaft BRD . svg
+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 385.149 Ärztinnen und Ärzte gezählt , die 2017 ärztlich tätig waren , und damit 6.542 Ärzte mehr als im Vorjahr .
+Der Anteil von Frauen stieg weiter an und erreichte 2017 46,8 % , nach 46,5 % im Vorjahr .
+Auch der Anteil älterer Ärzte stieg weiterhin an .
+2017 waren 18,4 % der Ärzte 60 Jahre oder älter ( 2016 : 17,9 % ) .
+Insgesamt waren 2017 172.647 Ärztinnen und Ärzte in der vertragsärztlichen Versorgung , also als Niedergelassene tätig , selbständig oder bei einem Vertragsarzt angestellt .
+Arztbesuche : Deutsche Erwachsene ( zwischen 18 und 79 Jahren ) gehen im Durchschnitt 9,2-mal pro Jahr zum Arzt .
+Österreich In Österreich ist man mit der Sponsion zunächst Doktor der gesamten Heilkunde ( Doctor medicinae universae / Dr. 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 2002/03 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 14. Dezember 2010 hat die EU-Kommission in ihrem Amtsblatt C377/10 eine Änderungsmitteilung für die , Anhang 5.1.1 . 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 5 Ärzten je 1000 Einwohner ist mit die höchste Ärztedichte Europas und eine der höchsten weltweit .
+Einwohnerquote Kassenärzte : Da in Österreich eine Pflichtversicherung herrscht , sind 99 % der Bevölkerung Krankenkassenzahler .
+Die Quote ist also repräsentativ .
+Weiterbildung Ärzte müssen in Österreich pro Jahr 50 Stunden Weiterbildung absolvieren , was alle 5 Jahre von der Ärztekammer kontrolliert wird .
+Schweiz 2017 arbeiteten in der Schweiz rund 36 ' 700 ( 36 ' 900 , je nach Quelle ) Ärzte , davon rund 15 ' 200 ( 42 % ) Frauen und 21 ' 400 ( 58 % ) Männer , 51 % im ambulanten und 47 % im stationären Sektor , rund 12 ' 600 ( 34 % ) 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 3 ( „ praktischer Arzt “ ) und 8 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 60–100 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 1. Januar 2005 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 50 Stunden ( Art. 9 ArG , Wöchentliche Höchstarbeitszeit ) . Sie ist zwar bedeutend höher als die allgemein übliche Arbeitszeit in der Schweiz ( 38,5 –42 , 5 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 60 oder 70 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 , 2017/18 ) 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 120 ' 000 und 360 ' 000 CHF leitender Arzt – zwischen 200 ' 000 und 600 ' 000 CHF Chefarzt – zwischen 250 ' 000 und 750 ' 000 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 370 ' 000 CHF leitende Ärzte – rund 290 ' 000 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 9-Fachen des Grundlohns betragen .
+' Einzelne Chefärzte kommen so auf Jahreslöhne von 2 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
@@ -6277,3310 +3959,2288 @@
 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
+Vertragsarzt ( Kassenarzt ) Zahnarzt
+Literatur Wolfgang U. Eckart : Geschichte der Medizin . 5. Auflage .
+Springer , Berlin u. a. 2005 , ISBN 3-540-21287-6 . ( 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
+) Wilhelm Haberling , Franz Hübotter , Hermann Vierordt ( Bearb. ) : Biographisches Lexikon der hervorragenden Ärzte aller Zeiten und Völker . 2. Auflage .
+Urban & Schwarzenberg , Berlin / Wien 1929–1935 . Markus Vieten : Via medici-Buchreihe : Berufsplaner Arzt oder was man mit einem Medizinstudium alles anfangen kann . Thieme Verlag , Stuttgart 2003 , ISBN 3-13-116105-1 . Vittoria Bucknall , Suendoss Burwaiss , Deborah MacDonald , Kathy Charles , Rhys Clement : Mirror mirror on the ward , who ’ s the most narcissistic of them all ?
+Pathologic personality traits in health care .
+In : Canadian Medical Association Journal . 187 , 2015 , S. 1359–1363 . Ralf Bröer : Medizinalgesetzgebung / Medizinrecht . In : Werner E. Gerabek , Bernhard D. Haage , Gundolf Keil , Wolfgang Wegner ( Hrsg. ) : Enzyklopädie Medizingeschichte . Walter de Gruyter , Berlin / New York 2005 , ISBN 3-11-015714-4 , S. 942–950 . Werner E. Gerabek , Bernhard D. Haage , Gundolf Keil , Wolfgang Wegner ( Hrsg. ) : Enzyklopädie Medizingeschichte . De Gruyter , Berlin / New York 2005 , ISBN 3-11-015714-4 , insbesondere S. 105–108 ( Stichworte Arzt [ … ] ) und S. 121–123 ( Ausbildung , ärztliche . ) Giovanni Maio : Arztbild . In : Werner E. Gerabek u. a. ( Hrsg. ) : Enzyklopädie Medizingeschichte . 2005 , S. 106–108 . 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 , 2003 , ISBN 3-8260-2176-2 , S. 199–202 . Wolfgang Wegner : Arzt . In : Werner E. Gerabek u. a. ( Hrsg. ) : Enzyklopädie Medizingeschichte . 2005 , S. 105 f. Weblinks Nationales : Hendrik Schneider und Thorsten Ebermann : hrr-strafrecht.de Einzelnachweise Bernhard Dietrich Haage : Medizinische Literatur des Deutschen Ordens im Mittelalter . In : Würzburger medizinhistorische Mitteilungen . Band 9 , 1991 , S. 217–231 ; hier : S. 222. Heinrich Schipperges : Zur Unterscheidung des „ physicus “ vom „ medicus “ bei Petrus Hispanus . In : III ° Congresso Nacional de Historia de la Medicina ( Valencia 1969 ) . III ( 1972 ) , S. 321–327 . Theodor Kirchhoff : Ueberblicke über die Geschichte der deutschen Irrenpflege im Mittelalter . In : Allgemeine Zeitschrift für Psychiatrie und psychiatrisch-gerichtliche Medizin . Band 87 , 1887 , Heft 1 , S. 61–103 , hier : S. 102. Johann Hermann Baas : Die geschichtliche Entwicklung des ärztlichen Standes und der medicinischen Wissenschaften . Berlin 1896 . In : servana.de 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 2005 , ISBN 3-11-015714-4 , S. 915–920 ; hier : S. 918. 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 2005 , ISBN 3-11-015714-4 , S. 122 f. ; hier : S. 122. Ralf Bröer : Medizinalgesetzgebung / Medizinrecht . In : Werner E. Gerabek , Bernhard D. Haage , Gundolf Keil , Wolfgang Wegner ( Hrsg. ) : Enzyklopädie Medizingeschichte . Walter de Gruyter , Berlin / New York 2005 , ISBN 3-11-015714-4 , S. 942–950 ; hier : S. 943. In : welt.de , 27. Februar 2016 . R. Tyssen : Health problems and the use of health services among physicians : a review article with particular emphasis on Norwegian studies . In : Ind Health . 45 ( 5 ) , Okt 2007 , S. 599–610 . PMID 18057803 . 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 2004 , ISBN 3-8017-1032-7 , S. 332. T. L. Schwenk , L. Davis , L. A. Wimsatt : In : JAMA . Band 304 , Nummer 11 , September 2010 , S. 1181–1190 , . doi : 10.1001/jama.2010.1300 . PMID 20841531 . Thomas Bronisch : Suizidalität der Psychotherapeuten . In : Otto F. Kernberg , Birger Dulz , Jochen Eckert : WIR : Psychotherapeuten . 1. Auflage . Schattauer , Stuttgart 2006 , ISBN 3-7945-2466-7 , S. 116–117 . E. Schernhammer : Taking their own lives – the high rate of physician suicide . In : The New England Journal of Medicine . Band 352 , Nummer 24 , Juni 2005 , S. 2473–2476 , . doi : 10.1056/NEJMp058014 . PMID 15958803 . K. Püschel , S. Schalinski : Zu wenig Hilfe für sich selbst – Ärzte in Suizidgefahr . In : Archiv für Kriminologie . Band 218 , Nummer 3–4 , Sep-Okt 2006 , S. 89–99 , . PMID 17067089 . C. Reimer , S. Trinkaus , H. B. Jurkat : Suizidalität bei Ärztinnen und Ärzten . In : Psychiatrische Praxis . Band 32 , Nummer 8 , November 2005 , S. 381–385 , . doi : 10.1055/s-2005-866903 . PMID 16308801 . M. Wolfersdorf : Suicide and suicide prevention for female and male physicians . In : MMW Fortschr Med. 149 ( 27–28 ) , 28. Jun 2007 , S. 34–36 . PMID 17715662 . Friedbert Ficker : Schutzpatrone der Ärzte und Apotheker . In : Bayerische Staatszeitung . Band 20 , Nr. 9 , Heimatbeilage Unser Bayern . 1971 . Ralf Bröer : Medizinalgesetzgebung / Medizinrecht . S. 943. In : bundesaerztekammer.de , 23. Oktober 2015 , abgerufen am 9. November 2017 . In : bundesaerztekammer.de , abgerufen am 9. November 2017 . In : bundesaerztekammer.de , abgerufen am 9. November 2017 . In : bundesaerztekammer.de , 31. Dezember 2013 . abgerufen am 9. November 2017 . Zahl der Woche . In : F. A. S. 20. April 2014 , S. C1 . BGH-GS Beschl. v. 29. März 2012 – GSSt 2/11 , BeckRS 9998 , 126831 . In : openjur.de Änderung § 3 Bundesärzteordnung vom 1. April 2012 , buzer.de Pressemitteilung : In : iqwig.de Teil I , Kapitel „ 1 Zusammenfassung “ , S. 20. . ( PDF ) , Statistisches Bundesamt ( Destatis ) , 2015/2017 In : Rheinische Post . 9. Mai 2011 . Gehälter in Kliniken nach Positionen . praktischarzt.de In : arzt-und-apotheke.net , abgerufen am 22. Februar 2013 . may / EB : Ärztestatistik – Mehr Ärzte , Trend zur Anstellung . In : Deutsches Ärzteblatt . Jahrgang 115 , Heft 14 , 6. April 2018 , S. A621 . N. Weber : In : Spiegel Online . 14. September 2016 . wegweiser.ac.at . In : Amtsblatt der Europäischen Union . 14. Dezember 2010 . 2009 hatte in Europa nur Griechenland eine höhere Ärztedichte als Österreich ; OECD 2011 , Angabe nach Ärztinnen und Ärzte : Bedarf und Ausbildungsstellen 2010 bis 2030 . Papier zu einer Studie der Gesundheit Österreich GmbH im Auftrag des Gesundheitsministeriums und Wissenschafts- und Forschungsministeriums in Kooperation mit der Österreichischen Ärztekammer , Pressekonferenz , 20. Juli 2012 , Pressezentrum Sozialministerium , Abschnitt Bestandsanalyse . S. 4 ( bmg . gv . at ) . Ärzte nicht zu Reanimationsschulung verpflichtet orf . at , 12. Mai 2018 , abgerufen am 12. Mai 2018 . . Web der Verbindung der Schweizer Ärztinnen und Ärzte ( FMH ) , fmh . ch . Web des Bundesamtes für Gesundheit , ( BAG ) , bag . admin.ch Art. 9 , Wöchentliche Höchstarbeitszeit in : SR 822.11 Bundesgesetz über die Arbeit in Industrie , Gewerbe und Handel ( Arbeitsgesetz , ArG ) in Systematischer Sammlung des Bundesrechts ( SR ) , auf admin.ch Arbeitsgesetz ( Assistenz- und Oberärzte ) , auf Web des VSAO , Verband Schweizerischer Assistenz- und Oberärztinnen und - ärzte , vsao.ch Arbeitszeit in der Schweiz , auf Web des Grenzgänger-Arbeitnehmer-Arbeitgeber-Verbands ( GAAV ) , gaav.de ( gaav.ch ) . Web FMH , fmh . ch ; . ( PDF ) Editorial , Schweizerische Ärztezeitung , Nr. 10 , 2018 , auf Web FMH , fmh . ch ; ( PDF ) Editorial , Schweizerische Ärztezeitung , Nr. 31–32 , 2013 , auf Web FMH , fmh . ch Simon Hehli , Jan Hudec : . In : NZZ . 31.10.17 VSAO , Verband Schweizerischer Assistenz- und Oberärztinnen und - ärzte , vsao.ch ; . VSAO Zürich , auf vsao-zh.ch 
+
+Datei :D a Vinci Vitruve Luc Viatour 2.svg Anthropologie ( im 16. 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 ( 1449–1519 ) , der in einem 1501 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 1799 an der Ingolstädter Universität als Vorlesung anbot .
+Ein Lehrstuhl für „ Allgemeine Naturgeschichte und Anthropologie “ wurde 1826 in München eingerichtet .
+Friedrich Nasse gab von 1823 bis 1826 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 1. August 1886 Johannes Ranke berufen , dem 1917 der Schweizer Rudolf Martin ( 1864–1925 ) folgte , der 1918 Direktor des Anthropologischen Instituts und der Anthropologisch-Prähistorischen Staatssammlung wurde .
+Martin war 1900 zum Extraordinarius und 1905 zum Ordinarius für Anthropologie an der Universität Zürich ernannt worden .
+Naturwissenschaftlicher Ansatz Biologische Anthropologie Datei :P hysical anthropologist.jpg 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 Datei : Galton at Bertillon & #39 ; s ( 1893 ) . 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
+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 1960er 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 Globalisierungs ­ prozesse veränderten Forschungslandschaft Rechnung tragen möchte .
+Kulturanthropologie Datei : Schultuete.jpg
+Die Kulturanthropologie ist eine empirisch gestützte Wissenschaft von der Kultur ( im Sinne von „ menschliche Kultur “ ) . Sie entwickelte sich im 20. 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 20. Jahrhundert als Reaktion auf den Verlust von Weltorientierung entstand .
+Mit Ausnahme von René Descartes , der bereits Mitte des 17. Jahrhunderts in seinen Meditationen über die erste Philosophie ( 1641 ) 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 1300 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 Datei :D haka street crowds.jpg
+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 1970 eine „ reflexive Anthropologie “ entwickelt ( Bob Scholte 1970 ) . 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 16. Jahrhundert aufgekommene medizinische Anthropologie beschäftigt sich mit der Wechselwirkung von Kultur und Medizin .
+Anthropologie als Oberbegriff und Dachwissenschaft Datei :C leveland Museum of Art - damaged Thinker.jpg
+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 1977 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 1977 ä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 8/9 , 2012/2013 , ISBN 978-3-86888-077-9 , S. 437–453 . 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
+.
+Themenheft : Grenzpunkt Mensch .
+Nr. 4 , 1996 .
+Verlag der blaue Reiter , ISBN 978-3-9804005-3-4 . Joachim Bauer : Prinzip Menschlichkeit .
+Warum wir von Natur aus kooperieren .
+Hoffmann und Campe , Hamburg 2006 , ISBN 3-455-50017-X . Eike Bohlken , Christian Thies ( Hrsg. ) : Handbuch Anthropologie .
+Der Mensch zwischen Natur , Kultur und Technik .
+Metzler , Stuttgart 2009 , ISBN 978-3-476-02228-8 . Martin Buber : Ich und Du . Insel , Leipzig 1923 ; Reclam , Stuttgart 1995 , ISBN 3-15-009342-2 . Zeno Bucher : Die Abstammung des Menschen als naturphilosophisches Problem . Koenigshausen & Neumann , Würzburg 1992 , ISBN 3-88479-721-2 . Werner Fuchs u. a. ( Hrsg. ) : Lexikon zur Soziologie .
+Westdeutscher Verlag , Opladen 1978 , 1995 , ISBN 3-531-11417-4 . Hans-Georg Gadamer , Paul Vogler ( Hrsg. ) : Neue Anthropologie . Thieme , Stuttgart und dtv , München 1972–1975 ( Band 1 und 2 : Biologische Anthropologie . Band 3 : Sozialanthropologie . Band 4 : Kulturanthropologie . Band 5 : Psychologische Anthropologie . Band 6 und 7 : Philosophische Anthropologie ) .
+Gisela Grupe u. a. : Anthropologie .
+Ein einführendes Lehrbuch .
+Springer , Berlin 2005 , ISBN 3-540-21159-4 . Marvin Harris : Menschen . DTV , München 1996 , ISBN 3-423-30530-4 . Winfried Henke , Hartmut Rothe : Menschwerdung . Fischer , Frankfurt 2003 , ISBN 3-596-15554-1 . Uwe Hoßfeld : Geschichte der biologischen Anthropologie in Deutschland . Von den Anfängen bis in die Nachkriegszeit .
+Steiner , Stuttgart 2005 , ISBN 3-515-08563-7 . Holger Jebens , Karl-Heinz Kohl ( Hrsg. ) : The End of Anthropology ? Sean Kingston , Wantage 2011 , ISBN 978-1-907774-28-7 ( englisch ; deutsche Professoren ; ausführliche Fachbesprechung : doi : 10.1080/00664677.2014.899201 ) .
+Rainer Knußmann ( Hrsg. ) : Anthropologie . Handbuch der vergleichenden Biologie des Menschen .
+Bd. 1/I , 1/II .
+Fischer , Stuttgart 1988/1992 , ISBN 3-437-30505-0 . Marc Rölli : Kritik der anthropologischen Vernunft . Matthes & Seitz , Berlin 2011 , ISBN 978-3-88221-539-7 . Max Scheler : Die Stellung des Menschen im Kosmos . In : Max Scheler : Gesammelte Werke . Band 9 , Francke , Bern 1976 , ISBN 3-7720-1039-3 . Friedemann Schrenk , Timothy G. Bromage , Henrik Kaessmann : Die Frühzeit des Menschen .
+Zurück zu den Wurzeln .
+In : Biologie in unserer Zeit . Nr. 32 , Weinheim 2002 , , S. 352–359 . Thomas Suddendorf : Der Unterschied : Was den Mensch zum Menschen macht .
+Berlin Verlag , Berlin 2014 , ISBN 3-8270-1093-4 . Ferdinand Tönnies : Schriften und Rezensionen zur Anthropologie , hg. von Rolf Fechner . Profil , München und Wien 2009 , ISBN 978-3-89019-656-5 . Christoph Wulf : Anthropologie .
+Geschichte , Kultur , Philosophie .
+Rowohlt , Reinbek 2004 , ISBN 3-499-55664-2 . Geschichte : Wilhelm E. Mühlmann : Geschichte der Anthropologie .
+4. Auflage .
+Aula , Wiesbaden 1986 , ISBN 3-89104-413-5 . Christoph Wulf ( Hrsg. ) : Vom Menschen .
+Handbuch Historische Anthropologie .
+Beltz , Weinheim / Basel 1997 . Glenn H. Penny , Matti Bunzl ( Hrsg. ) : Worldly Provincialism .
+German Anthropology in the Age of Empire .
+Ann Arbor 2003 . Bernhard Rathmayr : Die Frage nach den Menschen .
+Eine historische Anthropologie der Anthropologien .
+Barbara Budrich , Opladen 2013 . Medizinische Anthropologie : Eduard Seidler ( Hrsg. ) : Medizinische Anthropologie .
+Beiträge für eine Theoretische Pathologie .
+Berlin / Heidelberg / New York / Tokyo 1984 ( = 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 1980 ( 1996 ) , ISBN 3-437-25040-X . Pädagogische Anthropologie : Herbert Becker ( Hrsg. ) : Anthropologie und Pädagogik . Klinkhardt , Bad Heilbrunn 1977 , ISBN 3-7815-0339-9 . D. Kamper , Ch. Wulf ( Hrsg. ) : Anthropologie nach dem Tode des Menschen . Suhrkamp , Frankfurt 1994 , ISBN 3-518-11906-0 . Norbert Kühne : Aspekte und Probleme früher Entwicklung und Erziehung . In : Unterrichtsmaterialien Pädagogik-Psychologie ( Nr. 694 ) , Stark Verlag / Mediengruppe Pearson , Hallbergmoos 2012–2015 . Johanna Uher ( Hrsg. ) : Pädagogische Anthropologie und Evolution . Erlangen 1995 , ISBN 3-930357-06-2 . Christoph Wulf : Einführung in die pädagogische Anthropologie . Beltz , Weinheim / Basel 1994 , ISBN 3-407-25149-1 . Spezielle Themen : Manfred Engel : Romantische Anthropologie .
+Skizze eines Forschungsprojekts .
+In : Historische Anthropologie . Band 8 , 2000 , S. 264–271 . Michael Post : Entwurf der Grundlegung der fundamentalontologischen Anthropologie und natürlichen Theologie . Neuss 2007 , ISBN 978-3-00-021294-9 . Bernhard Verbeek : Die Anthropologie der Umweltzerstörung , die Evolution und der Schatten der Zukunft . Primus , Darmstadt 1998 , ISBN 3-89678-099-9 . 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 2004 , ISBN 3-89785-451-1 . Weblinks Gesellschaft für Anthropologie Einzelnachweise Axel W. Bauer : Bemerkungen zur Verwendung des Terminus „ Anthropologie “ in der Medizin der Neuzeit ( 16. –19. Jahrhundert ) . In : Eduard Seidler ( Hrsg. ) : Medizinische Anthropologie . 1984 , S. 32–55 . Seite der Arbeitsstelle Kleine Fächer zur Anthropologie , abgerufen am 17. April 2019 Axel W. Bauer : Was ist der Mensch ? Antwortversuche der medizinischen Anthropologie . In : Fachprosaforschung – Grenzüberschreitungen 8/9 , 2012/2013 , ISBN 978-3-86888-077-9 , S. 437–453 , insbesondere S. 441–444 , hier : S. 441 f. Christian Friedrich Nasse ( Hrsg. ) : Zeitschrift für die Anthropologie . Cnobloch , Leipzig 1823–1826 ; vorher : Friedrich Nasse ( Hrsg. ) : Zeitschrift für psychische Ärzte . Band 1–2 , Leipzig 1818–1819 ; derselbe ( Hrsg. ) : Zeitschrift für psychische Ärzte , mit besonderer Berücksichtigung des Magnetismus . Leipzig 1880–1822 . Nachruf Martin Rudolf ( Jahrbuch 1926 , Mollier ) - badw.de Gerfried Ziegelmayer : 100 Jahre Anthropologie in München . In : Würzburger medizinhistorische Mitteilungen . Band 5 , 1987 , S. 245–269 , hier : S. 245–253 . Wulf , Kamper : Anthropologie . In : Heinz-Elmar Tenorth , Rudulf Tippelt ( Hrsg. ) : BELTZ . Lexikon Pädagogik . Beltz , Weinheim / Basel 2007 , S. 26–28 . Axel Honneth , Hans Joas : Soziales Handeln und menschliche Natur . Anthropologische Grundlagen der Sozialwissenschaften . Campus , Frankfurt am Main 1980 , S. ?? . I. L. Horowitz : The life and death of project Camelot . In : American Psychologist . Band 21 , Nr. 5 , 1966 , S. 445–454 ( doi : 10.1037/h0021152 ) . Wolf Lepenies : Soziologische Anthropologie . Materialien . München : Hanser 1974 , S. 49. Gesa Lindemann : Das Soziale von seinen Grenzen her denken . Velbrück , Weilerswist 2009 , S. ?? . Axel W. Bauer : Was ist der Mensch ? Antwortversuche der medizinischen Anthropologie . 2012/13 ( 2014 ) , S. 447 f. Erich Weber : Pädagogische Anthropologie . Donauwörth , Ludwig Auer Verlag , 8. Aufl. 1995 , S. 23 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. 1994 , S. 8. Winfried Effelsberg : Interkulturelle Konflikte in der Medizin . Medizinanthropologische Überlegungen . In : Würzburger medizinhistorische Mitteilungen . Band 3 , 1985 , S. 29–40 , hier : S. 29 ( zitiert ) . Axel W. Bauer : Was ist der Mensch ? Antwortversuche der medizinischen Anthropologie . In : Fachprosaforschung – Grenzüberschreitungen 8/9 , 2012/2013 , ISBN 978-3-86888-077-9 , S. 437–453 , insbesondere S. 441–444 . Übersicht 1 aus : Gerhard Medicus , Was uns Menschen verbindet : Humanethologische Angebote zur Verständigung zwischen Leib- und Seelenwissenschaften . 2. Auflage . VWB , Berlin 2013 , ISBN 978-3-86135-583-0 . 
+
+Datei : Napoli BW 2013-05-16 16-24-01.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
+( * 20. Juli 356 v. Chr. in Pella ; † 10. Juni 323 v. Chr. in Babylon ) war von 336 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 ( 356–336 v. Chr. ) Datei : Alexander &amp; Bucephalus by John Steell.JPG
+Alexander wurde im Jahre 356 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 5. 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 6. Jahrhundert v. Chr.
+verstärkte sich der griechische kulturelle Einfluss in der makedonischen Oberschicht .
+Datei : Karte Makedonien 336 vC-de.svg
+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 ( 338 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 337 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 , 9 ) 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 336 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 ( 336–335 v. Chr. ) Datei : AlexanderTheGreat Bust Transparent.png
+Im Jahre 336 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 336 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 335 v. Chr.
+mit 15.000 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 30.000 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 ( 334–333 v. Chr. ) Datei : MakedonischesReich.jpg
+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 492 und 479 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 340 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 334 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 150 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 334 v. Chr. mit einer Armee aus etwa 35.000 Makedonen und Griechen , um in die Kämpfe einzugreifen , während rund 12.000 Makedonen unter Antipatros Makedonien und Griechenland sichern sollten .
+In der Schlacht am Granikos ( Mai 334 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 20.000 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 400 Schiffen versprochen worden war .
+Da auch Alexander von dieser Flotte gehört hatte , wies er Nikanor , einen Bruder Parmenions , an , mit 160 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 334/333 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 333 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 ( 333 v. Chr. ) Datei : Alexander Sarcophagus.jpg
+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 600.000 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 100.000 , die Stärke des makedonischen Heeres dagegen auf ca. 25 – 30.000 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 450 Tote und 4000 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 4000 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 „ 2600 Talente in Münzgeld und 500 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 ( 332 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 “ , 10.000 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 250 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 8000 Gefallenen der Stadt soll sich auf die gesamte Belagerungszeit beziehen . Ob die anschließende angebliche Kreuzigung von 2000 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 30.000 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 45 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 332 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 .
+Datei :O lympias.1.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 , 700 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 332 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 10.000 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 332 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 ( 332 v. Chr. ) Während Alexander mit dem Heer 332 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 333 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 332 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 15 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 332 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 ( 332–331 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 800 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 331 v. Chr. an der Mittelmeerküste Alexandria , die bedeutendste all seiner Stadtgründungen .
+Im März zog Alexander von Paraetonium aus 400 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 ( 331–330 v. Chr. ) Im Mai 331 v. Chr. kehrte Alexander nach Tyros zurück .
+Er befahl hier den Wiederaufbau der Stadt , die er mit befreundeten Phöniziern wieder besiedeln ließ .
+15.000 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 40.000 Fußsoldaten und 7000 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 331 v. Chr. überquerte das Heer den Tigris .
+Am 20. 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 11 km von der persischen Armee entfernt bei einem Dorf namens Gaugamela , weshalb die folgende Schlacht als Schlacht von Gaugamela bekannt wurde .
+Am 1. 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 330 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 ( 330 v. Chr. ) Datei :D arius III.jpg
+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 ( 330–329 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 330 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 329 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 75 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 ( 329–327 v. Chr. ) Datei : AlexandreLouvre.jpg
+Nach der Einnahme von Marakanda zog Alexander noch weiter bis zum Syrdarja und gründete dort im Mai 329 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 329/328 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 328 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 328 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 327 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 11.000 Mann Besatzung in den eroberten Gebieten Sogdiens zurück .
+Alexander in Baktrien ( 327 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 , 30.000 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 ( 326 v. Chr. ) Datei : Tetradrachm Ptolemaeus I obverse CdM Paris FGM2157.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 326 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 30 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 ( 326–325 v. Chr. ) Der beschwerliche Rückweg zum Hydaspes dauerte bis zum September .
+In Bukephala war mit dem Bau von 800 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 325 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 325 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 100.000 Mann bis zu wahrscheinlich realistischeren 30.000 .
+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 ( 324 v. Chr. ) Datei : Istanbul - Museo archeol .
+- Sarcofago di Alessandro , sec. IV a. C. - Foto G. Dall & #39 ;O rto 28-5-2006 08.jpg
+Alexander gründete im Januar 324 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 10.000 persische Frauen mit Soldaten zu verheiraten – die Massenhochzeit von Susa .
+Die Ehen wurden von Alexander als Notwendigkeit gesehen , um das Zusammenwachsen von Persern und Makedonen / Griechen 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 6000 Söldnern und 5000 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 .
+11.500 griechische Soldaten wurden in den Folgetagen nach Hause geschickt .
+Im Herbst des Jahres 324 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 ( 323 v. Chr. ) Datei : Mid-nineteenth century reconstruction of Alexander & #39 ; s catafalque based on the description by Diodorus.jpg
+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 324 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 323 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 322 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 10. 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 Datei :P tolemaeus I &amp; Berenike I.jpg
+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 1. 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 4. Jahrhunderts zu sehen gewesen sein ) .
+Der Kirchenvater Johannes Chrysostomos ( † 407 ) 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 10. Jahrhundert wurde eine angebliche Grabstätte gezeigt .
+Im 15. und 16. Jahrhundert berichteten europäische Reisende von einem kleinen Gebäude in Alexandria , das als Alexandergrab ausgegeben wurde .
+Seit dem 18. Jahrhundert sind viele Lokalisierungsversuche unternommen worden , die bisher alle fehlgeschlagen sind .
+Geschichtlicher Ausblick Datei :D iadochen1.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
+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 148 v. Chr. ) , das der Seleukiden in Vorderasien ( bis 64 v. Chr. ) und das der Ptolemäer in Ägypten ( bis 30 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 331 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 2. 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 17. 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 Datei : Niketerion Alexander CdM.jpg
+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 3. 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 4. 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 ( † 63 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 4. 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 Datei : The coronation of Alexander.jpg
+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 80 Dichtungen in 35 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 Datei : Alexander the Great , Ghent , Ms. 92.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 60 Handschriften erhaltener , spätestens im 9. Jahrhundert entstandener Auszug ( Epitome ) aus diesem Werk .
+Um 968/969 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 13. 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 1237/1238 eine Versfassung der Historia de preliis in elegischen Distichen , die im Spätmittelalter populär wurde .
+Noch weit einflussreicher war aber die schon zwischen 1178 und 1182 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 13. 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 12. 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 12. 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 Datei : Jean Fouquet- The Coronation of Alexander , from the book Histoire Ancienne.JPG
+Alberich von Bisinzo ( Albéric de Pisançon ) , der im frühen 12. 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 12. Jahrhunderts entstanden weitere französische Gedichte , die einzelne Episoden aus Alexanders Leben ( Belagerung von Tyros , Indienfeldzug , Lebensende ) behandelten .
+Sie wurden im späten 12. Jahrhundert zur „ Standardversion “ des altfranzösischen Roman d ’ Alexandre ( auch : Roman d ’ Alixandre ) zusammengefügt , die von allen im romanischen Sprachraum verbreiteten volkssprachlichen Bearbeitungen des Stoffs die stärkste Wirkung erzielte .
+Dieses Epos besteht aus über 20 000 Versen , Zwölf- und Dreizehnsilbern ; vom Roman d ’ Alexandre 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 12. 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 15. Jahrhundert entstanden Prosafassungen des Roman d ’ Alexandre .
+Der altfranzösische Prosa-Alexanderroman fand weite Verbreitung .
+Einen Höhepunkt erreichte die Alexander-Bewunderung im Herzogtum Burgund am Hof Herzog Philipps des Guten ( † 1467 ) und seines Nachfolgers , Karls des Kühnen .
+Die bedeutendste spanische Bearbeitung des Stoffs ist El libro de Alexandre .
+Dieses Epos umfasst über 10 000 Verse ( Alexandriner ) und ist damit die umfangreichste epische Dichtung Spaniens aus dem 13. 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 14. 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 15. Jahrhundert erreichte das Interesse an der Alexandersage in Italien seinen Höhepunkt .
+Deutsche Literatur Die deutschsprachige Alexandersage und Alexanderdichtung setzte um die Mitte des 12. 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 13. 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 1271 und 1282 entstandenen Gedicht Alexander ( 28.000 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 .
+1352 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 14. und im 15. Jahrhundert war der Alexanderstoff in neuen Prosabearbeitungen weit verbreitet ; die eine befindet sich im Großen Seelentrost ( Mitte des 14. Jahrhunderts ) , die andere ist Johann Hartliebs Histori von dem grossen Alexander , die nach der Mitte des 15. 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 15. 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 14. 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 Datei : San marco alexander.jpg 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 7. 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 . 1388 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 14. 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 18 erwähnt wird , dass er einen Damm gegen Gog und Magog errichtete ( Verse 83–98 ) .
+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 18. Sure ( Verse 59–81 ) 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ī ( † 819/821 ) 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 Datei : Iskandar ( Alexander the Great ) at the Talking Tree.jpg
+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ī ( † 1020 ) 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 .
+1191 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 14. Jahrhundert mit Buchmalerei geschmückt .
+In Nordindien sorgten die Mogul-Kaiser des 16. Jahrhunderts für die Bebilderung solcher Bücher .
+Im Jahr 1390 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 Datei :C harles Le Brun - Entry of Alexander into Babylon.JPG
+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 ( † 1534 ) , 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 1468 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 .
+1528/29 schuf der Maler Albrecht Altdorfer sein berühmtes Gemälde Die Alexanderschlacht .
+Charles Le Brun malte ab den frühen sechziger Jahren des 17. 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 17. 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 1558 eine Tragedia von Alexandro Magno , die in sieben Akten die ganze Geschichte Alexanders darstellt .
+In Frankreich verfasste Jacques de la Taille 1562 die Tragödien La Mort de Daire und La Mort d'Alexandre , und Alexandre Hardy wählte dieselben Titel für zwei seiner Tragödien ( La Mort d'Alexandre , 1621 , und La Mort de Daire , 1626 ) .
+Im weiteren Verlauf des 17. Jahrhunderts folgten zahlreiche Tragödien und Tragikomödien , darunter Racines Alexandre le Grand ( Uraufführung 1665 ) .
+Noch intensiver war die Rezeption in italienischer Sprache .
+Antonio Cesti komponierte die Oper Alessandro vincitor di se stesso ( Uraufführung Venedig 1651 ) , Francesco Lucio ein „ dramma musicale “ Gl'amori di Alessandro Magno e di Rossane ( Libretto von Giacinto Andrea Cicognini , 1651 ) ; zahlreiche Dramen , Melodramen , Opern und Ballette folgten .
+Unter den Opern waren besonders erfolgreich Alessandro Magno in Sidone von Marc ’ Antonio Ziani ( 1679 , Libretto von Aurelio Aureli ) , die „ tragicommedia per musica “ Alessandro in Sidone von Francesco Bartolomeo Conti ( 1721 , Libretto : Apostolo Zeno ) und Alessandro nell ’ Indie von Leonardo Vinci ( 1729 , Libretto : Pietro Metastasio ) sowie vor allem Alessandro von Händel ( Uraufführung in London 1726 , Libretto von Paolo Antonio Rolli ) .
+Gluck verwertete Elemente des Alexanderstoffs sowohl in seiner Oper Poro ( Alessandro nell ’ India ) ( Uraufführung : Turin 1744 , Libretto von Metastasio ) als auch in dem Ballett Alessandro .
+Zu Beginn des 17. 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 1584 ) , die auch unter dem Titel Alexander and Campaspe bekannt ist und von einem Aufenthalt Alexanders in Athen handelt .
+John Dryden dichtete 1692 die Ode Alexander ’ s Feast , welche die Basis für das Libretto des 1736 vollendeten und uraufgeführten gleichnamigen Oratoriums von Georg Friedrich Händel ( HWV 75 ) bildete .
+In Griechenland wurde von 1529 bis ins frühe 20. Jahrhundert die Alexanderlegende in gedruckten Volksbüchern verbreitet , zunächst vorwiegend in Versform ( Rimada , 14 Drucke von 1529 bis 1805 ) , ab dem 18. Jahrhundert meist in Prosa ( Phyllada ) .
+Von insgesamt 43 Drucken der Phyllada aus dem Zeitraum von ca. 1680 bis 1926 erschienen 20 in der zweiten Hälfte des 19. Jahrhunderts .
+Rezeption in Nordmazedonien Datei : Alexander-Statue-Skopje.jpg
+Seit der Unabhängigkeitserklärung der früheren jugoslawischen Teilrepublik Mazedonien , der heutigen Republik Nordmazedonien , im Jahr 1991 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 2006 wurde der Flughafen der mazedonischen Hauptstadt Skopje nach Alexander benannt ( Aerodrom Skopje „ Aleksandar Veliki “ ) ; dort wurde eine große Alexander-Büste aufgestellt .
+2009 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 2011 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 2018 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 20. Jahrhunderts gehören Alexander in Babylon von Jakob Wassermann ( 1905 ) , 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
+von Klaus Mann ( 1929 ) , der Alexander als gescheiterten Utopisten darstellt , und Iskander von Paul Gurk ( 1944 ) .
+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 ( 2005 ) 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 1986 im Album Somewhere in Time erstmals veröffentlicht wurde .
+Beurteilung in der modernen Forschung Den Ausgangspunkt der modernen wissenschaftlichen Auseinandersetzung mit Alexander bildete die 1833 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 20. Jahrhundert William W. Tarn , dessen 1948 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
+Alexander ( Film )
+Quellen Waldemar Heckel , John C. Yardley : Alexander the Great .
+Historical Sources in Translation .
+Blackwell , Oxford 2004 , ISBN 0-631-22821-7 ( 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 327–325 v. Chr. Antike Zeugnisse , eingeleitet , übersetzt und erläutert ( = Fremde Kulturen in alten Berichten , Bd. 8) .
+Thorbecke , Stuttgart 2002 , ISBN 3-7995-0607-1 . Literatur Zum historischen Alexander Pedro Barceló : Alexander der Große . Wissenschaftliche Buchgesellschaft , Darmstadt 2007 , ISBN 3-89678-610-5 . Helmut Berve : Das Alexanderreich auf prosopographischer Grundlage . 2 Bände , Beck , München 1926 ( 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
+.
+Oxford / New York 1996 ( 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 1988 , 1993 , ISBN 0-521-40679-X . Albert Brian Bosworth : Alexander the Great .
+In : The Cambridge Ancient History .
+2. Auflage , Bd. 6 : The Fourth Century B. C. Cambridge University Press , Cambridge 1994 , ISBN 0-521-23348-8 , S. 791–875 . Pierre Briant : Darius in the Shadow of Alexander . Harvard University Press , Cambridge ( Massachusetts ) / London 2015 . Pierre Briant : Alexander the Great and His Empire : A Short Introduction . Princeton University Press , Princeton 2010 . Paul Cartledge : Alexander the Great .
+The Hunt for a New Past.
+Overlook Press , Woodstock ( New York ) / London 2004 , ISBN 1-58567-565-2 ( gut lesbare Darstellung , wenngleich eher thematisch als chronologisch gegliedert ) .
+Alexander Demandt : Alexander der Große : Leben und Legende .
+Beck , München 2009 , ISBN 978-3-406-59085-6 ( Rezension bei sehepunkte ) .
+Johann Gustav Droysen : Geschichte Alexanders des Großen . Herausgegeben von Armin Hohlweg u. a. , ars una , Neuried 2004 , ISBN 3-89391-800-0 ( Nachdruck der Ausgabe Gotha 1877 , 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
+.
+Wissenschaftliche Buchgesellschaft , Darmstadt 2006 , ISBN 3-534-15590-4 ( sehr gute Einführung ) .
+Robin Lane Fox : Alexander der Große .
+Eroberer der Welt .
+4. Auflage , Klett-Cotta , Stuttgart 2005 , ISBN 3-608-94078-2 ( 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 , Berkeley / Los Angeles / London 1992 , ISBN 0-520-07166-2 ( Nachdruck von Penguin , Harmondsworth 1974 ; neben Bosworth , Lauffer und Lane Fox eine der besten modernen Alexander-Biografien ) .
+Hans-Joachim Gehrke : Alexander der Grosse . 6. , aktualisierte Auflage .
+Beck , München 2013 , ISBN 978-3-406-41043-7 . Nicholas G. L. Hammond : Alexander der Große .
+Feldherr und Staatsmann .
+Ullstein , Berlin 2004 , ISBN 3-549-07140-X . Svend Hansen , Alfried Wieczorek , Michael Tellenbach ( Hrsg. ) : Alexander der Große und die Öffnung der Welt .
+Asiens Kulturen im Wandel .
+Schnell & Steiner , Regensburg 2009 , ISBN 978-3-7954-2177-9 ( Begleitband zur gleichnamigen Ausstellung in den Reiss-Engelhorn-Museen in Mannheim mit ca. 600 Farbabbildungen und Essays von Wissenschaftlern verschiedener Fachrichtungen ) .
+Waldemar Heckel : The Marshals of Alexander ’ s Empire . Routledge , London 1992 , ISBN 0-415-05053-7 ( nützliches prosopografisches Handbuch ) .
+Waldemar Heckel : Who ’ s Who in the Age of Alexander the Great .
+Prosopography of Alexander ’ s Empire .
+Blackwell , Oxford u. a. 2006 , ISBN 1-4051-1210-7 . Waldemar Heckel , Lawrence A. Tritle ( Hrsg. ) : Alexander the Great .
+A new History .
+Blackwell , Oxford u. a. 2009 ( 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 . 4. Auflage , dtv , München 2004 , ISBN 3-423-34066-5 ( deutsche Kurzdarstellung , sehr quellennah ) .
+Sabine Müller : Alexander der Große .
+Eroberung - Politik - Rezeption .
+Kohlhammer , Stuttgart 2019 , ISBN 978-3-17-031346-0 . Joseph Roisman ( Hrsg. ) : Brill ’ s companion to Alexander the Great . Brill , Leiden 2003 , ISBN 90-04-12463-2 ( 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 1973 ( umfassende Darstellung , die teilweise mit den vorherigen , zumeist positiven Alexanderbildern brach ) .
+Jakob Seibert : Alexander der Große ( = Erträge der Forschung . Bd. 10 ) .
+Wissenschaftliche Buchgesellschaft , Darmstadt 1972 , ISBN 3-534-04492-4 . William W. Tarn : Alexander the Great . 2 Bände , Cambridge University Press , Cambridge 1948 ( deutsch 1968 , Nachdruck in einem Band 1981 ; teilweise sehr romantisierende Darstellung , wobei Alexander ausgesprochen positiv beurteilt wird ; Bd. 2 bietet einen Überblick über die Quellen sowie Einzeluntersuchungen ) .
+Hans-Ulrich Wiemer : Alexander der Große . Beck , München 2005 , ISBN 3-406-52887-2 ( solide Einführung ) .
+Wolfgang Will : Alexander der Große ( = Urban Taschenbücher . Bd. 370 ) .
+Kohlhammer , Stuttgart 1986 , ISBN 3-17-008939-0 . Wolfgang Will ( Hrsg. ) : Zu Alexander dem Großen .
+Festschrift Gerhard Wirth zum 60. Geburtstag .
+2 Bände , Hakkert , Amsterdam 1987–1988 . Gerhard Wirth : Alexander der Große mit Selbstzeugnissen und Bilddokumenten .
+Rowohlt , Reinbek 1973 , ISBN 3-499-50203-8 . Ian Worthington : By the Spear .
+Philip II , Alexander the Great , and the Rise and Fall of the Macedonian Empire .
+Oxford University Press , Oxford 2014 . Ian Worthington ( Hrsg. ) : Alexander the Great .
+A Reader .
+Routledge , London 2003 , ISBN 0-415-29186-0 ( 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 1990 , ISBN 2-87031-149-4 . Karsten Dahmen : The Legend of Alexander the Great on Greek and Roman Coins . Routledge , London 2007 , ISBN 0-415-39451-1 . Siegmar Döpp : Alexander in spätlateinischer Literatur . In : Göttinger Forum für Altertumswissenschaft 2 , 1999 , S. 193–216 ( 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
+.
+In : Henning Börm ( Hrsg. ) : Antimonarchic Discourse in Antiquity .
+Steiner , Stuttgart 2015 , S. 85–112 . 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 1978 . George Cary : The Medieval Alexander . Cambridge University Press , Cambridge 1956 . Heribert J. Gleixner : Das Alexanderbild der Byzantiner . Salzer , München 1961 . 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 1999 . Tilman Nagel : Alexander der Große in der frühislamischen Volksliteratur ( = Beiträge zur Sprach- und Kulturgeschichte des Orients , Band 28 ) .
+Verlag für Orientkunde , Walldorf 1978 , ISBN 978-3-936687-28-6 . Richard Stoneman : Alexander the Great .
+A Life in Legend .
+Yale University Press , New Haven 2008 , ISBN 978-0-300-11203-0 . Zachary David Zuwiyya ( Hrsg. ) : A Companion to Alexander Literature in the Middle Ages . Brill , Leiden / Boston 2011 . 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 52 , 2006 , S. 183–207 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
+( = Miscellanea Byzantina Monacensia , Band 8) .
+Universität Institut für Byzantinistik und Neugriechisch , Philologie , München 2. Juli 1968 , ( Dissertation Universität München 1968 , 306 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
+) ; [ gekürzte ] Buchhandelsausgabe ( 95 Seiten ) : ( = Tusculum-Schriften ) .
+Heimeran , München 1969 , .
+Weblinks Teils sehr kritische Betrachtung von Prof. Worthington , zuerst erschienen im Ancient History Bulletin 13.2 ( 1999 ) 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 2009 der Reiss-Engelhorn-Museen in Mannheim Anmerkungen Plutarch , Alexander 2,1 ( englische Übersetzung ) Plutarch , Alexander 2,3 ( englische Übersetzung ) Plutarch , Alexander 6. Herodot , Historien 5,22 . Siehe die Quellenzeugnisse bei Heckel , Yardley : Alexander . S. 7 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 , 360–146 BC , in honor of E. Badian . Norman 1996 , S. 122–139 ( siehe auch hier ) . Anderer Meinung ist Nicholas G. L. Hammond : Literary evidence for Macedonian speech . In : Historia 43/2 , 1994 , S. 131–142 . Im Folgenden wird mit „ Makedone ( n ) “ nur die Herkunft aus dem antiken Makedonien ausgedrückt . Peter Green : Alexander of Macedon . Berkeley 1992 , S. 6 f. Anonyme Chronik in : Bernard P. Grenfell , Arthur S. Hunt ( Hrsg. ) : The Oxyrhynchus Papyri . Part I , London 1898 , S. 25–36 , hier : S. 27 Spalten III.13-IV.1 ( http://ia600303.us.archive.org/13/items/oxyrhynchuspapyr01grenuoft/oxyrhynchuspapyr01grenuoft_bw.pdf ) . Die antiken Quellen , darunter Plutarch , Alexander 10,5-7 und Justin , Historiarum Philippicarum libri XLIV 9,6-7 ; 11,2,1-23 sowie Diodor , Bibliothéke historiké 16 , 94 – 17 , 2 widersprechen sich . Die neuere Forschung wird bei Hans-Joachim Gehrke : Geschichte des Hellenismus . München 2003 , S. 144 diskutiert . Anonyme Chronik in : Bernard P. Grenfell , Arthur S. Hunt ( Hrsg. ) : The Oxyrhynchus Papyri . Part I , London 1898 , S. 25–36 , hier : S. 27 Spalten III.13-IV.1 ( http://ia600303.us.archive.org/13/items/oxyrhynchuspapyr01grenuoft/oxyrhynchuspapyr01grenuoft_bw.pdf ) Anonyme Chronik in : Bernard P. Grenfell , Arthur S. Hunt ( Hrsg. ) : The Oxyrhynchus Papyri . Part I , London 1898 , S. 25–36 , hier : S. 27 Spalten IV.1-7 ( http://ia600303.us.archive.org/13/items/oxyrhynchuspapyr01grenuoft/oxyrhynchuspapyr01grenuoft_bw.pdf ) . 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 , 19. –21. Dezember 1996 , Bonn 1998 , S. 3 ff. Karl Julius Beloch : Griechische Geschichte , 2. Auflage , Bd. 3.2 , S. 361 ; vgl. Siegfried Lauffer : Alexander der Große , 4. Auflage , München 2004 , S. 77. Curtius , Historiae Alexandri Magni Macedonis 3,12,27 –13 , 16. Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( Nachdruck ) , S. 185. Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( Nachdruck ) , S. 186. Robin Lane Fox : Alexander der Große , Stuttgart 1974 , S. 229. Johann Gustav Droysen : Geschichte Alexanders des Großen , hrsg. von Armin Hohlweg u. a. , Neuried 2004 ( Nachdruck der Ausgabe Gotha 1877 ) , S. 272f . ( und Anm. 274 der Herausgeber ) . Robin Lane Fox : Alexander der Große , Stuttgart 1974 , S. 240. Arrian , Anabasis 2,25 . Alexander Demandt : Alexander der Große . Leben und Legende . München 2009 , S. 155. Demandt führt dazu an : Diodor , Bibliothéke historiké 17 , 40 , 41 ; 17 , 46 , 4 ; Curtius Rufus , Historiae Alexandri Magni Macedonis 4 , 15 ; Justin , Historiarum Philippicarum libri XLIV 11 , 10 , 14. Nicholas Hammond : Alexander der Große . Berlin 2004 , S. 146. Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( Nachdruck ) , S. 199 und Robin Lane Fox : Alexander der Große . Stuttgart 1974 , S. 250. William Linn Westermann : The Slave Systems of Greek and Roman Antiquity , Philadelphia 1955 , S. 28. Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( Nachdruck ) , S. 199. Zeitangabe nach Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( 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 1998 , S. 293–296 . Frank Rainer Scheck : Die Weihrauchstraße . Bergisch Gladbach 1998 , S. 281. Nicolas Hammond : Alexander der Große . Berlin 2004 , S. 148 : „ 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 2009 , S. 12 ) . In der Zeit des Römers Curtius „ … ( konnte ) die zeitgenössische Kritik an den römischen Kaisern im 1. Jhdt. n. Chr. nur heimlich geäußert werden … und ( sich ) an Alexander [ … ] – stellvertretend – offen zeigen “ ( Wolfgang Will : Alexander der Große , Darmstadt 2009 , S. 13 ) . Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( Nachdruck ) , S. 202. Frank Rainer Scheck : Die Weihrauchstraße . Bergisch Gladbach 1998 , S. 279. Robin Lane Fox : Alexander der Große . Stuttgart 1974 , S. 198 f. Johann Gustav Droysen : Geschichte Alexanders des Großen . München 1954 ( Nachdruck ) , S. 211 f. Günther Hölbl : Geschichte des Ptolemäerreiches , Darmstadt 1994 , S. 9. Robin Lane Fox : Alexander der Große , S. 258. Gerhard Wirth , 1973 , gibt hierzu die Quelle an : Pseudo-Kallisthenes 1 , 34 , 2 ( S. 24 ) . Text und Bild : Robin Lane Fox : Alexander der Große , Rowohlt Taschenbuch Verlag , Reinbek bei Hamburg , 2010 ( Original 1973 ) , S. 248. ISBN 978-3-499-62641-8 . Siehe auch die anonyme Chronik in : Bernard P. Grenfell , Arthur S. Hunt ( Hrsg. ) : The Oxyrhynchus Papyri . Part I , London 1898 , S. 25–36 , hier : S. 28 Spalten IV.24 –36 ( Volltext als PDF-Datei ) . Anonyme Chronik in : Bernard P. Grenfell , Arthur S. Hunt ( Hrsg. ) : The Oxyrhynchus Papyri . Part I , London 1898 , S. 25–36 , hier : S. 28 Spalten V.1-4 ( 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 2005 . Einen knappen Überblick bietet etwa Albert Brian Bosworth : The Indian campaigns . 327–325 B. C. In : J. Roisman ( Hrsg. ) : Brill's Companion to Alexander the Great , S. 159–168 . 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 , 360–146 B. C. , Oklahoma 1996 , S. 140–166 ; Johannes Hahn ( Hrsg. ) : Alexander in Indien , 327–325 v. Chr. , Stuttgart 2000 . Zur Lokalisierung vgl. Siegfried Lauffer : Alexander der Große , 4. Auflage , München 2004 , S. 155 Anm. 19. Vgl. Ernst Badian : Alexander the Great and the Unity of Mankind . In : Historia . Nr. 7 , 1958 , S. 425–444 . Allgemeiner Überblick bei Daniel Ogden : Alexander ’ s Sex Life . In : Waldemar Heckel , Lawrence A. Tritle ( Hrsg. ) : Alexander the Great . A New History , Chichester 2009 , S. 203 ff. Fritz Moritz Heichelheim : Wirtschaftsgeschichte des Altertums , Band 2 , Leiden 1969 , S. 421. Diodor , Bibliothéke historiké 18,4,1 –6. Vgl. Albert Brian Bosworth : Alexander's last Plans . In : Albert B. Bosworth ( Hrsg. ) : From Arrian to Alexander : Studies in Historical Interpretation . Oxford 1988 , S. 185 ff. Laut Plutarch , Alexander 76,9 starb er am 28. Daisios , entsprechend dem 10. Juni 323 v. Chr. Diodor , Bibliothéke historiké 17 , 117 , 4. Diskussion dazu bei Michael Rathmann : Perdikkas zwischen 323 und 320 : Nachlassverwalter des Alexanderreiches oder Autokrat ? Wien 2005 , S. 9–26 ( 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 1996 , S. 87–90 . Zum politischen Hintergrund siehe Claudia Bohm : Imitatio Alexandri im Hellenismus , München 1989 , S. 142–144 . Harry E. Tzalas : ” The Tomb of Alexander the Great ” – The history and the legend in the Greco-Roman and Arab times . In : Graeco-Arabica 5 , 1993 , S. 329–354 , hier : 337. Tzalas stellt S. 333–336 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 5 , 1993 , S. 329–354 , hier : 332 f. , 339–348 . Zu den Einzelheiten siehe die gründliche Untersuchung von Peter Marshall Fraser : Cities of Alexander the Great , Oxford 1996 ( Städteliste S. 240–243 , Karten S. 236–238 ) . Vgl. Lionel Pearson : The lost histories of Alexander the Great . New York 1960 ( Onlineversion ) . Zu den Anfängen der Alexanderlegenden bei den Zeitgenossen des Königs siehe Erwin Mederer : Die Alexanderlegenden bei den ältesten Alexanderhistorikern , Stuttgart 1936 . Ben Edwin Perry : The Ancient Romances , Berkeley 1967 , S. 35 ; Hartmut Bohmhammel : Valerius ’ Übertragung der Alexandergeschichte und ihre gesellschaftlichen Tendenzen , Dissertation TU Berlin 2008 , S. 6. Zur Nektanebos-Legende siehe Richard Stoneman : Alexander the Great . A Life in Legend , New Haven 2008 , S. 6 ff. Hartmut Bohmhammel : Valerius ’ Übertragung der Alexandergeschichte und ihre gesellschaftlichen Tendenzen , Dissertation TU Berlin 2008 , S. 120–135 . 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 2005 . 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 1976 , S. 145–158 , 162–172 , Alfred Heuß : Alexander der Große und die politische Ideologie des Altertums . In : Antike und Abendland 4 , 1954 , S. 66 f. , Alexander Meeus : Alexander's Image in the Age of the Successors . In : Waldemar Heckel , Lawrence A. Tritle ( Hrsg. ) : Alexander the Great . A New History , Chichester 2009 , S. 235–250 und die Untersuchung von Claudia Bohm : Imitatio Alexandri im Hellenismus , München 1989 . Claudia Bohm : Imitatio Alexandri im Hellenismus , München 1989 , S. 145 , 153 ff. , 181. Gerhard Wirth : Alexander und Rom . In : Alexandre le Grand . Image et réalité , Genf 1976 , S. 186–210 ; Otto Weippert : Alexander-Imitatio und römische Politik in republikanischer Zeit , Augsburg 1972 , S. 56 ff. ; Diana Spencer : Roman Alexanders : Epistemology and Identity . In : Waldemar Heckel , Lawrence A. Tritle ( Hrsg. ) : Alexander the Great . A New History , Chichester 2009 , S. 251–274 , hier : 262–267 . Siehe dazu Corinne Jouanno : Un épisode embarrassant de l ’ histoire d ’ Alexandre : la prise de Thèbes . In : Ktèma 18 , 1993 , S. 245–258 . Max Brocker : Aristoteles als Alexanders Lehrer in der Legende , Bonn 1966 , S. 20 ; Erwin Mederer : Die Alexanderlegenden bei den ältesten Alexanderhistorikern , Stuttgart 1936 , S. 149–151 . Zu Senecas Alexander-Rezeption siehe Alfred Heuß : Alexander der Große und die politische Ideologie des Altertums . In : Antike und Abendland 4 , 1954 , S. 88f . ; zur philosophischen Alexanderkritik allgemein Johannes Stroux : Die stoische Beurteilung Alexanders des Großen . In : Philologus 88 , 1933 , S. 222–240 und William W. Tarn : Alexander , Cynics and Stoics . In : American Journal of Philology 60 , 1939 , S. 41–70 , hier : 54–56 . Lucan , Bellum civile 10,20 –45. Gerhard Wirth : Der Weg in die Vergessenheit , Wien 1993 , S. 48–50 . Alfred Heuß : Alexander der Große und die politische Ideologie des Altertums . In : Antike und Abendland 4 , 1954 , S. 94 f. Ernst Bammel : Der Zeuge des Judentums . In : Wolfgang Will ( Hrsg. ) : Zu Alexander dem Großen , Bd. 1 , Amsterdam 1987 , S. 283 ; vgl. Gerhard Wirth : Der Weg in die Vergessenheit , Wien 1993 , S. 20–23 . Johannes Chrysostomos , Ad illuminandos catechesis 2,5 . Zum Alexanderbild des Orosius siehe Siegmar Döpp : Alexander in spätlateinischer Literatur . In : Göttinger Forum für Altertumswissenschaft 2 , 1999 , S. 193–216 , hier : 209–212 online ( PDF ; 157 kB ) . Aktueller Überblick bei Zachary David Zuwiyya ( Hrsg. ) : A Companion to Alexander Literature in the Middle Ages , Leiden / Boston 2011 . Herwig Buntz : Die deutsche Alexanderdichtung des Mittelalters , Stuttgart 1973 , S. 1. Das grundlegende Standardwerk für die mittelalterliche Alexander-Rezeption ist George Cary : The Medieval Alexander , Cambridge 1956 . Zu den orientalischen Versionen siehe Rudolf Macuch : Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain . In : Graeco-Arabica 4 , 1991 , S. 223–264 ; David J. A. Ross : Alexander Historiatus . A Guide to medieval illustrated Alexander Literature , Frankfurt am Main 1988 , S. 6–9 . Dan 2 , 31–45 sowie Dan 7 und 8. 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 2002 , S. 40 ff. Victor M. Schmidt : A Legend and its Image . The Aerial Flight of Alexander the Great in Medieval Art , Groningen 1995 ( Untersuchung mit zahlreichen Abbildungen ) . Siehe auch Richard Stoneman : Alexander the Great . A Life in Legend , New Haven 2008 , S. 111–119 . Gottfried von Admont , Homilia XVI . In : Jacques Paul Migne , Patrologia Latina , Bd. 174 Sp. 1131 f. ; Hugo von St. Viktor , Allegoriae in Vetus Testamentum 9,4 . In : Migne , Patrologia Latina , Bd. 175 Sp. 749 f. Trude Ehlert : Deutschsprachige Alexanderdichtung des Mittelalters , Frankfurt am Main 1989 , S. 20 f. Siehe auch Ulrich Mölk : Alberics Alexanderlied . In : Jan Cölln u. a. ( Hrsg. ) : Alexanderdichtungen im Mittelalter , Göttingen 2000 , S. 21–36 . Eine Übersicht über die französische Dichtung bietet David J. A. Ross : Alexander Historiatus . A Guide to medieval illustrated Alexander Literature , Frankfurt am Main 1988 , S. 9–17 ; vertiefte Darstellungen bieten Martin Gosman : La légende d ’ Alexandre le Grand dans la littérature française du 12e siècle , Amsterdam 1997 , und Catherine Gaullier-Bougassas : Les romans d ’ Alexandre . Aux frontières de l ’ épique et du romanesque , Paris 1998 . Die Geschichte der Alexanderrezeption im italienischen Mittelalter beschreibt Joachim Storost : Studien zur Alexandersage in der älteren italienischen Literatur , Halle ( Saale ) 1935 . Trude Ehlert : Deutschsprachige Alexanderdichtung des Mittelalters , Frankfurt am Main 1989 , S. 43–46 , 59 ; Christoph Mackert : Die Alexandergeschichte in der Version des ‚ pfaffen ’ Lambrecht , München 1999 , S. 36 f. , 262–267 , 277–297 , 336 ff. Trude Ehlert : Deutschsprachige Alexanderdichtung des Mittelalters , Frankfurt am Main 1989 , S. 59–62 . Zu diesem Werk siehe Gerrit Bunt : Alexander the Great in the literature of Medieval Britain , Groningen 1994 , S. 19–26 . Heribert J. Gleixner : Das Alexanderbild der Byzantiner , München 1961 , S. 67–85 , 97–100 . 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 1978 , S. 25–27 ( und S. 21 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 4 , 1991 , S. 223–264 , hier : 241–257 ; 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 2002 , S. 11–15 ; Max Brocker : Aristoteles als Alexanders Lehrer in der Legende , Bonn 1966 , S. 83–86 ; zuletzt Kevin van Bladel : The Alexander Legend in the Qur'an 18 : 83–102 , in : Gabriel S. Reynolds ( Hrsg. ) : The Qur'an in Its Historical Context , London 2008 , S. 175–203 . Rudolf Macuch : Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain . In : Graeco-Arabica 4 , 1991 , S. 223–264 , hier : 237. Dominique Svenson : Darstellungen hellenistischer Könige mit Götterattributen , Frankfurt am Main 1995 , S. 14–17 . Zum antiken Ursprung dieses Sagenmotivs siehe Alexander Demandt : Alexander im Islam . In : Monika Schuol u. a. ( Hrsg. ) : Grenzüberschreitungen , Stuttgart 2002 , S. 11–15 , hier : 13 f. Rudolf Macuch : Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain . In : Graeco-Arabica 4 , 1991 , S. 223–264 , hier : 241. Die Stelle ist Pseudo-Kallisthenes , Vita Alexandri Magni 2,39,12 . Skeptisch äußerte sich allerdings Brannon M. Wheeler : Moses or Alexander ? Early Islamic Exegesis of Qur’an 18:60 –65. In : Journal of Near Eastern Studies 57 , 1998 , S. 192 ff. Zum arabischen Alexanderroman siehe Toufic Fahd : La version arabe du Roman d ’ Alexandre . In : Graeco-Arabica 4 , 1991 , S. 25–31 . Max Brocker : Aristoteles als Alexanders Lehrer in der Legende , Bonn 1966 , S. 79. Michel M. Mazzaoui : Alexander the Great and the Arab Historians . In : Graeco-Arabica 4 , 1991 , S. 33–43 . Zu den spanischen Versionen der muslimischen Alexanderlegende siehe Manuela Marín : Legends of Alexander the Great in Moslem Spain . In : Graeco-Arabica 4 , 1991 , S. 71–89 . Richard Stoneman : Alexander the Great in the Arabic Tradition . In : Stelios Panayotakis ( Hrsg. ) : The Ancient Novel and Beyond , Leiden 2003 , S. 15–18 . Max Brocker : Aristoteles als Alexanders Lehrer in der Legende , Bonn 1966 , S. 62–65 , 96 ; Richard Stoneman : Alexander the Great . A Life in Legend , New Haven 2008 , S. 41–44 . Noch im 17. Jahrhundert war diese Sichtweise bei den Parsen in Indien verbreitet ; siehe Friedrich Pfister : Kleine Schriften zum Alexanderroman , Meisenheim 1976 , S. 303. Rudolf Macuch : Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain . In : Graeco-Arabica 4 , 1991 , S. 223–264 , hier : 258 f. Von einem Vordringen Alexanders nach China hatte schon der 1048 gestorbene persische Gelehrte al-Bīrūnī geschrieben , siehe Alexander Demandt : Alexander im Islam . In : Monika Schuol u. a. ( Hrsg. ) : Grenzüberschreitungen , Stuttgart 2002 , S. 11–15 , hier : 14. Rudolf Macuch : Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain . In : Graeco-Arabica 4 , 1991 , S. 223–264 , hier : 259. 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 1996 , S. 91–107 . David J. A. Ross : Alexander Historiatus . A Guide to medieval illustrated Alexander Literature , Frankfurt am Main 1988 , S. 33–36 , 45 , 59 , 64 f. Zur jüdischen Alexanderlegende siehe auch Max Brocker : Aristoteles als Alexanders Lehrer in der Legende , Bonn 1966 , S. 71–78 ; Friedrich Pfister : Kleine Schriften zum Alexanderroman , Meisenheim 1976 , S. 319–327 . David J. A. Ross : Alexander Historiatus . A Guide to medieval illustrated Alexander Literature , Frankfurt am Main 1988 , S. 34–36 . Arthur Hübner : Alexander der Große in der deutschen Dichtung des Mittelalters . In : Die Antike 9 , 1933 , S. 32. 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 1996 , S. 20 f. Georg Veloudis : Alexander der Große . Ein alter Neugrieche , München 1969 , S. 16 f. Eine ausführlichere Darstellung bietet die Dissertation von Georg Veloudis : Der neugriechische Alexander , München 1968 . . Über die Positionen mazedonischer Nationalisten informiert Loring M. Danforth : The Macedonian Conflict : Ethnic Nationalism in a Transnational World , Princeton 1995 , S. 42–55 , speziell zu Alexander dem Großen S. 46–49 . Sinisa-Jakov Marusic : ( 5. Mai 2009 ) . Hajrudin Somun : ( 27. Juni 2011 ) . . Über die Positionen griechischer Nationalisten informiert Loring M. Danforth : The Macedonian Conflict : Ethnic Nationalism in a Transnational World , Princeton 1995 , S. 30–42 , speziell zu Alexander dem Großen S. 34 , 36–38 . DerStandard.at , 6. Februar 2018 . Abgerufen am 21. Februar 2018 . Gisbert Haefs : Alexander , Band 1 : Hellas . Der Roman der Einigung Griechenlands ( 1992 ) und Band 2 : Asien . Der Roman der Eroberung eines Weltreichs ( 1993 ) . 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 1998 . Der von Ernst Badian verfasste Alexander-Artikel im Neuen Pauly , einem maßgeblichen Nachschlagewerk ( Bd. 1 , Sp. 468–474 ) , fasst die aus der Sicht dieser Forschungsrichtung wesentlichen Gesichtspunkte zusammen . Waldemar Heckel : The Conquests of Alexander the Great . Cambridge 2007 , S. IXf . Frank Holt : Alexander the Great today . In the Interests of Historical Accuracy ? In : The Ancient History Bulletin 13 , 1999 , S. 111–117 . Vgl. dazu Ian Worthingtons Antwort auf Holt . 
+
+Antike ( von „ alt , altertümlich , altehrwürdig “ ) bezeichnet eine Epoche im Mittelmeerraum , die etwa von 800 v. Chr.
+bis ca. 600 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 1. 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 3500 v. Chr. einsetzt .
+Der größere Zeitraum von etwa 3500 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 476 bzw. bis zum Tod des oströmischen Kaisers Justinian 565.
+Seit den Arbeiten des belgischen Historikers Henri Pirenne wird oft auch das Jahr 632 , 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 8. 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 1900 bis 1100 v. Chr. sowie die so genannten „ Dunklen Jahrhunderte “ 1200 bis 750 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 : 325 : Konzil von Nikaia
+393 : Letzte Olympische Spiele der Antike
+395 : Teilung des römischen Reiches nach dem Tod des Theodosius
+476 : Untergang des weströmischen Reichs unter Romulus Augustulus
+498 : Taufe des Frankenkönigs Chlodwig I.
+529 : Gründung des ersten abendländischen Benediktinerklosters und Schließung der platonischen Akademie nach dem Tod des „ letzten “ antiken Philosophen Boëthius 524 565 : Tod Kaiser Justinians
+568 : Ende der so genannten Völkerwanderung mit dem Langobardeneinfall in Italien 632 : Beginn der islamischen Expansion
+641 : Tod des Kaisers Herakleios
+In der neueren Forschung wird meistens ein später Zeitpunkt favorisiert ( 565 bzw. die Zeit um 600 n. Chr. ) . Generell erscheint es ohnehin sinnvoll , von einem Übergangszeitraum ab ca. 500 bis 7. 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 19. 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. 2000 bis ca. 1600 v. Chr. im Mittelhelladikum anzusiedeln .
+Zu Beginn dieses Zeitabschnitts – teils auch schon im letzten Abschnitt des Frühhelladikums FH III ca. 2200–2000 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. 1900 bis 1450 v. Chr. hatte , entwickelte sich auf dem Festland aus der Kultur des Mittelhelladikums die mykenische Kultur ( ca. 1600 bis 1050/00 v. Chr. ) . Sie hatte ihren Ausgangspunkt vermutlich in der Argolis und erscheint unvermittelt mit reichen Schachtgräbern ab ca. 1600 v. Chr. Unter anderem übernahm die mykenische Kultur von der minoischen die Schrift .
+Die auf Kreta ( unter anderem ) verwendete sog. Linear A-Schrift des 17. bis 15. Jahrhunderts v. Chr. wurde zur sog. Linear B-Schrift ( 15. bis 12. 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 .
+Datei : Löwentor Mykene.jpg 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 13. 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. 1400 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 1200 bis 750 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 150 Jahre weiter , erlebte in einigen Regionen ab Mitte des 12. Jahrhunderts sogar eine gewisse Nachblüte , bevor der Übergang in die sogenannte Protogeometrische Periode ( ca. 1050/00 –900 v. Chr. ) erfolgte .
+Ungefähr zur gleichen Zeit , als sich um 1200 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 12. Jahrhundert v. Chr. weiterhin betrieben , teilweise auch noch im 11. Jahrhundert v. Chr. Der Überlieferung nach setzte ca. 1050 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 12. / 11.
+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 8. 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 9. 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 8. Jahrhundert v. Chr. die eigentliche Antike .
+Seit dem Jahr 776 v. Chr. ist die Siegerliste der Olympischen Spiele überliefert .
+Von etwa 770 bis 540 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 750 und 650 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 3. Jahrhundert v. Chr. , die ältesten Codices mit längeren Textpassagen tauchen im Mittelalter ( ca. 10. 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 700 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 720 und 600 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 650 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 ( 621 v. Chr. ) und Solons ( 594/593 v. Chr. ) gelang es Peisistratos und seinen Söhnen etwa zwischen 561 und 510 v. Chr. zwar noch einmal , eine Tyrannis zu errichten .
+Bis 501 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 500 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 490 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 479 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 .
+Datei : Athens Acropolis.jpg Nach der erfolgreichen Verteidigung und mit der Gründung des Attischen Seebunds 477 v. Chr. unter der auf die eigene Seemacht gestützte Vorherrschaft Athens setzte eine etwa 50-jährige Blütezeit der Stadt ( die Pentekontaetie ) ein , die bis zum Ausbruch des Peloponnesischen Krieges 431 v. Chr. ( bzw. bis zum Tod des leitenden Staatsmannes Perikles im Jahr 429 v. Chr. ) reichte .
+Die Akropolis mit dem Parthenon ­ tempel 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 philosophie ­ geschichtlicher 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 431 v. Chr. in den fast 30 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 , 404 v. Chr. mit der vollständigen Niederlage Athens und mit der Errichtung einer zeitweiligen spartanischen Hegemonie über Griechenland .
+In der ersten Hälfte des 4. 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 386 v. Chr. ) . 371 v. Chr. löst Theben unter Epaminondas nach der Schlacht bei Leuktra Sparta als Hegemon ab .
+Doch auch Thebens Vorherrschaft bestand nur bis rund 362 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 338 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 5. 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 ( 336 bis 30 v. Chr. ) Datei : AlexanderTheGreat Bust.jpg Nach der Ermordung Philipps 336 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 323 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 100.000 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 2. Jahrhunderts v. Chr. tauchte erstmals Rom als bedeutende Macht in Griechenland auf und dehnte nach und nach seinen Einfluss aus .
+146 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 64/63 v. Chr. die Beseitigung der Überreste des Seleukidenreiches .
+Als letzter Nachfolgestaat des Alexanderreichs wurde im Jahre 30 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 753 v. Chr. gegründet , entstand neueren Forschungen zufolge erst gegen Ende des 7. 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. 500 bis 27 v. Chr. ) Datei :C t-fororomano1.jpg Um 500 v. Chr. befreiten sich die Römer vom etruskischen Stadtkönigtum und bildeten wohl um 475 v. Chr. eine republikanische Regierungsform aus .
+In den Zwölftafelgesetzen , die um 450 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 S. P. Q. R. 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 Veto ­ recht gegen Senatsbeschlüsse besaß .
+Datei : Gaius Julius Caesar ( 100-44 BC ) . JPG Mit der Legion entwickelten die Römer eine effektive Streitmacht .
+Bis zum Jahr 272 v. Chr. unterwarfen sie ganz Italien südlich der Poebene .
+Mit den Punischen Kriegen gegen die Seemacht Karthago im 3. und 2. Jahrhundert v. Chr. begann der Aufstieg Roms zur antiken Weltmacht , die für die folgenden Jahrhunderte die gesamte Mittelmeer ­ welt beherrschen sollte .
+Nach 200 v. Chr. nahm Rom zunehmend Einfluss auf die Politik der hellenistischen Großmächte und wurde zur Protektoratsmacht im östlichen Mittelmeerraum .
+148 v. Chr. wurde das Makedonien der Antigoniden , 63 v. Chr. das Reich der Seleukiden , und schließlich 30 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 ( 27 v. Chr. bis 284 n. Chr. ) Datei : Statue-Augustus.jpg Das von Augustus errichtete Kaisertum ( Prinzipat ) wurde von ihm und seinem Nachfolger Tiberius für rund 60 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 68/69 ( 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 96 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 2. 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 2. 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 180 n. Chr. ein als Blütezeit betrachtetes Zeitalter des Imperiums .
+Nach dem schwachen Commodus , der 192 ermordet wurde , stabilisierten die Kaiser aus dem Hause der Severer , hervorzuheben ist besonders Septimius Severus , die Grenzen wenigstens teilweise .
+Kaiser Caracalla gewährte 212 mit der Constitutio Antoniniana allen freien Reichsbürgern das Bürgerrecht .
+Nach der Ermordung des Severus Alexander 235 kam es jedoch unter den so genannten Soldatenkaisern zur Reichskrise des 3. Jahrhunderts , die aber erst um 260 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 224 ( bzw. 226 ) , 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 ( 284 bis 565/632 n. Chr. ) Mit der Einführung der Tetrarchie ( 293 ) und zahlreichen inneren Reformen gelang es Kaiser Diokletian ( seit 284 Kaiser ) gegen Ende des 3. 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 363 ; 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 300 und 600 eine massive Transformation durchlief , bspw. mit dem Ersten Konzil von Nicäa .
+Die Platonische Akademie in Athen , oft als „ Hort des Heidentums “ bezeichnet , wurde 529 geschlossen , während die bereits christianisierte Schule von Alexandria noch bis zum Beginn des 7. Jahrhunderts bestehen blieb .
+Kaiser Valentinian I. festigte den Westen des Reiches , doch kam es 378 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 392 zur Staatsreligion und verbot alle heidnischen Kulte wie die Olympischen Spiele .
+Allerdings lassen sich noch bis mindestens in das 6. Jahrhundert hinein bedeutende heidnische Minderheiten auf dem Boden des Imperiums nachweisen .
+Datei : Justinian mosaik ravenna.jpg Nach der faktisch endgültigen Teilung des Reiches unter den beiden Söhnen des Theodosius 395 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 7. 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 5. Jahrhundert direkt Besitz von weströmischen Provinzen .
+Ihre Anführer traten hier oft an die Stelle der römischen Autoritäten .
+Rom selbst wurde 410 von den Westgoten und 455 von den Vandalen geplündert , von der Millionenstadt der hohen Kaiserzeit schrumpfte sie auf schätzungsweise 200.000 Einwohner zum Ende des 5. 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 7. Jahrhundert eine Krisenzeit , siehe unten ) lösten sich im 5. 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 .
+476 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 6. Jahrhundert noch zur Antike gezählt , da vor allem im Osten römisch-antike Strukturen fortbestanden und dem oströmischen Kaiser Justinian ( 527–565 ) 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 540 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 7. 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 8. 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 15. 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 18. Jahrhundert die „ klassische “ griechische Kunst – oder vielmehr das , was man idealisierend für diese hielt – zunehmend ins Zentrum des Interesses .
+Im 19. 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 20. 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 10 % der griechischen Literatur überliefert ist . Andere Forscher sind noch weit pessimistischer und gehen eher von einer Verlustrate um 99 % 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
+Rom : Römische Religion
 Lateinische Literatur
 Untergang des Römischen Reiches
-Listen
-Liste antiker Stätten
+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>
+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 1923 ff. ( Nachdr. Brill , Leiden 1995ff . , ISBN 90-04-01108-0 ; CD-ROM , ISBN 90-04-14137-5 ) .
+Siehe nun vor allem auch die Neubearbeitung ( mit englischer Übersetzung und neuem Kommentar ) : Brill ’ s New Jacoby
+Die Fragmente römischer Historiker sind gesammelt in Die frühen römischen Historiker und in ( allerdings nur bis zur Mitte des 3. 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 L ’ Année philologique dar ( L ’ Année Philologique .
+Bibliographie critique et analytique de l ’ Antiquité greco-latine , hrsg. von J. Marouzeau und J. Ernst , Paris 1923ff . ) . 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 2 Reihen , Stuttgart 1894–1980 , ISBN 3-476-01193-3 . ( Neudruck ab 1997ff . ; trotz des Alters in seiner Gesamtheit nicht überholtes Grundlagenwerk ) Konrat Ziegler , Walther Sontheimer , Hans Gärtner ( Hrsg. ) : Der Kleine Pauly .
+Lexikon der Antike .
+( KlP ) , 5 Bände .
+Druckenmüller ( Artemis ) , Stuttgart / München 1964–1975 , ISBN 3-423-05963-X . ( Nachdruck dtv , München 2002 ; 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 1996–2003 , ISBN 3-476-01470-3 . ( 26 Bände mit schwankender Qualität der Beiträge ) S. Hornblower , A. Spawforth ( Hrsg. ) : The Oxford Classical Dictionary ( OCD ) .
+4. Auflage .
+Oxford University Press , Oxford 2012 . ( 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 2006 ( aktuelles und gut bebildertes Nachschlagewerk zur klassischen Antike ; Rezension in ) Carl Andresen und andere ( Hrsg. ) : Lexikon der Alten Welt . ( LAW ) , Albatros , Düsseldorf 2001 , ISBN 3-491-96036-3 . ( in viele Bereichen veralteter Forschungsstand ) Oliver Nicholson ( Hrsg. ) : The Oxford Dictionary of Late Antiquity . Oxford University Press , Oxford 2018 , ISBN 978-0-19-866277-8 . ( 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 ) , 2. völlig neu bearbeitete und stark erweiterte Auflage .
+De Gruyter , Berlin / New York 1973–2007 . ( Neubearbeitung des wichtigen Lexikons von Hoops ) Theodor Klauser und andere ( Hrsg. ) : Reallexikon für Antike und Christentum . ( RAC ) , Stuttgart 1950ff , ISBN 3-7772-9427-6 . ( noch nicht abgeschlossen , besonderes Augenmerk gilt der Spätantike ) Kai Brodersen , Bernhard Zimmermann ( Hrsg. ) : Metzler Lexikon Antike . 2. , überarbeitete und erweiterte Auflage .
+J. B. Mezler Verlag , Stuttgart 2006 , ISBN 3-476-02123-8 . 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 1996 . Heinz Mikisch : Basiswissen Antike .
+Ein Lexikon .
+Verlag Philipp Reclam jun. , Stuttgart 2006 , ISBN 3-15-018465-7 . ( sehr knapp ) Einführungen Hans-Joachim Gehrke , Helmuth Schneider ( Hrsg. ) : Geschichte der Antike . 4. , erweiterte und aktualisierte Auflage .
+Metzler , Stuttgart / Weimar 2013 , ISBN 978-3-476-02494-7 . ( grundlegende Einführung ) Hans-Joachim Gehrke ( Hrsg. ) : Die Welt vor 600.
 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
+( Geschichte der Welt , Band 1 ) .
+C. H. Beck , München 2017 , ISBN 978-3406641015 . Rosemarie Günther : Einführung in das Studium der Alten Geschichte . Paderborn 2001 , ISBN 3-506-99498-0 . Hartmut Leppin : Einführung in die Alte Geschichte . München 2005 , ISBN 3-406-53527-5 . Allgemeine Darstellungen Beck Geschichte der Antike . 6 Bände .
+C. H. Beck , München 2014–2016 ( 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 2015 . Sebastian Schmidt-Hofner : Das klassische Griechenland .
+Der Krieg und die Freiheit .
+München 2016 . Peter Scholz : Der Hellenismus .
+Der Hof und die Welt .
+München 2015 . Wolfgang Blösel : Die römische Republik .
+Forum und Expansion .
+München 2015 . Armin Eich : Die römische Kaiserzeit .
+Die Legionen und das Imperium .
+München 2014 . Rene Pfeilschifter : Die Spätantike .
+Der eine Gott und die vielen Herrscher .
+München 2014 . 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. 3000–323 BC . 3. Auflage .
+2016 . Jonathan Hall : A History of the Archaic Greek World . 2. Auflage .
+2014 . P. J. Rhodes : A History of the Classical Greek World . 2005 . Robert Malcolm Errington : A History of the Hellenistic World . 2006 . Stephen Mitchell : A History of the Later Roman Empire , AD 284–641 . 2. Auflage .
+2015 . Timothy E. Gregory : A History of Byzantium . 2005 . ( Alle Bände bieten einen gut lesbaren und fundierten , knappen Überblick mit aktueller Literatur . ) Blackwell Companion to the Ancient World . Verschiedene Herausgeber .
+Blackwell , Oxford 2003ff .
+( 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. , 14. Bände ( teils in Teilbänden ) .
+2. Auflage .
+Cambridge 1970ff .
+( 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 . 13 Bände .
+Oldenbourg , München 2007ff .
+( 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 1994 , ISBN 3-506-71980-7 . Robin Lane Fox : Die klassische Welt .
+Eine Weltgeschichte von Homer bis Hadrian .
+Klett-Cotta , Stuttgart 2010 . ( gut lesbare und verlässliche Überblicksdarstellung bis ins 2. Jahrhundert n. Chr. ) Wolfgang Schuller : Das Erste Europa , 1000 v. Chr. –500 n. Chr. ( Handbuch der Geschichte Europas , Band 1 ) .
+Ullmer , Stuttgart 2004 , ISBN 3-8001-2791-1 . Jochen Bleicken u. a. ( Hrsg. ) : Oldenbourg Grundriss der Geschichte . Band 1–4 , München 1980 ff. ( versch .
+Auflagen ) .
+( Dreiteilung jedes Bandes : 1 ) sehr knappe Darstellung , 2 ) Forschungsüberblick und 3 ) umfassende Bibliographie . ) Eckhard Wirbelauer ( Hrsg. ) : Oldenbourg Geschichte Lehrbuch : Antike . Oldenbourg , München 2004 , ISBN 3-486-56663-6 . ( 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 . 2018 . Kathryn Lomas : The Rise of Rome .
+From the Iron Age to the Punic Wars .
+2018 . David Potter : The Origin of Empire .
+Rome from the Republic to Hadrian .
+2019 . Michael Kulikowski : The Triumph of Empire .
+The Roman World from Hadrian to Constantine .
+2016 Michael Kulikowski : The Tragedy of Empire .
+From Constantine to the Destruction of Roman Italy .
+( geplant für 2019 ) Routledge History of the Ancient World . Routledge Verlag , London / New York : Amélie Kuhrt : The ancient Near East . 2 Bände .
+1995 , ISBN 0-415-01353-4 ( Band 1 ) , ISBN 0-415-12872-2 ( Band 2 ) ( recht umfassende Darstellung der altorientalischen Geschichte bis zu den Achaimeniden ) Robin Osborne : Greece in the making 1200–479 B. C. 1996 , ISBN 0-415-03583-X . Simon Hornblower : The Greek world 479–323 B. C. 4. Auflage .
+2011 , ISBN 978-0-415-60292-1 . ( hervorragende Gesamtdarstellung der klassischen Zeit ) Graham Shipley : The Greek world after Alexander 323–30 B. C. 2000 , ISBN 0-415-04618-1 ( 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. 1000–264 B. C ) .
+1995 , ISBN 0-415-01596-0 . Martin Goodman : The Roman world 44 B. C. – A. D. 180. 1997 , ISBN 0-415-04969-5 . David S. Potter : The Roman empire at Bay , AD 180–395 . 2004 , ISBN 0-415-10058-5 ; 2. Aufl. 2014 ( hervorragende Darstellung , die auch soziokulturelle Aspekte mit einbezieht ) .
+Averil Cameron : The Mediterranean world in Late Antiquity A. D. 395–600 . 1993 , ISBN 0-415-01420-4 ; 2. Auflage 2012 ( 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 . 4 Bände ( in 8 Teilbände ) .
+Straßburg 1893ff .
+( 2. überarb .
+Auflage .
+1912ff . ) . ( Bedeutende , aber teilweise umstrittene Darstellung ) Georg Busolt : Griechische Geschichte bis zur Schlacht bei Chaeroneia . 3 Bände in 4. Perthes , Gotha 1885–1904 . Johann Gustav Droysen : Geschichte des Hellenismus . Perthes , Gotha 1877 . ( auf CD-ROM , Berlin 2007 , ISBN 978-3-89853-343-0 ) Matthias Gelzer : Julius Caesar .
+Der Politiker und Staatsmann .
+Callwey , München 1941 . ( 3. Auflage .
+Nachdr. Steiner , Wiesbaden 1983 , ISBN 3-515-03907-4 ) Edward Gibbon : Verfall und Untergang des römischen Imperiums . 6 Bände dtv , München 2003 , ISBN 3-423-96406-5 . - Original The History of the Decline and Fall of the Roman Empire . 6 Bände im Quartoformat .
+London 1776–1788 . ( 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 . 5 Bände , 7. Auflage .
+Darmstadt 1965 ( orig. 1884–1902 ; online ) .
+Theodor Mommsen : Römische Geschichte . Weidmann , Berlin 1902 ( Nachdr. dtv , München 2001 , ISBN 3-423-59055-6 ) .
+( 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. 2011 , ISBN 978-3-506-77306-7 . ( aktuelle und recht umfassende Darstellung bis ins späte 4. Jahrhundert v. Chr. ) Detlef Lotze : Griechische Geschichte .
+Von den Anfängen bis zum Hellenismus .
+München 2007 , ISBN 978-3-406-45014-3 ( 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 1982 . 5. Auflage .
+1995 , ISBN 3-423-04400-4 . ( ausgezeichnete Darstellung der griechischen Frühzeit bis hin zu den Perserkriegen ) John K. Davies : Das klassische Griechenland und die Demokratie . München 1982 . ( 5. Auflage .
+1996 , ISBN 3-423-04401-2 ) Christian Meier : Athen .
+Ein Neubeginn der Weltgeschichte .
+Berlin 1993 , ISBN 3-88680-128-4 . ( Gesamtdarstellung Athens im 5. Jahrhundert , aber ohne Anmerkungen . ) Frank W. Walbank : Die hellenistische Welt . München 1983 . ( 4. Auflage .
+1994 , ISBN 3-423-04402-0 ) Hermann Bengtson : Griechische Geschichte .
+Von den Anfängen bis in die römische Kaiserzeit .
+Handbuch der Altertumswissenschaft III .
+4 , Reprint der 5. durchgesehen und erg. Auflage von 1977 , München 1996 , ISBN 3-406-06660-7 . ( Als Ausgabe ohne wissenschaftlichen Apparat : Griechische Geschichte . 9. Auflage .
+München 2002 , ISBN 3-406-02503-X ; inhaltlich weitgehend veraltet ! ) Rom Klaus Bringmann : Geschichte der römischen Republik . München 2002 , ISBN 3-406-49292-4 . ( solide Darstellung ) Karl Christ : Geschichte der römischen Kaiserzeit . 5. aktual .
+Auflage .
+München 2005 , ISBN 3-406-36316-4 . ( 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 449 ) .
+Kröner , Stuttgart 2013 , ISBN 978-3-520-44901-6 ( 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
+( = Kröners Taschenausgabe . Band 458 ) .
+Kröner , Stuttgart 2009 , ISBN 978-3-520-45801-8 ( aktuelle und gut lesbare Darstellung der Kaiserzeit ) .
+Hermann Bengtson : Grundriss der Römischen Geschichte mit Quellenkunde .
+Republik und Kaiserzeit bis 284 n. Chr.
+Handbuch der Altertumswissenschaft III .
+5. München 1982 , ISBN 3-406-08617-9 . ( Inhaltlich inzwischen weitgehend veraltet . ) Alexander Demandt : Die Spätantike . Handbuch der Altertumswissenschaft III .
+6 , München 1989 ; 2. überarbeitete Auflage .
+München 2007 . ( Als inhaltlich gekürzte Ausgabe ohne wissenschaftlichen Apparat : Geschichte der Spätantike . München 1998 , ISBN 3-406-44107-6 ) Arnold Hugh Martin Jones : The Later Roman Empire 284–602 .
+A Social , Economic and Administrative Survey .
+3 Bände Oxford 1964 ( Neudruck in 2 Bände Baltimore 1986 ) .
+( 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. 2012 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
+Kulturgeschichte der Antiken Welt . Verschiedene Verfasser , Band 1ff . , Mainz 1977ff .
+Griechenland – Hellas
+Jochen Bleicken : Die athenische Demokratie . 4. Auflage .
+Stuttgart 1995 , ISBN 3-8252-1330-7 . Donald Kagan : The Peloponnesian War . London 2003 , ISBN 0-00-711505-9 . ( 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 . 2 Bände .
+1941 . Michael Stahl : Gesellschaft und Staat bei den Griechen . 2 Bände Schöningh , Paderborn 2003 , Band 1 , ISBN 3-506-99000-4 , Band 2 , ISBN 3-506-99001-2 . ( sehr gutes Überblickswerk ) Karl-Wilhelm Welwei : Das klassische Athen .
+Demokratie und Machtpolitik im 5. und 4. Jahrhundert .
+Darmstadt 1999 , ISBN 3-534-12976-8 . ( Detaillierte Darstellung der Politik Athens und dessen Aufstieg zur Hegemonialmacht . ) Karl-Wilhelm Welwei : Sparta .
+Aufstieg und Niedergang einer antiken Großmacht .
+Stuttgart 2004 , ISBN 3-608-94016-2 . ( Wohl die beste deutschsprachige Darstellung der Geschichte Spartas . ) Karl-Wilhelm Welwei : Die griechische Polis .
+Verfassung und Gesellschaft in archaischer und klassischer Zeit .
+2. Auflage .
+Stuttgart 1998 , ISBN 3-515-07174-1 . Rom
+Aufstieg und Niedergang der römischen Welt . Berlin und New York 1972ff .
+Jochen Bleicken : Verfassungs- und Sozialgeschichte des Römischen Kaiserreiches . 2 Bände .
+Paderborn , München , Wien , Zürich 1981 , Band 1 , ISBN 3-506-99403-4 , Band 2 , ISBN 3-506-99257-0 . Persien / Iran
+Encyclopædia Iranica London 1985 ff. ( Onlineportal ) Touraj Daryee ( Hrsg. ) : King of the Seven Climes .
+A History of the Ancient Iranian World ( 3000 BCE-651 CE ) .
+UCI Jordan Center for Persian Studies , Irvine ( CA ) 2017 . Josef Wiesehöfer : Das antike Persien .
+Von 550 v. Chr. bis 650 n. Chr.
+Aktual .
+Neuauflage , Patmos , Düsseldorf 2005 , ISBN 3-491-96151-3 ( 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
+Reallexikon der Germanischen Altertumskunde , 2. Auflage .
+Bruno Bleckmann : Die Germanen .
+Von Ariovist zu den Wikingern .
+C. H. Beck Verlag , München 2009 . Walter Pohl : Die Germanen . 2. Auflage .
+Oldenbourg , München 2004 . 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
+.
+2. Auflage .
+Kohlhammer , Stuttgart u. a. 2005 . Kelten
+Bernhard Maier : Die Kelten .
+Ihre Geschichte von den Anfängen bis zur Gegenwart .
+3. , vollständig überarbeitete und erweiterte Auflage .
+C. H. Beck , München 2016 . Wolfgang Meid : Die Kelten . 2. , verbesserte Auflage .
+Reclam , Stuttgart 2011 . Skythen , Hunnen und andere Steppenvölker
+Christoph Baumer : The History of Central Asia . Band 1 und 2. I. B.
+Tauris , London 2012ff .
+Valerie Hansen : The Silk Road .
+A History with Documents .
+Oxford University Press , Oxford 2016 . Hyun Jin Kim : The Huns . Routledge , New York 2016 . St. John Simpson , Svetlana Pankova ( Hrsg. ) : Scythians .
+Warriors of ancient Siberia .
+Thames & Hudson , London 2017 . Timo Stickler : Die Hunnen . C. H. Beck , München 2007 . Indien und China
+Raoul McLaughlin : Rome and the Distant East .
+Trade Routes to the Ancient Lands of Arabia , India and China .
+Continnuum , London / New York 2010 . Walter Scheidel ( Hrsg. ) : Rome and China .
+Comparative Perspectives on Ancient World Empires .
+Oxford University Press , Oxford u. a. 2009 . Richard Stoneman : The Greek Experience of India .
+From Alexander to the Indo-Greeks .
+Princeton University Press , Princeton 2019 . Geschichtsschreibung
+Dieter Flach : Römische Geschichtsschreibung . 3. Aufl. , WBG , Darmstadt 2001 . Gabriele Marasco ( Hrsg. ) : Greek and Roman Historiography in Late Antiquity .
+Fourth to Sixth Century A. D.
+Leiden u. a. 2003 . John Marincola ( Hrsg. ) : A Companion to Greek and Roman Historiography . 2 Bde. , Blackwell , Oxford 2007 . Klaus Meister : Die griechische Geschichtsschreibung . Kohlhammer , Stuttgart 1990 . Militärgeschichte
+Leonhard Burckhardt : Militärgeschichte der Antike . C. H. Beck , München 2008 , ISBN 978-3-406-56247-1 . Brian Campbell , Lawrence A. Tritle ( Hrsg. ) : The Oxford Handbook of Warfare in the Classical World . Oxford University Press , Oxford 2013 , ISBN 978-0-19-530465-7 . Christian Mann : Militär und Kriegführung in der Antike ( = Enzyklopädie der griechisch-römischen Antike . Band 9 ) .
+Oldenbourg , München 2013 , ISBN 978-3-486-59682-3 . 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
+.
+Klett-Cotta , Stuttgart 2012 , ISBN 978-3-608-94768-7 . Harry Sidebottom , Michael Whitby ( Hrsg. ) : The Encyclopedia of Ancient Battles . 3 Bände .
+Wiley-Blackwell , Malden u. a. 2017 . 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 2005 . Werner Dahlheim : Die Welt zur Zeit Jesu . C. H. Beck , München 2013 . Jörg Rüpke : Pantheon .
+Geschichte der antiken Religionen .
+C. H. Beck , München 2016 . Entdeckungsfahrten
+Raimund Schulz : Abenteurer der Ferne .
+Die großen Entdeckungsfahrten und das Weltwissen der Antike .
+Klett-Cotta , Stuttgart 2016 , ISBN 978-3-608-94846-2 . Wirtschaftsgeschichte
+Géza Alföldy : Römische Sozialgeschichte . 4. , völlig überarbeitete und aktualisierte Auflage .
+Steiner , Stuttgart 2011 . Sitta von Reden : Antike Wirtschaft ( = Enzyklopädie der griechisch-römischen Antike . Band 10 ) .
+de Gruyter Oldenbourg , Berlin u. a. 2015 , ISBN 978-3-486-85262-2 . 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 8) .
+Metzler , Stuttgart / Weimar 2013 , ISBN 978-3-476-02468-8 . Ulrich Niggemann , Kai Ruffing : In : Europäische Geschichte Online . hrsg. vom Institut für Europäische Geschichte ( Mainz ) , 2013 ( Zugriff am : 29. August 2013 ) .
+Weblinks Sehr umfangreiche Linkliste der HU Berlin KIRKE – Linkportal Antike ( wohl das umfassendste dt. Angebot ) LacusCurtius – zahlreiche antike Texte in engl. Übersetzung und / oder Originaltexte Perseus Project – Quellensammlung zur Antike ( englisch ) Navicula Bacchi – Materialsammlung Alte Sprachen und Antike Geschichte Umfangreiche und teils sehr empfehlenswerte Materialsammlung bei Livius.org 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 ( 1941 ) . Vgl. dazu ausführlich Klaus-Peter Johne ( Hrsg. ) : Die Zeit der Soldatenkaiser . 2 Bände . Berlin 2008 . Siehe Hermann Strasburger : Umblick im Trümmerfeld der griechischen Geschichtsschreibung . In : Historiographia antiqua . Festschrift für Willy Peremans , Leuven 1977 , S. 3–52 . „ 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 2002 , S. 62 ) . Vgl. auch Mortimer Chambers : Georg Busolt : his career in his letters . Leiden 1990 , S. VII ; Donald Kagan : The outbreak of the Peloponnesian War . Ithaca / NY 1969 , S. VII . Überblick zur neueren Forschung zur Spätantike etwa bei Philip Rousseau ( Hrsg. ) : A Companion to Late Antiquity . Malden ( Massachusetts ) u. a. 2009 . 
+
+Datei : Anthony Hope Hawkins by Alfred Ellis &amp; Walery.jpg Anthony Hope war das Pseudonym von Sir Anthony Hope Hawkins ( * 9. Februar 1863 in London ; † 8. Juli 1933 ) , 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 1885 mit einem first-class degree und wurde Anwalt in London .
+Er heiratete 1903 , hatte zwei Söhne und eine Tochter .
+Während des Ersten Weltkrieges arbeitete er im Ministry of Information .
+1918 wurde er für seine Verdienste während des Krieges zum Ritter geschlagen .
+Sein erstes Buch war A Man of Mark ( 1890 ) , später schrieb er The Dolly Dialogues ( 1894 ) .
+Den größten Erfolg hatte er mit The Prisoner of Zenda ( dt. „ Der Gefangene von Zenda “ ) . Anschließend verfasste er Rupert of Henzau ( 1898 ) 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 .
+1 Å = 100.000 fm = 100 pm = 0,1 nm = 10 − 4 μm = 10 − 7 mm = 10 − 8 cm = 10 − 10 m
+Das Ångström wird insbesondere in der Kristallographie und der Chemie benutzt , um mit „ einfachen “ Zahlenwerten arbeiten zu können .
+So ist 1 Å 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 0,3 und 3 Å.
+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 1925 Manne Siegbahn mit der Definition der X-Einheit , die etwa 10 − 13 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 1301-3 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 + 00C5 ) dargestellt werden .
+Unicode enthält zwar auch ein Zeichen namens ANGSTROM SIGN ( Ångströmzeichen , U + 212B : Å ) , 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 978-3-411-04163-3 , Eintrag „ Ångström “ , S. 102. 
+
+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 Datei : Ampere coulomb.svg
+Ein Ampere entspricht einem Fluss von 1 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. 6,2 Trillionen Elektronen pro Sekunde .
+Ein Fluss von 1 A über eine Spannung von 1 Volt ( V ) bedeutet eine Leistung von 1 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 1 Weber-Einheit = 0,1 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-Einheit / Sekunde “ 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 1939 die Einheit der Stromstärke als weitere Basiseinheit vorgeschlagen .
+Definition 1898 1898 wurde 1 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 1,118 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 1948 Datei : Ampere-def.svg 1948 wurde das Ampere wie folgt über die Lorentzkraft zweier Leiter aufeinander definiert : 1 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 1 m zwischen diesen Leitern eine Kraft von 2 · 10 − 7 Newton pro Meter Leiterlänge hervorrufen würde .
+Mit dieser Definition wurde zugleich der Wert der magnetischen Feldkonstante μ0 festgelegt .
+Neudefinition des Ampere 2018 Am 16. November 2018 wurde auf der 26. Generalkonferenz für Maß und Gewicht beschlossen , das Ampere und andere SI-Basiseinheiten mit Wirkung zum 20. Mai 2019 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 μ0 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 , 2009 , S. 246 Wilhelm Jaeger : Die Entstehung der internationalen Maße der Elektrotechnik , Julius Springer Verlag , Berlin 1932 , S. 8–9 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 4047 m - beziehungsweise 40,47 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 43.560 Square Feet definiert , weil die zur ursprünglichen Definition verwendeten Längenmaße Furlong ( = 660 Fuß ) und Chain ( = 66 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 ± 20 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 87.000 ac ( ≈ 350 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 bushel / acre 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 40 Rods ( oder Perches ; = 1 Furlong oder 660 Feet ) und der Breite von 4 Rods ( oder Perches ; = 66 Feet oder [ seit 1620 ] 1 Chain ) beziehungsweise 160 Square Rods ( Quadratruten ) bei welcher Grundstücksform auch immer definiert .
+Mit seiner Größe von grob 40 Ar ist der Acre typologisch vergleichbar mit dem Morgen , dem Tagewerk ( oder Tagwan ) , dem Joch ( oder Juchart ) und dem Mannwerk .
+Angloamerikanische Maßreform 1959 Die weltweit unterschiedlichen angloamerikanischen Längeneinheiten wurden 1959 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 1,000002 .
+Bei der Landvermessung hätte dies bei großen Entfernungen zu spürbaren Differenzen geführt .
+Bei einer Streckenlänge von beispielsweise 1000 km wäre der Unterschied 2 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 U. S.
 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
+basierende Acre ist um etwa 162 cm - geringfügig größer .
+Historische Einheiten Obgleich auf den Britischen Inseln die Größe des Acres seit dem Hochmittelalter mit 160 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 1824 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 1,3-fache Größe , der Plantation Acre grob die 1,6-fache Größe des heutigen Acres .
+Einige dieser veralteten Maße waren teilweise bis ins 20. Jahrhundert gebräuchlich , so in abgelegenen Gebieten Irlands .
+Literatur Herbert Arthur Klein : The Science of Measurement .
+A Historical Survey .
+Dover Publications , Mineola NY 1988 . Johann Friedrich Krüger : Vollständiges Handbuch der Münzen , Maße und Gewichte aller Länder der Erde . Verlag Gottfried Basse , Quedlinburg / Leipzig 1830 . Weblinks Einzelnachweise Flexion von Acre . canoo.net ; abgerufen am 22. Dezember 2012 , und Rechtschreibung Acre . duden.de ; abgerufen am 22. Dezember 2012 . Oxford English Dictionary , Band I , Seite 117 f. – Vgl. ferner Herbert Arthur Klein : The Science of Measurement . A Historical Survey . Dover Publications , Mineola NY 1988 , S. 76. Zu Irland vgl. . 
+
+Apostilb ( Einheitenzeichen asb ) ist eine veraltete Einheit der Leuchtdichte selbstleuchtender Körper .
+1942 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 1978 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 cd / m - bzw. das Nit : Weblink Luminance Unit Measurement Converter Einzelnachweise sizes.com : , nach : Journal of the Optical Society of America , volume 32 , pages 348-362 . 
+
+Das oder der Ar , in der Schweiz die Are , ist eine Flächenmaßeinheit im metrischen System von 100 & nbsp ; m < sup > 2 < / sup > mit dem Einheitenzeichen a ( oft jedoch nicht oder falsch abgekürzt : Ar bzw. ar ) .
+100 & nbsp ; a ergeben 1 & nbsp ; ha.
+Ein Quadrat mit dem Flächeninhalt von 1 a hat eine Kantenlänge von zehn Metern , man spricht daher auch von einem Quadratdekameter & nbsp ;(d am < sup > 2 < / 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 1793 wurde in Frankreich das Meter als der 10-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 100 m2 neu geschaffen .
+Sie war anfangs die einzige gebräuchliche metrische Flächeneinheit , samt ihren Teilen und Vielfachen Zentiar ( 1 ca = 1 m2 ) und Hektar ( 1 ha = 100 a ) .
+Im Jahr 1868 wurde die Maßeinheit unter der Bezeichnung Ar auch in Deutschland amtlich eingeführt .
+Vielfache und Teile 1 Hektar ( von „ Hekto-Ar “ ) = 1 ha = 100 a = 10.000 m2
+= 1 hm2 = 100 m • 100 m 1 Dekar ( von „ Deka-Ar “ ) = 1 daa = 10 a = 1000 m2
+1 Ar = 1 a = 100 m2
+= 1 dam2 = 10 m • 10 m 1 Zentiar = 0,01 a = 1 m2
+= 1 m2 = 1 m • 1 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 6 der SI-Broschüre ( 8. Auflage ) ist das Ar nicht genannt . In der 7. Auflage von 1998 sind noch beide enthalten . Im | url = http://www.bipm.org/utils/common/pdf/CCU16.pdf | wayback = 20070620020032 | text = 16. Meeting des CCU 2004 ( Seite 11 ; PDF ; 1,1 MB ) heißt es noch , dass beide in Tabelle 6 erscheinen sollen . Das Ar wurde dann offenbar als „ minor change “ in einem „ editorial meeting “ eliminiert , auf das im nachfolgenden | url = http://www.bipm.org/utils/common/pdf/CCU17.pdf | wayback = 20070620020108 | text = 17. Meeting ( Seite 5 ; PDF ; 259 kB ) Bezug genommen wird . C. Bopp : Die internationale Maß- , Gewichts- und Münz-Einigung durch das metrische System . Julius Maier , Stuttgart 1869 . 
+
+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 20 ) .
+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 90 , 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 20. Jahrhundert ( zuerst in Frankreich , England und den USA ) zu entstehen .
+Eine frühe Ausnahme innerhalb der deutschen Historiker war Karl Lamprecht ( 1856–1915 ) .
+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. s | cholé ) vorbehalten , was etwa „ schöpferische Muße “ beschrieb , wovon das deutsche Wort Schule herrührt .
+Datei : Ilia Efimovich Repin ( 1844-1930 ) - Volga Boatmen ( 1870-1873 ) . 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 1918 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 1808 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 ( 1798 , § 87 ) 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 1967 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 1950er und 1960er 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 1956 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 1960 und 2010 das Arbeitsvolumen pro Kopf kontinuierlich um 30 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 ‘ ; 1883 ) , 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 1887 auf Deutsch .
+Lafargue zitierte Lessing : „ Laß uns faul in allen Sachen , Nur nicht faul zu Lieb ’ und Wein ’ Nur 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 3 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 1968 wieder .
+Die Ablehnung der Arbeit spielte auch in Italien in den Kämpfen der 1960er und 1970er Jahre eine zentrale Rolle .
+Der Postanarchist Bob Black rief 1985 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 Punkt ( en ) 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 1990er 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 ( 1933 ) 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
+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
+Literatur Bücher Sven Rahner : Architekten der Arbeit : Positionen , Entwürfe , Kontroversen . edition Körber-Stiftung , Hamburg 2014 , ISBN 978-3-89684-156-8 . Andrea Komlosy : Arbeit .
+Eine globalhistorische Perspektive .
+13. bis 21. Jahrhundert .
+Promedia , Wien 2014 , ISBN 978-3-85371-369-3 . Bob Black : Die Abschaffung der Arbeit . Löhrbach 2003 , ISBN 3-922708-04-8 Harry Braverman : Die Arbeit im modernen Produktionsprozeß . Campus Verlag , Frankfurt am Main u. a. 1977 , ISBN 3-593-32225-0 . Karl Bücher : Arbeit und Rhythmus . Hirzel , Leipzig 1904 . Robert Castel : Les métamorphoses de la question sociale , une chronique du salariat . 1995 . deutsch : Die Metamorphosen der sozialen Frage : eine Chronik der Lohnarbeit . Univ.-Verlag Konstanz , Konstanz 2000 . Lars Clausen : Produktive Arbeit , destruktive Arbeit . Verlag Walter de Gruyter , Berlin / New York 1988 , ISBN 3-11-011814-9 . Angelika Ebbinghaus : Arbeiter und Arbeitswissenschaft .
+Zur Entstehung der „ Wissenschaftlichen Betriebsführung “ .
+Westdeutscher Verlag , Opladen 1984 , ISBN 3-531-11667-3 . Peter Fleissner : Technologie und Arbeitswelt in Österreich . ÖGB-Verlag , 1987 , ISBN 3-7035-0326-2 . Reimer Gronemeyer ( Hrsg. ) : Der faule Neger .
+Vom weißen Kreuzzug gegen den schwarzen Müßiggang .
+Rowohlt , Reinbek bei Hamburg 1991 , ISBN 3-499-13071-8 . Reinhard P. Gruber : Nie wieder Arbeit .
+Schivkovs Botschaften vom anderen Leben .
+ISBN 3-7017-0606-9 . Simon Head : The New Ruthless Economy .
+Work and Power in the Digital Age .
+Oxford UP , 2005 , ISBN 0-19-517983-8 . IG Metall : Handbuch ' Gute Arbeit ' . 2007 , ISBN 978-3-89965-255-0 . Wulf D. Hund : Stichwort Arbeit : Vom Banausentum zum travail attractif .
+Distel Verlag , Heilbronn 1990 , ISBN 3-923208-21-9 . 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
+.
+1932 . Paul Lafargue : Das Recht auf Faulheit .
+Widerlegung des Rechts auf Arbeit von 1848 .
+5. Auflage .
+Trotzdem Verlag , Grafenau 2004 , ISBN 3-931786-03-X . Severin Müller : Phänomenologie und philosophische Theorie der Arbeit .
+Band I : Lebenswelt – Natur – Sinnlichkeit . Karl Alber , Freiburg / München 1992 , ISBN 3-495-47731-4 ; Band II : Rationalität – Welt – Vernunft . Karl Alber , Freiburg / München 1994 , ISBN 3-495-47732-2 . David F. Noble : Maschinenstürmer oder die komplizierten Beziehungen der Menschen zu ihren Maschinen . Wechselwirkung-Verlag , Berlin 1986 , ISBN 3-924709-00-9 . Erich Ribolits : Die Arbeit hoch ?
+Berufspädagogische Streitschrift wider die Totalverzweckung des Menschen im Post-Fordismus .
+Profil , München / Wien 1995 , ISBN 3-89019-362-5 . 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
+.
+2004 , ISBN 3-89771-429-9 . Helmuth Schneider u. a. : Geschichte der Arbeit .
+Vom Alten Ägypten bis zur Gegenwart .
+Kiepenheuer & Witsch , Köln 1980 , ISBN 3-462-01382-3 . Eberhard Straub : Vom Nichtstun .
+Leben in einer Welt ohne Arbeit .
+wjs-Verlag , Berlin 2004 , ISBN 3-937989-02-1 . 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
+, VS Verlag , Wiesbaden 2008 . Susanne Hartard , Axel Schaffer , Carsten Stahmer ( Hrsg. ) : Die Halbtagsgesellschaft .
+Konkrete Utopie für eine zukunftsfähige Gesellschaft .
+Nomos Verlag , Baden-Baden 2006 , ISBN 3-8329-2245-8 . Manfred Füllsack : Arbeit . ( UTB Reihe NR3235 ) .
+2009 , ISBN 978-3-8252-3235-1 . 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 , 27 ) .
+Edition Sigma , Berlin 2008 . Heinz-J .
+Bontrup : Arbeit und Kapital .
+Wirtschaftspolitische Bestandsaufnahme und Alternativen .
+In : Johannes Rehm , Hans G. Ulrich ( Hrsg. ) : Menschenrecht auf Arbeit ?
+Sozialethische Perspektiven .
+Stuttgart 2009 , ISBN 978-3-17-020823-0 . 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 1999 , ISBN 3-89691-466-9 , S. 362–383 . Peter-Paul Bänziger : , in : Zeithistorische Forschungen / Studies in Contemporary History 12 ( 2015 ) , S. 11–38 . 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 2000 ; Einleitung von Christiana Lütges , S. 13–22 , insb . 16–18 . " Tripaliare bedeutete ursprünglich , jemanden auf dem trepalium zu foltern ; dieses wurde erstmals im 6. 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 16. 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 ; Beck'sche Verlagsbuchhandlung , München 1998 , ISBN 3-406-39267-9 , S. 54 ( Originaltitel : Tools for Conviviality . Harper and Row , New York 1973 ) 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 1980.Xenophon : Oikonomikós 4,2Aristoteles : Politik 1328 b 37 ff . De officiis 1,150grundeinkommensblog.blogspot . com : Der aktuelle Beschäftigungsoptimismus in historischer Perspektive . 3. November 2010 . . Website des Theoriemagazins . . www.anarchismus.at . . krisis.org . 
+
+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 12C 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 0,1 u. Die betreffende ganze Zahl heißt Massenzahl des Kerns oder Atoms und ist gleich der Anzahl der Nukleonen im Kern .
+Definition 1 u ist definiert als ein Zwölftel der Masse eines isolierten Atoms des Kohlenstoff-Isotops 12C im Grundzustand .
+Der aktuell empfohlene Wert ist < ref name = " uinkg " > 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 MeV / c < sup > 2 < / 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 12C-Atoms 12 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 1960 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 16O .
+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 16O 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 , 12C 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 16O höher ist als bei 12C 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 80/181/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 kg / mol 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 , 1 kDa = 1000 Da , sowie das Megadalton , 1 MDa = 1.000.000 Da .
+Beziehung zur molaren Masse Bis zur Neudefinition der SI-Basiseinheiten im Jahr 2019 war das Mol als die Stoffmenge definiert , die aus ebenso vielen Einzelteilchen besteht , wie Atome in 12 Gramm 12C enthalten sind .
+Durch diese Definition der atomaren Masseneinheit und des Mols über dasselbe Atom ( ein Atom 12C hatte eine Masse von 12 u , ein Mol 12C hatte eine Masse von 12 g ) ergab sich für die Masse eines Teilchens in u und dessen molare Masse in g / mol exakt der gleiche Zahlenwert .
+( Beispiel Acetylsalicylsäure : Masse eines Moleküls 180,16 u , molare Masse 180,16 g / mol ) .
+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 2019 nunmehr der Wert für NA exakt festgelegt ist und somit die Zahl der Teilchen in einem Mol nicht mehr über die Masse des 12C-Atoms bestimmt wird , hat ein Mol 12C nicht mehr exakt die Masse 12 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 12C hat definitionsgemäß die Masse 12 u.
+Ein Wasserstoffatom des Isotops 1H hat die Masse 1,007 825 0 u.
+Ein Molekül des bekannten Wirkstoffes Acetylsalicylsäure ( Aspirin ) hat eine Masse von 180,16 u.
+Ein Molekül des kleinen Peptidhormons Insulin hat eine Masse von 5808 u.
+Ein Molekül des Proteins Aktin ( eines der häufigsten Proteine in Eukaryoten ) hat eine Masse von ungefähr 42 ku .
+Einzelnachweise aufgrund der EU-Richtlinie 80/181/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 , Int . J. Mass Spectr.Ion Process . 251 ( 2006 ) 85-94 , 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 realize / realise „ 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 1994 bis 2004 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 Geml / Lauer , 2008 ) .
+Einzige Ausnahme bildet der Bereich „ Wissenschaft und Technik “ , in welchem eine Abnahme um den Faktor 1,6 zu verzeichnen ist .
+Insgesamt lässt sich festhalten , dass der Gebrauch von Anglizismen in zehn Jahren um den Faktor 1,7 zugenommen hat .
+Hingegen hat die Entlehnungshäufigkeit im Vergleich zum Zeitraum 1954–1964 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 ( 1995–2004 ) mit insgesamt 381191 Lemmata ausgewertet ; darunter wurden 13301 = 3,5 % Anglizismen festgestellt .
+Das Textkorpus hat einen Umfang von rund 10.3 Millionen Token ( = einzelne Wortformen ) , darunter 52647 = 0,5 % Anglizismen . Von den 13301 Anglizismen sind 12726 ( 95,68 % ) ( 48190 Token = 91,53 % ) Substantive , 307 ( 2,30 % ) ( 1654 Token = 3,14 % ) Adjektive , 255 ( 1,92 % ) ( 2371 Token = 4,50 % ) Verben und 13 ( 0,10 % ) ( 432 Token = 0,82 % ) 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 2001
+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 16781 datierbare Stichwörter , darunter 5244 Entlehnungen ( Lehnwörter und Fremdwörter ) .
+Unter den Entlehnungen sind 519 datierbare Anglizismen .
+Man sieht , dass diese Entlehnungen aus dem Englischen erst recht spät einsetzen und dann aber eine erhebliche Dynamik entwickeln .
+Im 20. Jahrhundert erreichen die Anglizismen 3,1 % des gesamten erhobenen Wortschatzes beziehungsweise 9,9 % 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 2003 , dass einige der Slogans von weniger als 10 % der Befragten verstanden wurden .
+Acht der zwölf untersuchten Unternehmen hätten ihre Werbeslogans seitdem geändert .
+2008 störten sich in einer Umfrage der Gesellschaft für deutsche Sprache 39 % 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 ( 58 % Ablehnung bei der Gruppe der über 59-Jährigen , 46 % Ablehnung bei ostdeutschen Umfrageteilnehmern ) .
+Die Entwicklung des Englischen zur lingua franca im 20. 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 2,1 Prozent der deutschen Arbeitnehmer verhandlungssicher Englisch .
+In der Gruppe der unter 30-Jährigen bewerten jedoch über 54 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 2014 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 59 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 19. 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 700 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 20. Jahrhunderts nicht mehr statt .
+Der Sprachwissenschaftler Rudolf Hoberg sah 2013 keine Bedrohung durch Anglizismen .
+Die deutsche Sprache habe schon immer englische Ausdrücke aufgenommen : „ Nach der letzten Duden-Ausgabe haben wir etwa 3,5 Prozent Anglizismen , aber 20 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 50 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 Grimm'sche 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 1945 . De Gruyter , Berlin / New York , NY 2001 , ISBN 3-11-012854-3 .
+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 2013 , Seiten 57–119 .
+ISBN 978-3-11-033462-3 . Cristiano Furiassi und Henrik Gottlieb ( Hrsg. ) : Pseudo-English – Studies on False Anglicisms in Europe . De Gruyter , Berlin / Boston / München 2015 , ISBN 978-1-61451-671-2 . Richard Glahn : Der Einfluss des Englischen auf gesprochene deutsche Gegenwartssprache .
+Eine Analyse öffentlich gesprochener Sprache am Beispiel von „ Fernsehdeutsch “ .
+2. , durchgesehene Aufl. , Peter Lang , Frankfurt am Main 2002 , ISBN 3-631-38955-8 . Manfred Görlach : Dictionary of European Anglicisms . Oxford 2001 , ISBN 0-19-823519-4 . Wolfgang Müller-Hasemann : Das Eindringen englischer Wörter ins Deutsche ab 1945 . In : Karl-Heinz Best , Jörg Kohlhase ( Hrsg. ) : Exakte Sprachwandelforschung . edition herodot , Göttingen 1983 , ISBN 3-88694-024-1 , S. 143–160 . Rudolf Muhr : Anglizismus . In : Gert Ueding ( Hrsg. ) : Historisches Wörterbuch der Rhetorik .
+WBG , Darmstadt 1992ff , Band 10 ( 2011 ) , Sp. 37–45 . 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 2000 , ISBN 3-631-36075-4 ( Dissertation Uni Münster ( Westfalen ) , philosophische Fakultät , 1999 ) , Peter Schlobinski : Anglizismen im Internet . in : Networx , Nr. 14 , 2000 , Online ( PDF ; kostenlos , 28 Seiten , 983 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 . 19. Dezember 2006 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
+, ( = Tübinger Beiträge zur Linguistik , Band 486 ) , Narr , Tübingen 2005 , S. 177–191 , ISBN 978-3-8233-6133-6 . Stefan Zenklusen : Leitsprache Anglotumbdeutsch .
+In : ( ders. ) : Im Archipel Coolag .
+wvb , Berlin 2006 , ISBN 3-86573-164-3 ; gekürzt in : Zeitschrift für kritische Theorie , Nr. 26/27 , Jahrgang 2008 , S. 191f , ISBN 978-3-86674-034-1 / .
+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
+Linguistische Anmerkungen zu einer populären Anglizismen-Kritik ( PDF ; 190 kB ) , Thomas Niehr , Heinrich-Heine-Universität Düsseldorf , 2002 . Anglizismen sind das neue Imponier-Deutsch ( zeit.de 2011 ) Infoportal zu Gebrauch , Einfluss und Kritik ( private Seite ) Einzelnachweise Wolfgang Pfeifer et al. , Etymologisches Wörterbuch des Deutschen , 4. Aufl. , Berlin 1993 , p. 337. Dieter Herberg / Michael Kinne / Doris Steffens : Neuer Wortschatz : Neologismen der 90er Jahre im Deutschen , Berlin / New York 2004 . Broder Carstensen / Ulrich Busse : Anglizismen-Wörterbuch : der Einfluss des Englischen auf den deutschen Wortschatz nach 1945 , Band 1 ( A–E ) , Berlin / New York 2001 , p. 61 * . Stephanie Bohmann : Englische Elemente im Gegenwartsdeutsch der Werbebranche . Tectum Verlag , 1996 , ISBN 978-3-89608-964-9 . Frank Puscher : Oberflächliche Fehler . In : c ’ t. 14/2009 , S. 74 , 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 15/2015 Seite 27 Annett Stein im General-Anzeiger ( Bonn ) vom 19. Dezember 2015 , Journal Seite 6 Svetlana Burmasova : ( PDF ; 4,8 MB ) , in : Beiträge zur Linguistik , Band 2 , University of Bamberg Press , Bamberg 2010 , a ) S. 222ff . , b ) S. 223 , c ) S. 225. 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 2013 , Seiten 57–119 , Bezug : Seite 77. ISBN 978-3-11-033462-3 . 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 2013 , Seiten 57–119 , Bezug : Seite 93. ISBN 978-3-11-033462-3 . Duden . Das Herkunftswörterbuch . Bibliographisches Institut , Mannheim / Leipzig / Wien / Zürich 2001 . ISBN 3-411-04073-4 . Helle Körner : Zur Entwicklung des deutschen ( Lehn- ) Wortschatzes . In : Glottometrics 7 , 2004 , Seite 25–49 . Tabelle für die Anglizismen Seite 36 ; weitere Angaben 29f . 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 7 , 1986 , Seite 31–41 , zu Duden . Etymologie 1963 und Katharina Ternes : Entwicklungen im deutschen Wortschatz . In : Glottometrics 21 , 2011 , Seite 25–53 , zu Kluge . Etymologisches Wörterbuch der deutschen Sprache . 24. Auflage 2002 . Zusammenfassung der Endmark-Studie . Studie der Gesellschaft für deutsche Sprache , Deutsche sprechen schlecht Englisch : Studie der GfK , Die Zeit , 18. Juni 2013 Sprachen lernen : Fernsehen auf Englisch , Die Zeit , 9. April 2014 Berliner Behörden machen es internationalen Start-ups nicht leicht , Tagesspiegel , 2. April 2014 Englisch muss unsere Verwaltungssprache werden , Die Welt , Kommentar von Alexander Graf Lambsdorff , 15. Dezember 2014 Umfrage : Mehrheit der Deutschen für Englisch als zweite Amtssprache , YouGov Meinungsforschungsinstitut , 9. August 2013 Ludwig Reiners : Stilkunst . Ein Lehrbuch deutscher Prosa , 2. Auflage . C. H. Beck , München 2004 , S. 391. ISBN 3-406-34985-4 . , RP online vom 5. Oktober 2013 , Spiegel Online vom 21. November 2013 , NPD-Blog , 7. März 2007 , Die Welt , 23. August 2000 books.google.de 
+
+Datei : Astronomer.moon.jpg Datei : JohannesVermeer-TheAstronomer ( 1668 ) . jpg Datei : Galileo.arp.300pix.jpg 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 und / oder 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 
+
+Datei : Alan Turing az 1930-as években.jpg Datei : Alan Turing signature.svg Alan Mathison Turing OBE , FRS [ ] ( * 23. Juni 1912 in London ; † 7. Juni 1954 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 1953 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 1952 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 2009 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 2011 trotz einer Petition abgelehnt .
+Am Weihnachtsabend , dem 24. Dezember 2013 sprach Königin Elisabeth II . posthum ein „ Royal Pardon “ ( Königliche Begnadigung ) aus .
+Leben und Wirken Kindheit und Jugend Datei : Alan Turing Aged 16.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 23. Juni 1912 zur Welt kam .
+Da der Staatsdienst seines Vaters noch nicht beendet war , reiste dieser im Frühjahr 1913 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 1916 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. Michael ’ s in St. Leonards-on-the-Sea geschickt , wo die Schulleiterin frühzeitig seine Begabung bemerkte .
+1926 , im Alter von 14 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 100 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 1928 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 1931 auf ein College zweiter Wahl gehen , das King ’ s College , Cambridge , entgegen seinem Wunsch , am Trinity College zu studieren .
+Er studierte von 1931 bis 1934 unter Godfrey Harold Hardy ( 1877–1947 ) , einem respektierten Mathematiker , der den Sadleirian Chair in Cambridge innehatte , das zu der Zeit ein Zentrum der mathematischen Forschung war .
+Datei : Turingmaschine.svg
+In seiner für diesen Zweig der Mathematik grundlegenden Arbeit On Computable Numbers , with an Application to the „ Entscheidungsproblem “ ( 28. Mai 1936 ) formulierte Turing die Ergebnisse Kurt Gödels von 1931 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 23 wichtigsten offenen Probleme der Mathematik des 20. Jahrhunderts , vorgestellt von David Hilbert 1900 auf dem 2. 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 ( 1903–1995 ) 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 .
+1938 und 1939 verbrachte Turing zumeist an der Princeton University und studierte dort unter Alonzo Church .
+1938 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 1939 besuchte Turing Vorlesungen des österreichisch-britischen Philosophen Ludwig Wittgenstein ( 1889–1951 ) ü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 Datei : Bletchley Park IMG 3606.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 1943 , 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 1970er 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 Datei :P unch cards in tray for Pilot ACE computer built at the National Physical Laboratory c. 1950 ( 9672239226 ) . jpg Von 1945 bis 1948 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 1948 lehrte Turing an der Universität Manchester und wurde im Jahr 1949 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 1950 ) 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 .
+1952 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 30 Minuten pro Zug .
+Das einzige schriftlich dokumentierte Spiel verlor er gegen einen Kollegen .
+Arbeit an mathematischen Problemen der Biologie Von 1952 bis zu seinem Tod 1954 arbeitete Turing an mathematischen Problemen der theoretischen Biologie .
+Er veröffentlichte 1952 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 1992 unveröffentlicht .
+Verfolgung wegen Homosexualität und Turings Tod Datei : Berliner CSD 2012 by andreas tw - 02.jpg
+1952 half der 19-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 1952 begann Turing seine Therapie bei dem aus Berlin stammenden und seit 1939 in Manchester lebenden Psychoanalytiker Franz Greenbaum .
+Dieser war ein Anhänger C. G.
 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
+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 .
+1954 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 1938 , 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 2000er 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 2013 zum Erfolg .
+Im Jahr 2009 unterzeichneten rund 30.000 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 10. September 2009 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 2012 weigerte sich die Regierung von Browns Nachfolger David Cameron , 49.000 Homosexuelle , die nach dem Criminal Law Amendment Act von 1885 verurteilt worden waren , postum zu rehabilitieren .
+Im Jahr 2013 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 1960er 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 24. Dezember 2013 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 2016 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 2015 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. 500.000 Personen unterschrieben und sollte von Turings Großneffen Nevil Hunt und der Großnichte Rachel Barns überreicht werden .
+Am 21. Oktober 2016 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 31. Januar 2017 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 16 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 Datei : Turing statue Surrey.jpg Am 2. März 1999 wurde der Asteroid ( 10204 ) Turing nach ihm benannt .
+Eine Turing-Statue wurde am 23. Juni 2001 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 50. Todestag , dem 7. Juni 2004 , 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 19. Juni 2007 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 2012 “ fanden zu Alan Turings hundertstem Geburtstag weltweit Veranstaltungen zur Würdigung seiner Leistungen und zum Gedenken daran statt .
+Im Jahr 2014 wurde er in die Hall of Honor ( Ehrenhalle ) des US-Geheimdienstes NSA ( National Security Agency ) aufgenommen .
+Verschiedenes Datei : Turing Plaque.jpg
+Alan Turing war ein hervorragender Langstreckenläufer .
+Von 1946 an startete er bei Wettkämpfen für den Walton Athletic Club . Bei den englischen Meisterschaften im Marathon 1947 wurde er Fünfter in 2:46 : 03 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 1948 in London qualifizierte .
+1950 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 1947 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 .
+2012 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 2000er Jahre von Achim Clausing zwei Originaldrucke der bedeutendsten Veröffentlichungen Turings im Nachlass von Heinrich Scholz entdeckt , wovon eine seit 1945 verschollen gewesen war . Es handelt sich um die Arbeit On Computable Numbers , with an Application to the „ Entscheidungsproblem “ von 1936 , 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 1950 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 Sotheby ’ s wurden vergleichbare Drucke Turings , die keine Widmung aufwiesen , für 180.000 Euro versteigert .
+2017 wurde eine bis dahin unbekannte Sammlung von 147 Briefen von Turing entdeckt .
+Eine weitere Sammlung mit 141 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 1949 bis 1954 .
+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 2019 gab die Bank of England bekannt , dass auf der ab Ende 2021 in Umlauf kommenden neuen 50-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
+Patente 1950 : 1951 : Literatur ( Auswahl ) Theorie und Diskussion David J. Bolter : Turing ´ s Man. Western Culture in the Computer Age .
+University of South Carolina Press , Chapel Hill 1984 , ISBN 0-8078-4108-0 . S. Barry Cooper , Jan van Leeuwen ( Hrsg. ) : Alan Turing : His Work and Impact . Elsevier , New York NY 2013 , ISBN 978-0-12-386980-7 . Jack Copeland , Jonathan Bowen , Mark Sprevak u. Robin Wilson ( Hrsg. ) : The Turing Guide .
+Oxford University Press , Oxford 2017 , ISBN 978-0-19-874783-3 . Juliet Floyd , Alisa Bokulich ( Hrsg. ) : Philosophical Explorations of the Legacy of Alan Turing .
+Turing 100.
+Springer , Berlin 2017 , ISBN 978-3-319-53280-6 . ( = Boston Studies in the History of Science 324 ) Geschichte und Biographie George Dyson : Turing ’ s Cathedral .
+The Origins of the Digital Universe .
+Pantheon , 2012 , ISBN 978-0-375-42277-5 . Turings Kathedrale : Die Ursprünge des digitalen Zeitalters . Propyläen Verlag , Berlin 2014 , ISBN 978-3-549-07453-4 . Francis Harry Hinsley , Alan Stripp : Codebreakers – The inside story of Bletchley Park . Oxford University Press , Reading 1993 , ISBN 0-19-280132-5 . Andrew Hodges : Alan Turing – The Enigma . Burnett Books , London , und Simon and Schuster , New York 1983 , Vintage , New York 1992 , ( Biografie ) . Alan Turing – Enigma .
+Kammerer und Unverzagt , Berlin 1989 , 2. Auflage Springer 1994 , ISBN 3-211-82627-0 . David Leavitt : The Man Who Knew Too Much .
+Alan Turing and the Invention of the Computer .
+W W Norton & Co , 2006 , ISBN 0-393-32909-7 . Dermot Turing : Alan Turing – The Life of a Genius . The History Press , 2017 , ISBN 978-1841657561 Prof – Alan Turing Decoded . Pavilion Books , 2015 , ISBN 978-1841656434 Gordon Welchman : The Hut Six Story – Breaking the Enigma Codes . Allen Lane , London 1982 ; Cleobury Mortimer M&M , Baldwin Shropshire 2000 , ISBN 0-947712-34-8 . Belletristik Rolf Hochhuth : Alan Turing .
+Erzählung .
+Rowohlt , Reinbek 1987 , ISBN 3-499-22463-1 . David Lagercrantz : Der Sündenfall von Wilmslow .
+Übersetzung aus dem Schwedischen Wolfgang Butt .
+Piper , München 2015 ( zuerst 2009 ) Wolf Schneider : Große Verlierer .
+Von Goliath bis Gorbatschow .
+Rowohlt , Reinbek 2004 , ISBN 3-498-06365-0 ( darin enthalten ein Kapitel über Alan Turing ) .
+Neal Stephenson : Cryptonomicon .
+Goldmann 2001 , ISBN 3-442-54529-3 . ( Originalausgabe New York 1999 . ) Robert Harris : Enigma .
+Heyne , München 1996 , ISBN 978-3-453-11593-4 . ( Englische Originalausgabe 1995 . ) Filme ( Auswahl ) 1996 : Breaking the Code . ( Der codierte Mann ) .
+Fernsehfilm-Biographie , Großbritannien , 90 : 46 Min. , Buch : Hugh Whitemore , Regie : Herbert Wise , Produktion : BBC , mit Derek Jacobi als Turing , online-Video .
+2001 : Enigma – Das Geheimnis . Regie : Michael Apted .
+Dieser Film basiert auf dem Roman Enigma des britischen Autors Robert Harris aus dem Jahre 1995 . 2011 : Codebreaker .
+Doku-Drama , Großbritannien , Buch : Craig Warner , Regie : Clare Beavan , Nic Stacey , Produktion : Channel 4 , 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
+, Erstsendung : 4. Juni 2014 , – Inhaltsangabe .
+2014 : Der Fall Alan Turing oder Wie ein Mathegenie Hitler knackte . ( OT : La drôle de guerre d'Alan Turing ou Comment les maths ont vaincu Hitler . ) Dokumentarfilm , Frankreich , 2014 , 59 : 56 Min. , Buch und Regie : Denis van Waerebeke , Produktion : Les Films d ’ ici , arte France , Off World , RTBF , Erstsendung : 6. Juni 2014 bei arte , Inhaltsangabe von arte , online-Video .
+2014 : The Imitation Game . Doku-Drama , Großbritannien , 2014 , 89 :3 0 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 , 2014 . 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 – turing.org.uk ( englisch ) The Turing Archive for the History of Computing – alanturing.net ( englisch ) The Turing Digital Archive . In : University of Cambridge ( englisch ) Genial & geheim – Alan Turing in 10 Etappen . In : Heinz Nixdorf MuseumsForum , Sonderausstellung zum 100.
+Geburtstag von Alan Turing , 2012 Artikel
+André Schulz : Turing und Schach . In : Schach Nachrichten , 7. Juni 2004 Stefan Betschon : Turingmaschine im Rückwärtsgang . In : Neue Zürcher Zeitung , 18. Januar 2012 ; zum 100.
+Geburtstag von Alan Turing Einzelnachweise Alan Turing : Colleagues share their memories . In : BBC News , 23. Juni 2012 . alphabetische Mitgliederliste der Royal Society ( PDF ; 1,1 MB ) , abgerufen am 18. Juli 2012.Andrew Hodges : Alan Turing – a short biography . In : turing.org , 1995 . Alan Turing : Manchester celebrates pardoned genius . In : BBC News , 24. Dezember 2013 , abgerufen am 25. Dezember 2013.Caroline Davies : Enigma Codebreaker Alan Turing receives Royal Pardon . In : The Guardian , 24. Dezember 2013.Friedhelm Greis : Homosexualität . Queen begnadigt Alan Turing . In : golem.de , 27. Dezember 2013 . Royal pardon for codebreaker Alan Turing . In : BBC News , 24. Dezember 2013 , abgerufen am 25. Dezember 2013.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. 6 , 2012 , Themenheft Digitales Glück.André Schulz : Die goldene Gans , die niemals schnattert . In : Schach Nachrichten , 7. Juni 2004 , über Turing und Schach.Boris Mayer : Kein Code war ihm zu schwer . In : Jungle World , 28. Juni 2012 , Nr. 26 ; abgerufen am 19. August 2017 . In : BBC News , 5. Juni 2014 ; abgerufen am 7. Juni 2014 . to seep through sth. In : reverso.net , Collins Wörterbuch online , siehe unten , unter den Beispielen , aufgerufen 18. Februar 2015 . N / A Thousands call for Turing apology . In : BBC News , 31. August 2009.Felix Knoke : Netzweltticker . Briten fordern Entschuldigung an Computer-Pionier Turing . In : SpOn , 1. September 2009.Werner Pluta : Alan Turing . Späte Rehabilitierung für den Computerpionier . In : golem.de , 23. Juli 2013 , abgerufen am 23. Juli 2013Nicholas Watt : Enigma codebreaker . Alan Turing to be given posthumous pardon . In : The Guardian , 19. Juli 2013 , abgerufen am 23. Juli 2013 . Royal pardon for codebreaker Alan Turing . In : BBC News , 24. Dezember 2013 ; abgerufen am 23. März 2013 . Katholische Nachrichten-Agentur ( KNA ) / dpa : Schwule sollen rehabilitiert werden . In : Badische Zeitung , 24. Februar 2015.Owen Bowcott : UK issues posthumous pardons for thousands of gay men . In : The Guardian , 31. Januar 2017 , abgerufen am 1. Februar 2017 . Fotos : Die Turing-Statue in Bletchley Park . In : whudat.de , 31. August 2011 . Turing-Jahr 2012 . In : Gesellschaft für Informatik , 2012 , abgerufen am 19. August 2017.Chris Christensen : Review of IEEE Milestone Award to the Polish Cipher Bureau for “ The First Breaking of Enigma Code ” . In : Cryptologia , 15. April 2015 , S. 192 , doi : 10.1080/01611194.2015.1009751 , bezahlpflichtig . I. E. G. Green : In isolation and autonomy : the marathon ambition of a computer genius , Alan Turing . In : Track Stats , September 2009 , ( englisch ) . Pat Butcher : In Praise of Great Men . In : globerunner.org 14. September 2009 , ( englisch ) . John Graham-Cumming : An Olympic honour for Alan Turing . In : The Guardian , 10. März 2010 , ( englisch ) . He [ Steve Jobs ] replied that he wished he had thought of that , but hadn ’ t. In : Walter Isaacson : Steve Jobs . 2011.Holden Frith : Unraveling the tale behind the Apple logo . In : CNN , 7. Oktober 2011 , ( englisch ) . Heinz Billing : Ein Leben zwischen Forschung und Praxis . Selbstverlag F. Genscher , Düsseldorf 1997 , S. 156 ; wiedergegeben nach Herbert Bruderer : Konrad Zuse und die Schweiz : Wer hat den Computer erfunden ? Oldenbourg Wissenschaftsverlag , München 2012 , ISBN 978-3-486-71665-8 , S. 64 , ( online ) . Hans-Heinrich Pardey : Genial und schrullig . In : Frankfurter Allgemeine Sonntagszeitung , 15. Januar 2012 , Artikelanfang.Laura Döing : Die geheimen Taten des Alan Turing . In : Deutsche Welle , 29. Januar 2012.Elmar Ries : Auf den Spuren eines Pioniers : In der Unibibliothek Münster liegen Sonderdrucke des Informatikers Alan Turing . In : Westfälische Nachrichten , 28. Januar 2013 , abgerufen am 9. Dezember 2013 . Josh Halliday : In : The Guardian , 27. August 2017 , abgerufen am 27. August 2017 Alan Turing Papers ( Additional ) im Archiv der Universität ManchesterConcert : A Man From The Future . In : Pet Shop Boys , 24. April 2014.Teresa Dapp : Musikalische Verneigung vor Alan Turing . In : dpa / Mittelbayerische Zeitung , 24. Juli 2014 . 
+
+Datei : Tommarp kloster 02.JPG Datei : Scale drawing underwater.jpg Datei : Arrow and spear heads - from-DC1.jpg Datei : 2006 5. Kampagne Sommer Bild 2 Keramikofen.jpg 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 2,5 Millionen Jahren bis in die nähere Gegenwart .
+Aufgrund neuer Funde in Afrika , die etwa 3,3 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 1450 , weil man Zeugnisse für die in den Quellen der Antike geschilderten Ereignisse finden wollte . Cyriacus von Ancona ( * um 1391 ; † um 1455 ) , 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 15. und 16. 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 16. 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 16. Jahrhundert vielfach mit Kupferstichen und Holzschnitten illustriert werden .
+In England veröffentlicht William Camden ( 1551–1632 ) im Jahre 1586 seine Britannia , einen Katalog der sichtbaren Altertümer .
+Bemerkenswert ist , dass er bereits Bewuchsmerkmale in Kornfeldern bemerkt und als solche interpretiert .
+Michele Mercati ( 1541–1593 ) gilt als der erste europäische Gelehrte , der Steinwerkzeuge als solche einstufte ; sein Werk wird jedoch erst 1717 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 4004 v. Chr. entstand .
+1655 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 .
+Datei : Sepulture de Cocherel.JPG Datei : Jättakullen , den 22 juli 2006 , bild 3.JPG In Skandinavien werden Bodendenkmäler schon früh beachtet .
+Bereits 1588 gräbt man einen Dolmen bei Roskilde aus .
+Im Jahre 1662 erhält Uppsala einen Lehrstuhl für Altertumskunde .
+1685 wird in Houlbec-Cocherel in Nordfrankreich eine neolithische Grabkammer ausgegraben .
+Sie gilt als die älteste archäologische Grabung , weil hier 1722 der erste erhaltene Grabungsbericht erstellt wurde .
+Der Kieler Professor Johann Daniel Major führt um 1690 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 L ’ Antiquité expliquée erscheint ab 1719 .
+In zehn Bänden stellt er Kunstgegenstände aus dem Mittelmeerraum dar .
+Montfaucons Werk bleibt für lange Zeit das Standardwerk .
+Mitte des 18. bis Mitte des 19. 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 20 Jahre später , durch die Bestätigung Charles Lyells ( 1797–1875 ) , 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 1836 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 30 Jahre später , um 1865 , unterschied J. Lubbock die Steinzeit noch in die des geschlagenen und die des geschliffenen Steins .
+Die Begriffe „ Paläolithikum “ ( Altsteinzeit ) und „ Neolithikum “ ( „ Neusteinzeit “ / Jungsteinzeit ) waren geboren .
+Die Epochen sind in sich vielfach untergliedert , aber die damals gefundene Unterteilung gilt – mit Einschränkungen – bis heute .
+Datei :Po mpeji um 1900 ueberblick.jpg
+Die ersten großen Ausgrabungen fanden in den antiken Städten Pompeji und Herculaneum statt .
+Beide waren am 24. August 79 n. Chr. durch den Ausbruch des Vesuvs ausgelöscht worden .
+Pompeji wurde Ende des 16. Jahrhunderts beim Bau einer Wasserleitung wiederentdeckt .
+1748 begannen die Grabungen .
+In Herculaneum wurde erstmals 1709 gegraben , 1738 ließ Karl III .
+von Neapel die Stadt gezielt ausgraben .
+1768 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 1762 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 .
+1802 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 17. Jahrhundert hatte sich die Erkenntnis durchgesetzt , dass es sich hierbei um Königsgräber handelt .
+Die Ägyptologie nahm mit Napoléon Bonapartes Ägypten-Feldzug 1798 ihren Anfang .
+In Begleitung des Heeres befanden sich auch Wissenschaftler .
+Von besonderer Bedeutung ist der Fund des Steins von Rosetta , welcher 1822 Jean-François Champollion die Entzifferung der Hieroglyphen ermöglichte .
+Von besonderer Bedeutung für die ägyptische Archäologie ist Auguste Mariette ( 1821–1881 ) , welcher ab 1858 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 , 1778–1823 ) , welche zuvor zahllose Funde nach Europa geschafft hatten .
+Mariette selbst hat seit 1850 rund 7000 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 ( 1810–1884 ) erstellte zwischen 1842 und 1845 eine umfassende Aufnahme ägyptischer und nubischer Denkmäler .
+1859 wurde das Ergebnis in den zwölf Bänden der Denkmaeler aus Aegypten und Aethiopien veröffentlicht , welche allein 894 Farbtafeln enthalten .
+Um die archäologische Erforschung Griechenlands machte sich um 1840 besonders Ludwig Ross verdient , der als erster systematische Ausgrabungen auf der Akropolis von Athen durchführte .
+Ab Mitte des 19. Jahrhunderts Mitte des 19. 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 ( 1716–1758 ) hat bereits 1738 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 ( 1788–1865 ) , welcher erstmals ein Museum ( 1819 ) nach diesem Prinzip ordnet .
+Sir John Lubbock ( 1834–1913 ) führt 1865 eine weitere Unterteilung der Steinzeit in Paläolithikum ( Altsteinzeit ) und Neolithikum ( Jungsteinzeit ) ein .
+Erst ab 1859 wird das hohe Alter der Menschheit allgemein anerkannt .
+Im selben Jahr erscheint Darwins Über die Entstehung der Arten .
+Der bereits 1856 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 1902 durchsetzen , als Rudolf Virchow stirbt , der als pathologische Autorität jede weiterführende Diskussion unterbunden hatte .
+In Schweden entwickelt Oscar Montelius ( 1843–1921 ) ein System der differenzierten Typologie zur Einordnung ( Periodisierung ) von Fundstücken und schafft die Grundlage einer relativen Chronologie .
+1853/54 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 1920er 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 5 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 ) .
+1846 beginnen die Ausgrabungen in Hallstatt .
+Die archäologische Erforschung der Kelten beginnt 1858 , als Oberst Schwab die ersten Ausgrabungen in La Tène am Neuenburgersee ( Schweiz ) durchführt .
+1872 wird die Eisenzeit Europas erstmals in eine ältere Phase ( Hallstattzeit ) und einer jüngeren ( Latènezeit ) unterteilt .
+Édouard Lartet ( 1801–1871 ) untersucht 1860 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 d ’ Enfer , Laugerie Haute , La Madeleine und Le Moustier ) aus .
+Besondere Aufmerksamkeit erlangen die großartigen Höhlenmalereien , welche 1879 in der Höhle von Altamira entdeckt werden .
+Die Entwicklung der Klassischen Archäologie in der zweiten Hälfte des 19. Jahrhunderts wird von Heinrich Schliemann ( 1822–1890 ) dominiert .
+Der Geschäftsmann und „ Hobbyarchäologe “ Schliemann gilt als Begründer der Vorgeschichtsarchäologie Griechenlands und des ägäischen Raumes .
+1869 gräbt er auf Ithaka und 1871 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 .
+1892 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 .
+20. und 21. Jahrhundert Datei : Howard carter.jpg Datei : Barzan.jpg In Ägypten leistet ab 1880 Sir William Matthew Flinders Petrie ( 1853–1942 ) als Forscher und Ausgräber Pionierarbeit .
+Ein Meilenstein der archäologischen Forschung sind seine Methoden und Ziele der Archäologie , die er 1904 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 1913 erscheint der erste Band des Handbuchs der Archäologie , Herausgeber ist Heinrich Bulle ( 1867–1945 ) .
+Als vorbildliche Grabung dieser Zeit gilt die 1922 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 20. Jahrhunderts gelingt Howard Carter ( 1873–1939 ) 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 ( 1858–1931 ) stellt 1920 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 1927 in Marburg geschaffen und im folgenden Jahr mit Gero Merhart von Bernegg aus Bregenz besetzt .
+Er hatte sich 1924 mit Die Bronzezeit am Jenissei habilitiert .
+Bei ihm promovierten bis zu seiner Zwangspensionierung durch die Nationalsozialisten im Jahr 1942 29 Studenten , nach dem Krieg kamen fünf weitere hinzu .
+Ab 1950 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 1947 mit einem Floß von Südamerika nach Polynesien und kann als einer der Begründer der Experimentellen Archäologie betrachtet werden .
+Im 20. Jahrhundert greift die Archäologie vermehrt auf Techniken anderer Wissenschaften zurück .
+Als Beispiele seien die 1949 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 1991 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 40 Individuen aus einer bronzezeitlichen Begräbnisstätte in der Lichtensteinhöhle rekonstruiert werden .
+Die New Archaeology der 1960er 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 1980er 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 21. 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 2011 in Agypten und in Libyen , 2013 in Syrien , 2014 in Mali bzw. im Irak und seit 2015 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 2,5 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
+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
+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 2. Jahrtausend v. Chr. und dem 5. 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 9. Jahrhundert ) und endet theoretisch mit dem Übergang zur Neuzeitarchäologie ( ca. 16. 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
+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 3. Jahrtausend v. Chr. bis 4. 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
+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 11. Jahrtausend v. Chr.
+bis zum 7. 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 Datei : Vorgeschichtlicher korb.jpg
+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
+Schlachtfeldarchäologie ( Zeithorizont : Bronzezeit bis 20. 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
+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
@@ -9589,252 +6249,171 @@
 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
+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 Datei : Archäologie schichtengrabung.jpg 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 1991 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 Datei :D endrochronologie.jpg 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 ?
+J. J.
+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
+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 ( 1743–1826 ) , welcher ab 1784 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 19. Jahrhunderts im Mayazentrum Copán durchgeführt .
+1911 entdeckt Hiram Bingham die Inkastadt Machu Picchu .
+Im Jahre 1990 fanden Archäologen in der Nähe von Mexiko-Stadt über 10.000 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 1863 wird in Indien die Archaeological Survey of India gegründet .
+1921/1922 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 ( 1874–1960 ) , der 1921 bei Yang Shao Tsun in Honan eine neolithische Wohnhöhle entdeckt und damit beweist , dass China in vorgeschichtlicher Zeit bewohnt war .
+1928 wird Anyang ausgegraben , die Hauptstadt der Shang-Dynastie des 2. Jahrtausends v. Chr.
+1974 wird die Terrakottaarmee rund um das Grab des chinesischen Kaisers Qin Shihuangdi bei Xi ’ an 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 2,5 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 3,3 Millionen Jahre alte Funde in Lomekwi 3 , Kenia , werden als Beleg für eine eigenständige archäologische Kultur interpretiert , vorschlagsweise Lomekwian genannt .
+Bereits seit dem 17. 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 600 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 2019 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 1986 ( 4. Neuaufl .
+scrîpvaz , Berlin 2004 ) .
+ISBN 3-931278-08-5 ( Nachdruck des Werks von 1959 , daher nur die traditionellen Methoden , neue Ansätze fehlen ) .
+Johannes Bergemann : Orientierung Archäologie – was sie kann , was sie will . Rowohlt , Reinbek bei Hamburg 2000 .
+ISBN 3-499-55612-X ( Klassische Archäologie ) .
+Colin Renfrew , Paul G. Bahn : Archaeology – Theories , Methods and Practice .
+5. Auflage , London 2005 , ISBN 978-0-500-28719-4 ( gute englischsprachige Einführung ) ; gekürzte deutsche Übersetzung von Helmut Schareika : Basiswissen Archäologie .
+Theorien – Methoden – Praxis
+, Philipp von Zabern , Mainz 2009 , ISBN 978-3-8053-3948-3 . 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
+.
+( 4. überarb .
+Aufl. UTB Francke , Tübingen , Basel 2008 ) .
+ISBN 978-3-8252-3696-0 . Manfred K. H. Eggert , Stefanie Samida : Ur- und frühgeschichtliche Archäologie ( 2. Aufl. UTB , Tübingen 2013 ) .
+ISBN 978-3-8252-3890-2 . Barbara Scholkmann – Hauke Kenzler – Rainer Schreg ( Hrsg. ) , Archäologie des Mittelalters und der Neuzeit .
+Grundwissen , Darmstadt : Wiss. Buchgesellschaft 2016 , ISBN 9783534268115 Überblick Paul G. Bahn ( Hrsg. ) : Archaeology .
+Cambridge Illustrated History .
+Cambridge University Press , Cambridge 1996 .
+ISBN 0-521-45498-0 . Reinhard Bernbeck : Theorien in der Archäologie ( UTB Wissenschaft Band 1964 ) .
+Francke Verlag , Tübingen , Basel 1997 , ISBN 3-8252-1964-X , ISBN 3-7720-2254-5 . Marion Benz , Christian Maise : Archäologie . Theiss , Stuttgart 2006 .
+ISBN 3-8062-1966-4 . Manfred K. H. Eggert : Archäologie .
+Grundzüge einer Historischen Kulturwissenschaft .
+Francke , Tübingen 2006 .
+ISBN 3-8252-2728-6 . Der Brockhaus Archäologie .
+Hochkulturen , Grabungsstätten , Funde .
+F. A.
+Brockhaus , Mannheim / Leipzig 2008 , ISBN 978-3-7653-3321-7 . 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
+( aus dem Französischen von Andreas Wittenburg ) .
+Klett-Cotta , Stuttgart 2009 , ISBN 978-3-608-93359-8 ( Rezension von Lutz Bunk Archäologische Detektivarbeit ) .
+Jeorjios Martin Beyer : Archäologie .
+Von der Schatzsuche zur Wissenschaft .
+Philipp von Zabern , Mainz 2010 , ISBN 978-3-8053-4166-0 . Matthias Knaut , Roland Schwab ( Hrsg. ) : Archäologie im 21. Jahrhundert .
+Innovative Methoden – bahnbrechende Ergebnisse .
+Konrad Theiss , Stuttgart 2010 , ISBN 978-3-8062-2188-6 . Geoffrey John Tassie , Lawrence Stewart Owens : Standards of Archaeological Excavations : A Fieldguide to the Methology , Recording Techniques and Conventions , London 2010 , ISBN 978-1-906137-17-5 . Marco Kircher : Wa ( h ) re 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 2012 , ISBN 978-3-8376-2037-5 . Aedeen Cremin : Große Enzyklopädie der Archäologie .
+Die wichtigsten archäologischen Stätten der Welt .
+Konrad Theiss , Stuttgart 2013 , ISBN 978-3-8062-2753-6 . Bruce Trigger : A History of Archaeological Thought .
+Cambridge University Press , Cambridge 1990 .
+ISBN 0-521-33818-2 . 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 3 Beier & Beran , Wilkau-Hasslau 1993 Archäologie in Deutschland Martin Kuckenburg : Siedlungen der Vorgeschichte in Deutschland , 300 000 bis 15 v. Chr. DuMont , Köln 1994 .
+ISBN 3-7701-2922-9 . Wilfried Menghin , Dieter Planck ( Hrsg. ) : Menschen Zeiten Räume Archäologie in Deutschland . Theiss , Stuttgart 2002 .
+ISBN 3-8062-1596-0 . Uta von Freeden , Siegmar von Schnurbein ( Hrsg. ) : Spuren der Jahrtausende .
+Archäologie und Geschichte in Deutschland .
+Theiss , Stuttgart 2003 .
+ISBN 3-8062-1337-2 ( 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 , Frankfurt / Main 2000 .
+ISBN 3-88059-979-3 . 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 1877 , Reprint der Originalausgabe durch Reprint-Verlag Leipzig 2001 , ISBN 3-8262-1513-3 Online-Publikationen Guido Nockemann : The DAS Project – Digitization of an archaeological collection , 2011 , e-paper for the Day Of Archaeology 2011 ( 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
+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
+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
+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
+Archäologiemuseen bei webmuseen.de
+www.exar.org 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übingen / Basel 2006 , UTB 2728 Hansjürgen Müller-Beck : Die Steinzeit – Der Weg der Menschen in die Geschichte . C. H. Beck , München 2008 , S. 22. Vgl. Homepage des U. S. Committee of the Blue Shield ; abgerufen am 26. Oktober 2016 . Isabelle-Constance v. Opalinski : Schüsse auf die Zivilisation . In : FAZ , 20. August 2014 . Hans Haider : Missbrauch von Kulturgütern ist strafbar . In : Wiener Zeitung , 29. Juni 2012 ; Aisling Irwin : A no-strike list may shield Yemen`s ancient treasures from war . In : New Scientist . Daily news vom 23. Januar 2017 ( abgerufen am 17. September 2017 ) . Jyot Hosagrahar : Culture : at the heart of SDGs . UNESCO-Kurier , April–Juni 2017 . Rick Szostak : The Causes of Economic Growth : Interdisciplinary Perspectives . Springer Science & Business Media , 2009 , ISBN 9783540922827 . Corine Wegener , Marjan Otter : Cultural Property at War : Protecting Heritage during Armed Conflict . In : The Getty Conservation Institute , Newsletter 23.1 , Spring 2008 
+
+Der ( ASCII , alternativ US-ASCII , oft [ ] ausgesprochen , ) ist eine 7-Bit-Zeichenkodierung ; sie entspricht der US-Variante von ISO 646 und dient als Grundlage für spätere , auf mehr Bits basierende Kodierungen für Zeichensätze .
+Der ASCII-Code wurde zuerst am 17. Juni 1963 von der American Standards Association ( ASA ) als Standard ASA X3.4-1963 gebilligt und 1967/1968 wesentlich sowie zuletzt im Jahr 1986 ( ANSI X3.4-1986 ) von ihren Nachfolgeinstitutionen aktualisiert und wird bis heute noch benutzt .
+Die Zeichenkodierung definiert 128 Zeichen , bestehend aus 33 nicht druckbaren sowie 95 druckbaren Zeichen .
+Druckbare Zeichen sind , beginnend mit dem Leerzeichen : ! " # $ % & ' ( ) * + , - . / 0123456789 : ; < => ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ [ \ ] ^_` abcdefghijklmnopqrstuvwxyz { | } ~ lateinische Alphabet
 arabischen Ziffern
 Interpunktionszeichen
 Satzzeichen
@@ -9844,157 +6423,3578 @@
 Schreibmaschine
 englische Sprache
 abwärtskompatibel
-ISO <num>
+ISO 8859
 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
+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 7 Bit zugeordnet .
+Da jedes Bit zwei Werte annehmen kann , gibt es 27 = 128 verschiedene Bitmuster , die auch als die ganzen Zahlen 0–127 ( hexadezimal 00h–7Fh ) 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 8-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 32 ASCII-Zeichencodes ( von 00hex bis 1Fhex ) 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 20hex ( 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 21hex bis 7Ehex 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 7Fhex ( 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 00hex ) fanden sich vor allem am Anfang und Ende eines Lochstreifens ( NUL ) .
+Aus diesem Grund gehörten zum eigentlichen ASCII nur 126 Zeichen , denn den Bitmustern 0 ( 0000000 ) und 127 ( 1111111 ) entsprachen keine Zeichencodes .
+Der Code 0 wurde später in der Programmiersprache C als „ Ende der Zeichenkette “ interpretiert ; dem Zeichen 127 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 5-Bit-Murray-Code zum 7-Bit-ASCII war es dann nur noch ein kleiner Schritt – auch ASCII wurde zuerst für bestimmte amerikanische Fernschreibermodelle , wie den Teletype ASR33 , eingesetzt .
+Die erste Version , noch ohne Kleinbuchstaben und mit kleinen Abweichungen vom heutigen ASCII bei den Steuer- und Sonderzeichen , entstand im Jahr 1963 .
+1968 wurde dann die bis heute gültige Fassung des ASCII-Standards festgelegt . Diese Fassung gebar die Caesar-Verschlüsselung ROT47 als Erweiterung von ROT13 .
+Während ROT13 nur das lateinische Alphabet um dessen halbe Länge rotiert , rotiert ROT47 alle ASCII-Zeichen zwischen 33 ( ! ) und 126 ( ~ ) .
+Computer In den Anfängen des Computerzeitalters entwickelte sich ASCII zum Standard-Code für Schriftzeichen .
+Zum Beispiel wurden viele Terminals ( VT100 ) und Drucker nur mit ASCII angesteuert .
+Für die Kodierung lateinischer Zeichen wird fast nur bei Großrechnern die zu ASCII inkompatible 8-Bit-Kodierung EBCDIC verwendet , die IBM parallel zu ASCII für sein System/360 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 1968 gestützt , es in den Regierungsbüros zu verwenden .
+Verwendung für andere Sprachen Mit dem Internationalen Alphabet 5 ( IA5 ) wurde 1963 eine 7-Bit-Codierung auf Basis des ASCII als ISO 646 normiert .
+Die Referenzversion ( ISO 646-IRV ) entspricht dabei bis auf eine Position dem ASCII .
+Um Buchstaben und Sonderzeichen verschiedener Sprachen darstellen zu können ( beispielsweise die deutschen Umlaute ) , wurden 12 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 646 verwendet .
+Die Kombinationen sind sprachspezifisch .
+So entspricht bei Pascal ( * und * ) den geschweiften Klammern ( { } ) , während C und dafür vorsieht .
+Erweiterungen Nutzung der übrigen 128 Positionen im Byte Zur Überwindung der Inkompatibilitäten nationaler 7-Bit-Varianten von ASCII entwickelten zunächst verschiedene Hersteller eigene ASCII-kompatible 8-Bit-Codes ( d. h.
+solche , die auf den ersten 128 Positionen mit ASCII übereinstimmen ) .
+Der Codepage 437 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 3.3 die westeuropäische Codepage 850 der Standard .
+Auch bei späteren Standards wie ISO 8859 wurden acht Bits verwendet .
+Dabei existieren mehrere Varianten , zum Beispiel ISO 8859-1 für die westeuropäischen Sprachen , die in Deutschland als DIN 66303 übernommen wurde .
+Deutschsprachige Versionen von Windows ( außer DOS-Fenster ) verwenden die auf ISO 8859-1 aufbauende Kodierung Windows-1252 – daher sehen zum Beispiel die deutschen Umlaute falsch aus , wenn Textdateien unter DOS erstellt wurden und unter Windows betrachtet werden .
+Jenseits von 8 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 8-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 8-Bit-Erweiterungen ist aber „ ASCII “ , denn das bezeichnet nur den einheitlichen 7-Bit-Code .
+Um den Anforderungen der verschiedenen Sprachen gerecht zu werden , wurde der Unicode ( in seinem Zeichenvorrat identisch mit ISO 10646 ) entwickelt .
+Er verwendet bis zu 32 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-8 ist eine 8-Bit-Kodierung von Unicode , die zu ASCII abwärtskompatibel ist .
+Ein Zeichen kann dabei ein bis vier 8-Bit-Wörter einnehmen .
+Sieben-Bit-Varianten müssen nicht mehr verwendet werden , dennoch kann Unicode auch mit Hilfe von UTF-7 in sieben Bit kodiert werden .
+UTF-8 entwickelte sich zum Standard unter vielen Betriebssystemen .
+So nutzen unter anderem Apples macOS sowie einige Linux-Distributionen standardmäßig UTF-8 , und mehr als 90 % der Websites werden in UTF-8 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 0 … 127 den gleichen Code verwenden wie ASCII und den Bereich über 127 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 8859 mit 15 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.
+437 , 850 ) und Windows-Codepages ( z. B.
+Windows-1252 ) KOI8-R für Russisch und KOI8-U für Ukrainisch ARMSCII-8 und ARMSCII-8a 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
+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 0 bis 127 in einem Byte kodiert , andere Zeichen werden durch mehrere Bytes mit Werten von über 127 kodiert : UTF-8 und GB 18030 für Unicode
+ISO 6937 für europäische Sprachen mit lateinischer Schrift Big5 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 1936 entdeckte Asteroid ( 3568 ) ASCII wurde 1988 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>
+Ausgaben American Standards Association : American Standard Code for Information Interchange .
+ASA X3.4-1963 .
+American Standards Association , New York 1963 ( ) American Standards Association : American Standard Code for Information Interchange .
+ASA X3.4-1965 .
+American Standards Association , New York 1965 ( genehmigt , aber nicht veröffentlicht ) United States of America Standards Institute : USA Standard Code for Information Interchange .
+USAS X3.4-1967 .
+United States of America Standards Institute , 1967 . United States of America Standards Institute : USA Standard Code for Information Interchange .
+USAS X3.4-1968 .
+United States of America Standards Institute , 1968 . American National Standards Institute : American National Standard for Information Systems .
+ANSI X3.4-1977 .
+1977 . American National Standards Institute : American National Standard for Information Systems .
+Coded Character Sets .
+7-Bit American National Standard Code for Information Interchange ( 7-Bit ASCII ) .
+ANSI X3.4-1986 .
+1986 . Weitere Revisionen : ANSI X3.4-1986 ( R1992 ) ANSI X3.4-1986 ( R1997 ) ANSI INCITS 4-1986 ( R2002 ) ANSI INCITS 4-1986 ( R2007 ) ANSI INCITS 4-1986 ( R2012 ) Literatur Jacques André : Caractères numériques : introduction . In : Cahiers GUTenberg . Band 26 , Mai 1997 , , S. 5–44 , ( französisch ) .
+Yannis Haralambous : Fonts & encodings .
+From Unicode to advanced typography and everything in between .
+Übersetzt von P. Scott Horne .
+O'Reilly , Beijing u. a. 2007 , ISBN 978-0-596-10242-5 ( englisch ) .
+Peter Karow : Digitale Schriften .
+Darstellung und Formate .
+2. verbesserte Auflage .
+Springer , Berlin u. a. 1992 , ISBN 3-540-54917-X . Mai-Linh Thi Truong , Jürgen Siebert , Erik Spiekermann ( Hrsg. ) : FontBook .
+Digital Typeface Compendium
+( = FontBook 4 ) .
+4. überarbeitete und erweiterte Auflage .
+FSI FontShop International , Berlin 2006 , ISBN 3-930023-04-0 ( in englischer Sprache ) .
+Weblinks IETF RFC 20 ( ANSI X 3.4-1968 ) ( englisch ) ITU T.50 ( 09/1992 ) International Alphabet No.5 ( englisch ) ISO / IEC 646 : 1991 ( englisch ) ASA X3.4-1963 ( englisch ) Erläuterungen zu den Steuerzeichen ( englisch ) ASCII Tabelle mit Erläuterungen ( deutsch ) Umwandlung von und zu Dezimale , Oktale , Hexadezimale und Binäre ASCII-Schreibweise ( englisch ) Einzelnachweise ( PDF ) w3techs.com Minor Planet Circ . 12973 ( PDF ) 
+
+Datei : ANKLE SPRAIN 02b.JPG Datei : Gray355.png Das Außenband des oberen Sprunggelenkes setzt sich zusammen aus drei Bändern ( der „ laterale Bandapparat “ ) : Ligamentum fibulotalare anterius und posterius sowie Ligamentum fibulocalcaneare .
+Beim Umknicken nach außen ( Supinationstrauma ) kommt es meist zur Zerrung oder zu einem Riss ( Ruptur ) des Lig.
+fibulotalare anterius
+oder / und des Lig.
+calcaneofibulare
+, seltener ist die komplette Ruptur aller drei Bänder .
+Eine Ruptur von mindestens einem dieser drei Bänder nennt man auch eine fibulare Bandruptur .
+Das Ligamentum fibulotalare anterius reißt am ehesten dann , wenn der Fuß zugleich gestreckt ( Plantarflexion ) und verdreht ( Inversion ) ist .
+Ist der Fuß bei einer Verdrehung angewinkelt ( Dorsalextension ) , bleibt dieses Band zumeist intakt .
+Bei Bänderrissen können die enormen Kräfte , die zugleich auf umliegende Weichteile und Knochen einwirken , zu Malleolarfrakturen oder zu knöchernen Bandausrissen ( Abrissfrakturen ) führen .
+Erste Hilfe Als Erste-Hilfe-Maßnahme bei einem vermuteten Bänderriss wird das Gelenk ruhiggestellt , gekühlt , vorsichtig bandagiert und hochgelagert ( PECH-Regel : „ Pause , Eis , Compression , Hochlagerung “ ) .
+Die PECH-Regel ist generell als geeignete Behandlungsmaßnahme akzeptiert , wenn auch die empirischen Belege für ihre Wirksamkeit unzureichend sind .
+Vermeintlich „ leichte “ Verletzungen werden von dem Betroffenen ebenso wie vom behandelnden Arzt oft unterschätzt .
+Wenn sie nicht angemessen diagnostiziert und behandelt werden , kann es zu wiederholten Verletzungen oder auch zu chronischer Gelenkinstabilität kommen , woraus sich weitere Schäden ergeben können .
+Laut der Leitlinien der DGU , ÖGU und DGOOC wird geschätzt , dass nur etwa die Hälfte der Patienten mit akuter Außenbandverletzung ärztliche Hilfe in Anspruch nimmt und somit adäquat behandelt wird .
+Diagnostik Bei der Diagnostik wird der Patient im Rahmen der Anamnese nach dem Hergang der Verletzung ( Unfallmechanismus , Sturz , Höhe , mechanische Kraft und Bewegungsrichtung des Fußes ) , nach der bisherigen Behandlung und nach früheren Verletzungen befragt , das Fußgelenk nach Schwellungen und Hämatomen untersucht , das Gangbild beurteilt und eine Untersuchung durch Palpation sowie spezifische Funktions- und Schmerztests durchgeführt .
+Hinzu kommen Röntgenaufnahmen und gegebenenfalls der Einsatz weiterer bildgebender Verfahren .
+Schubladentest Bei einer Verletzung der Außenbänder des oberen Sprunggelenks ist wegen der Wahl der richtigen Therapie vor allem die Frage wichtig , ob es sich um eine Bänderdehnung oder einen Bänderriss handelt .
+Geübten Untersuchern gelingt die Unterscheidung zwischen Bänderdehnung und Bänderriss in der Regel alleine mit dem Schubladentest , also ohne die Anfertigung von Röntgen-Bildern oder den Einsatz anderer gerätemedizinischer Untersuchungsmethoden : Für den vorderen Schubladentest liegt der Patient in Rückenlage .
+Der Untersucher umgreift mit einer Hand von unten die Ferse , mit der anderen Hand wird gefühlvoll von oben gegen das Schienbein gedrückt .
+Liegt lediglich eine Zerrung des vorderen Außenbandes vor , ist keine Schubladenbewegung möglich .
+Dagegen kann der Fuß bei einem Riss deutlich gegenüber dem Schien- und Wadenbein nach vorne ( bei liegendem Patienten nach oben ) aus dem Gelenk geschoben werden ( „ Talus ­ vorschub “ ) . Da sich die normale Schubladenbewegung im oberen Sprunggelenk im gesunden Zustand von Mensch zu Mensch stark unterscheidet , ist es wichtig , die Untersuchung zuvor am gesunden Sprunggelenk des anderen Beins durchzuführen .
+Auf diese Weise lässt sich herausfinden , welches Ausmaß der Schubladenbewegung beim betroffenen Menschen noch als nicht gerissen anzusehen ist .
+Die Stabilität der fibularen Seitenbänder wird auch durch die vertikalen Aufklappbarkeit getestet .
+Hierbei wird der Rückfuß gegen den fixierten Unterschenkel maximal nach innen gedrückt .
+Manche empfehlen , den Schubladentest beim Verdacht auf einen Außenbandriss nur innerhalb der ersten 48 Stunden nach der Verletzung durchzuführen , um nicht zu riskieren , dass sich im Falle eines Bänderrisses die frühen Verklebungen der Bänder wieder lösen .
+Sind mehr als 48 Stunden vergangen , solle man stattdessen von einem Riss ausgehen .
+Bildgebende Verfahren Zusätzlich können bildgebende Verfahren wie Röntgen sinnvoll sein , um einen Bruch ( Fraktur ) der angrenzenden Knochen auszuschließen .
+In seltenen Fällen kann zudem eine Magnetresonanztomographie ( MRT ) sinnvoll sein ; diese macht zugleich etwaige weitere Verletzungen ( etwa Kapselrisse , Gelenkergüsse oder Knochenprellungen ) sichtbar .
+Wie die Deutsche Gesellschaft für Ultraschall in der Medizin hervorhebt , kann ergänzend oder alternativ zur MRT die Sonografie eingesetzt werden , die es dem entsprechend qualifizierten Arzt erlaubt , Instabilitäten und Bänderrisse durch eine dynamische Untersuchung aufzuzeigen .
+Sehr in die Kritik geraten sind bei der Diagnosestellung die bis vor einiger Zeit üblichen sogenannten „ gehaltenen Röntgen-Aufnahmen “ . Dabei wird auf einem Röntgenbild festgehalten , wie weit sich das Gelenk mit einer fest definierten Kraft aufklappen lässt .
+Aus dem Aufklappwinkel , der im Röntgenbild eingezeichnet werden kann , wurde dann auf den Verletzungsgrad geschlossen .
+Der Grund für die Kritik ist , dass sich mit solchen gehaltenen Aufnahmen vor allem das mittlere Außenband überprüfen lässt , das allerdings nur sehr selten isoliert reißt , sondern fast immer nur in Kombination mit dem vorderen Außenband .
+Da für die Auswahl der Therapie vor allem die Frage wichtig ist , ob es sich um einen Riss oder eine Zerrung handelt , nicht aber ob ein oder zwei Bänder gerissen sind , reicht der Schubladentest , der das vordere Außenband überprüft , in den meisten Fällen als alleinige Untersuchung aus .
+Begleiterscheinungen Durch die enormen Kräfte , die beim Bänderriss auf umliegende Weichteile und Knochen einwirken , kann es zugleich zu Malleolarfrakturen oder zu knöchernen Bandausrissen ( Abrissfrakturen ) kommen , was zu einem freien Gelenkkörper und mitunter zu einem knöchernen Impingement des Gelenks führen kann .
+Außerdem können Außenbandrupturen ein Weichteil-Impingement am oberen Sprunggelenk verursachen , mit einer Einklemmung weichteiliger Strukturen ( entzündliche Gelenkinnenhaut , Kapselbandgewebe , Narbengewebe ) im Gelenk .
+Diese befinden sich zumeist in den vorderen und seitlichen Abschnitten des oberen Sprunggelenkes .
+Stören solche weichteiligen oder knöchernen Einklemmungen , werden sie eventuell arthroskopisch oder minimalinvasiv entfernt .
+Zudem ist ein Inversionstrauma die häufigste Ursache für das Sinus-tarsi-Syndrom .
+Behandlung Während noch vor einigen Jahren die Außenband ruptur regelhaft genäht wurde , ist heute bei gleich guten Behandlungsergebnissen die konservative Behandlung Standard .
+Denn da das Außenband in eine Gelenkkapsel eingebettet ist , kann es nach einer Ruptur auch ohne Operation zusammenwachsen . Nur bei kompletter Zerreißung aller drei Bänder und Operationswunsch ( z. B.
+Profisportler ) wird noch eine operative Behandlung empfohlen .
+Sowohl bei konservativer als auch bei operativer Therapie einer fibularen Bänderruptur fällt typischerweise eine mehrwöchtige Arbeitsunfähigkeit an .
+Konservative Behandlung In der Therapie des akuten Gelenktraumas können nicht-steroidale Entzündungshemmer ( NSAR ) eingesetzt und eine frühe Mobilisation des Gelenkes durchgeführt werden .
+Wie ein systematischer Review von 2008 zeigte , hat der Einsatz von NSAR , Beinwell-Salbe und manueller Therapie in einer frühen Phase nach der Verletzung zumindest kurzzeitig signifikant positive Auswirkungen auf die Funktionalität des Gelenkes . In Kombination mit anderen Therapien wie Krankengymnastik hat die manuelle Therapie auch längerfristig positive Auswirkungen auf die Heilung . Andererseits ist bekannt , dass NSAR auch Enzyme blockieren , die zur Heilung notwendig sind , und dass Patienten , deren Schmerzen unterdrückt werden , ihr Gelenk möglicherweise zu früh belasten . Krankengymnastik und manuelle Therapie sollen Schmerzen und Schwellungen verringern und die Funktion des Gelenkes wiederherstellen . Um einer chronischen Instabilität vorzubeugen , wird das Gelenk in der Akutphase mit Hilfe einer Schiene ruhiggestellt und in der Rehabilitationsphase physiotherapeutisch beübt ( Mobilisation des Gelenks , Balanceübungen ) . Ergänzend kann die Kryotherapie eingesetzt werden .
+Entzündliche , proliferative und remodellierende Phasen Bei der Behandlung in konservativer Therapie unterscheidet man mehrere Phasen der Heilung , deren Dauer von Fall zu Fall verschieden sein kann und die sich außerdem überlappen können : eine erste , mehrere Tage währende entzündliche Phase ( Phase I ) , eine etwa 5–28-tägige reparative oder proliferative Phase der Primärheilung ( Phase II ) , die durch Angiogenese , proliferierende Fibroblasten und Kollagenproduktion gekennzeichnet ist und eine vier- bis sechswöchige Umbau- bzw. remodellierende Phase ( Phase III ) in der die Kollagenfibrillen und Zellen der Bänder reifen .
+In Phasen I und II ist ein Schutz vor zu viel Belastung wichtig , um eine überschießende Produktion des Kollagens Typ III , und somit der Bildung eines elongierten weichen Bandes vorzubeugen ; in der Phase III hingegen ist eine allmähliche Zunahme der Belastung nötig , um die Bänder „ auszuhärten “ . Physiologische Belastungsreize während der Heilung eines Bänderrisses führen zu einer besseren Organisation des heilenden Gewebes und geringerer Narbenbildung .
+Bei der konservativen Therapie ist eine Schienung des Sprunggelenkes über sechs Wochen Standard , gegebenenfalls unter Verwendung von Unterarmgehstützen .
+Während dieser ersten circa sechs Wochen finden Umbauvorgänge statt , die sich den ersten mechanischen Belastungen anpassen . Teils wird für die ersten ca. 8 Tage ein Spaltgips in regelrechter Stellung verordnet , bis die Schwellung etwas abgeklungen ist .
+Es ist auch erprobt worden , Bänderverletzungen ergänzend innerhalb der ersten 48 Stunden nach der Verletzung mit Hyaluronsäure-Spritzen zu behandeln ; allerdings ist die empirische Datenlage zu dieser Methode noch gering ( Stand : 2011 ) .
+Liegt am Gelenk keine Schwellung ( mehr ) vor , wird normalerweise eine Orthese ( z. B. Aircast-Schiene ) eingesetzt .
+Sie stellt sicher , dass die gerissenen Bänder nicht belastet werden können und dass das Gelenk dennoch bewegt werden kann .
+Eine geeignete Orthese stabilisiert sowohl die Auswärtsdrehung ( Supination ) des Rückfußes als auch den Talusvorschub . Manche Orthesen verhindern nicht nur die Supination , sondern auch die Plantarflexion , was für die Anfangsphase als wichtig für die Heilung angesehen wird . Bei anderen wird die Beweglichkeit des Gelenks in horizontaler Richtung ( „ rauf / runter “ = Flexion / Extension ) kaum eingeschränkt , so dass zum Beispiel Spazieren oder Radfahren möglich sind .
+Sportmediziner raten dazu , spätestens 1–2 Tage nach dem Trauma ( oder nach einer Operation ) eine konsequente Schienung einzusetzen . Die Orthese wird zum Zweck der Stabilisierung Tag und Nacht getragen , da nachts der Muskeltonus nachlässt und der Fuß daher in eine ungünstige Haltung sacken könnte . Durch die nachlassende Spannung in der Nacht entstünde vor allem ein Zug auf das Ligamentum fibulotalare anterius und das Ligamentum fibulocalcaneare . Die Bänder wachsen durch das Tragen der Orthese eher belastungsgerecht zusammen , Probleme mit einem versteiften Gelenk , die bei kompletter Fixierung zu erwarten wären , werden vermieden .
+Als besonders günstig haben sich hierbei sogenannte modulare Orthesen erwiesen , die eine Anpassung der Bewegungsfähigkeit mit Orthese an den Heilungsverlauf ermöglichen .
+Ab der remodellierenden Phase kann der weitere Umbau von Bändern Monate bis Jahre dauern .
+Physikalische Therapie Bei der Außenbandruptur ist die physikalische Therapie ein Teil der konservativen Therapie .
+Wie bei anderen Bänderrissen auch geht es dabei u. a. um die Resorption eventueller Ödeme , die Verbesserung der Durchblutung , die Lösung von Verklebungen und den Erhalt der Beweglichkeit unter Beachtung ärztlicher Vorgaben .
+Hinzu kommen angepasste Übungen der Muskulatur und ggf. die Anleitung zur Verwendung von Gehstützen oder anderer Hilfsmittel .
+Die Leitlinien der DGU , ÖGU und DGOOC sehen für die Behandlung der Außenbandruptur nach einer initialen Phase mit Hochlagerung , Kryotherapie und elastische Wickelung isometrische Übungen in der Orthese vor .
+Im Verlauf der Behandlung wird häufig die manuelle Therapie eingesetzt , um die Beweglichkeit des Gelenkes zu verbessern . Die Leitlinien sprechen von limitierten , kurzzeitigen positiven Effekten der manuellen Therapie ; andere Studien zeigen auf , dass eine Lymphdrainage und manuelle Therapie zu einer verringerten Schwellung und größeren Beweglichkeit des Gelenkes führen kann , die die Propriozeption verbessern und das Risiko einer Versteifung des Gelenkes verringern . Dehnungsübungen der Achillessehne werden eingesetzt , da diese sich andernfalls infolge der Verletzung verkürzen kann . Nach Abnahme der Orthese sind laut der Leitlinien Koordinationsschulung , Muskelkräftigung ( Peroneusgruppe ) und Eigenreflexschulung vorgesehen . Mit sensomotorischem Balancetraining , das der Patient unter Anleitung oder selbständig durchführen kann , sollen erneute Verletzungen und dadurch wiederkehrende Bänderinstabilitäten vermieden werden . Allerdings liegen zum propriozeptiven Training widersprüchliche Ergebnisse vor . Die Wirksamkeit zusätzlicher Ultraschall- , Laser- und Kurzwellentherapie ist für die Behandlung der Außenbandruptur nicht nachgewiesen .
+Ein Review von 2014 kam zum Schluss , dass die manuelle Therapie und Gelenkmobilisierung sowohl bei akuten als auch bei subakuten oder chronischen Symptomen den Schmerz verringert und die Beweglichkeit verbessert .
+Operative Therapie Die operative Therapie der Außenbandruptur , so die Leitlinien der DGU , ÖGU und DGOOC , „ liefert bei gleicher frühfunktioneller Nachbehandlung eine der nichtoperativen Behandlung vergleichbare bis höhere Kapselbandstabilität bei einer nichtsignifikanten Tendenz zu höherer Steifigkeit und längerer Arbeitsunfähigkeit [ … ] sowie einem leicht erhöhten Risiko für die Entwicklung einer posttraumatischen Arthrose “ .
+Bin in die späten 1980er wurde fast jeder akute Bänderriss am oberen Sprunggelenk operiert . Heute werden Bandrupturen am oberen Sprunggelenk meistens zunächst konservativ behandelt , und eine Operation wird erst erwogen , wenn die konservative Therapie nach sechs oder mehr Monate nicht wirksam ist .
+Eine verbleibende chronische Instabilität kann mit Hilfe einer Außenbandplastik behoben werden .
+Bei Personen , bei denen im Alltag eine hohe Last auf das verletzte Gelenk einwirkt , vor allem bei Spitzensportlern , werden Bänderrisse auch direkt operiert . Auch im Falle eines knöchernen Bandausrisses kann eine Operation indiziert sein .
+Wird direkt operiert , können innerhalb der ersten 14 Tage nach der Verletzung die Teile des gerissenen Bandes aneinandergelegt und operativ vernäht werden .
+Später ist dies nicht mehr möglich , da diese schon teilweise abgebaut worden sind .
+Eine allzu frühe Operation kann allerdings eine arthrofibrotische Reaktion in der Gelenkkapsel auslösen .
+Nach einer operativen Bandrekonstruktion ist eine Prophylaxe der Schwellung , u. a. durch intermittierende Kühlung , durch den Einsatz von NSAR in den ersten Tagen nach der Operation und durch konsequente Hochlagerung des Fußes entscheidend .
+Im Folgenden können Warm-Kalt-Wechselduschen des Fußes und manuelle Therapie eingesetzt werden . Es kommt eine funktionelle Stufentherapie zum Einsatz , mit einer anfänglichen sechswöchigen Schienung , welche die Flexo-Extension des oberen Sprunggelenks begrenzt , sowie mit vorsichtigen frühfunktionellen , sensomotorischen Übungen ab dem Ende der zweiten Woche .
+Eingeschränkte Fahrtauglichkeit während der Heilung Ist der Fuß noch nicht dauerhaft belastbar oder ist eine Orthese nötig , kann die Fahrtauglichkeit eingeschränkt sein ( Fahruntüchtigkeit ) .
+Komplikationen Bei adäquater Behandlung , sei es konservativ oder durch Operation , heilt die Außenbandruptur in den meisten Fällen vollständig aus .
+Bei einem kleineren Teil der Behandelten bleiben jedoch chronische Symptome zurück .
+Laut einem Review von 1997 bleiben bei 10–30 % der Behandelten eine chronische Synovitis oder Tendinitis , Gelenksteife , Schwellung ( bzw. Schwellneigung ) , Schmerz , Muskelschwäche oder Gelenkinstabilität zurück . Laut einem Review von 2018 hatten nach 1–4 Jahren 5 % –46 % der Behandelten noch Schmerzen , 3 % –34 % rezidivierende Umknickverletzungen und 33 % –55 % eine Gelenkinstabilität ; 25 % berichteten über ein vorderes Impingement .
+Wird ein Bänderriss in der Frühphase der Heilung nicht angemessen behandelt , etwa indem neu gebildetes Wundgewebe durch Retraumatisierung zerstört wird , verlängert sich die Entzündungsphase .
+Auch andere Faktoren wie ein hohes Alter , Durchblutungsstörungen oder Diabetes können die Heilung verzögern .
+Werden Verletzungen nicht ausreichend ausgeheilt , kann es zu wiederholten Verletzungen oder auch zu chronischer Gelenkinstabilität kommen , woraus sich weitere Schäden ergeben können . Des Weiteren deuten Studien darauf hin , dass Gelenkinstabilität mit einer verringerten Lebensqualität und einer verringerten körperlichen Aktivität der Betroffenen einhergehen kann .
+Wachsen die Bänder unzureichend zusammen , kann es zur Abnutzung des Knorpels und somit zu einer Arthrose kommen .
+( Siehe auch : Posttraumatische Arthrose . ) Durch Umknickverletzungen und Bänderrisse kann es durch post-traumatische Synovitis und durch Einklemmung von Narbengewebe zu einem Weichteil-Impingement am oberen Sprunggelenk und dadurch zu einer mit Schmerzen verbundenen Beschränkung des Bewegungsmaßes dieses Gelenks ( Sprunggelenk-Impingement ) kommen . Dies kann eine Indikation für einen operativen Eingriff darstellen , etwa durch eine Abtragung des einklemmenden Gewebes mittels Arthroskopie . Weblinks Frische Außenbandruptur am Oberen Sprunggelenk , Leitlinien Unfallchirurgie der Deutschen Gesellschaft für Unfallchirurgie ( DGU ) und der Österreichischen Gesellschaft für Unfallchirurgie ( ÖGU ) , konsentiert mit der Leitlinienkommission der Deutschen Gesellschaft für Orthopädie und Orthopädische Chirurgie ( DGOOC ) , 8. August 2017 , gültig bis 8. August 2022 Sprunggelenkverstauchung , gesundheitsinformation.de , Gesundheitsportal des IQWiG , 4. April 2018 Einzelnachweise en : Sprained ankle Jörg Jerosch : Operative Therapie von Fuß und Sprunggelenk : Fußchirurgie in Klinik und Praxis , Deutscher Ärzteverlag , 2009 , ISBN 978-3-7691-0488-2 . S. 287. Jürgen Arnold : Orthopädie und orthopädische Chirurgie : Fuß , Hrsg. : Carl Joachim Wirth . Georg Thieme Verlag , 2002 , ISBN 978-3-13-126241-7 . S. 11. Andreas Maassen : Checkliste Parietale Osteopathie , Georg Thieme Verlag , 2011 , ISBN 978-3-8304-7464-7 . S. 240. Martin Breitenseher : Der MR-Trainer : Untere Extremität , Georg Thieme Verlag , 2013 , ISBN 978-3-13-170482-5 . S. 70. Frühe Physiotherapie : Viele Bänderrisse heilen ohne OP , Spiegel online , 11. Januar 2017 . S. 11. R. Best u. a. : In : Deutsche Zeitschrift für Sportmedizin . Jahrgang 62 , Nr. 3 ( 2011 ) , S. 57/62 . ( PDF ; 179 kB ) Frans van den Berg : Angewandte Physiologie , Georg Thieme Verlag , 2003 , ISBN 978-3-13-116032-4 . S. 141H . Lohrer , W. Alt , A. Gollhofer , B. Rappe : Verletzungen am lateralen Kapselbandapparat des Sprunggelenks – eine Übersicht , Deutsche Zeitschrift für Sportmedizin , Jahrgang 51 , Nr. 6 ( 2000 ) . Darin S. 106–203 . S. 202. S. 6–7 . Christoff Zalpour : Springer Lexikon Physiotherapie , Springer-Verlag , 2013 , ISBN 978-3-642-34730-6 , S. 121. Dietmar Seidenspinner : Training in der Physiotherapie : Gerätegestützte Krankengymnastik , Springer-Verlag , 2006 , ISBN 978-3-540-27135-2 . S. 163. Frans van den Berg : Angewandte Physiologie , Georg Thieme Verlag , 2003 , ISBN 978-3-13-116032-4 . S. 140. „ In general , the aetiology of impingement can be due to post-traumatic synovitis , malunion of fracture , scarring , recurrent sprains or other osseous causes “ . Zitiert nach : „ Ankle impingement and instability are well-recognized complications of ankle sprain . “ Zitiert nach : „ In fast zwei Dritteln aller Fälle ist das Impingement von intraartikulärem Narbengewebe und von Narbensträngen nach Ligamentrupturen die häufigste Ursache eines Weichteilimpingements am OSG “ . Zitiert nach : Mellany Galla , Markus Walther : Arthroskopie an Sprunggelenk und Fuß : Das Praxisbuch der Techniken und Indikationen , Schattauer Verlag , 2016 , ISBN 978-3-7945-2967-4 . Kapitel „ 4 Arthroskopie des ventralen oberen Sprunggelenks “ , Unterkapitel „ 4.1 Indikationen “ , Abschnitt „ 4.1.1 Synovialitis und Weichteilimpingement “ S. 82. 
+
+Datei : A Specimen by William Caslon.jpg Ein Alphabet ( frühneuhochdeutsch von kirchenlateinisch , von alphábētos ) ist die Gesamtheit der kleinsten Schriftzeichen bzw. Buchstaben einer Sprache oder mehrerer Sprachen in einer festgelegten Reihenfolge .
+Die Buchstaben können über orthographische Regeln zu Wörtern verknüpft werden und damit die Sprache schriftlich darstellen .
+Die im Alphabet festgelegte Reihenfolge der Buchstaben erlaubt die alphabetische Sortierung von Wörtern und Namen beispielsweise in Wörterbüchern .
+Nach einigen Definitionen ist mit Alphabet nicht der Buchstabenbestand in seiner festgelegten Reihenfolge gemeint , sondern die Reihenfolge selbst .
+Die Bezeichnung Alphabet geht auf die ersten beiden Buchstaben des griechischen Alphabets zurück ( Alpha – α , Beta – β ) . Ausgehend von den ersten drei Buchstaben des deutschen Alphabets ( bzw. des lateinischen Alphabets ) sagt man auch Abc ( die Schreibweise Abece verdeutlicht die Aussprache , wird aber selten verwendet ) .
+Alphabetschriften gehören wie Silbenschriften zu den phonographischen Schriften und stehen damit im Gegensatz zu piktografischen oder logografischen Systemen , bei denen die Zeichen für Begriffe stehen ( z. B.
+Rind , Sonnenaufgang , Freundschaft ) .
+Im Unterschied zu Silbenschriften bezeichnen alphabetische Buchstaben in der Regel jeweils nur einen Laut ( Phonem ) .
+Damit wird die fürs Sprechenlernen schon erbrachte und unerlässliche Abstraktionsleistung hochgradig ins Schreiben hinübergerettet und das Erlernen völlig neuer Symbole für die Objekte des Alltags eingespart .
+Eine Zwischenform aus Alphabetschrift und Silbenschrift stellen die sogenannten Abugidas dar , zu denen die indischen Schriften gehören ( siehe auch Schrifttypen ) .
+Das Alphabet dient auch dem Erlernen des Lesens und des Schreibens ; eine Merkhilfe dazu waren die Buchstabentafeln .
+Jemand , der lesen kann , wird fachsprachlich ebenfalls als Alphabet bezeichnet , das Gegenteil ist der Analphabet .
+Ein wichtiges Ziel von Kulturpolitik ist die Alphabetisierung der jeweiligen Bevölkerung – also die Beherrschung des Lesens und des Schreibens durch alle .
+Deutsches Alphabet Das deutsche Alphabet ist eine Variante des lateinischen Alphabets .
+Von diesem stammen 26 Buchstaben : Im deutschen Alphabet kommen dazu noch die drei Umlaute ( Ä / ä , Ö / ö , Ü / ü ) sowie das Eszett ( ẞ / ß ) .
+Weitere Alphabete ( Auswahl ) Datei : Alphabete.PNG Datei : Venn diagram showing Greek , Latin and Cyrillic letters.svg
+Natürliche Schriftsprachen Plan- , Sonder- und Geheimsprachen Funktionsweise Die Buchstaben eines Alphabetes sind schriftliche Symbole für die kleinsten bedeutungsunterscheidenden lautlichen Einheiten der Sprache , die Phoneme ; zum Beispiel unterscheiden und in und die Bedeutung der Wörter ( siehe auch Minimalpaar und Allophon ) .
+In einem idealen Alphabet entspricht jeder Buchstabe einem Phonem und umgekehrt .
+In der Praxis finden sich aber immer Abweichungen : Es kann dasselbe Zeichen für verschiedene Laute gelten ( z. B.
+für in und in oder die drei in ) .
+Es kann derselbe Laut mit verschiedenen Zeichen notiert werden ( z. B.
+in und ) .
+Es können mehrere Zeichen für ein einziges Phonem stehen ( ) .
+Es können mehrere Laute durch ein einziges Zeichen wiedergegeben werden ( z. B.
+für ) .
+Es kann ein Laut unbezeichnet bleiben ( z. B.
+der Knacklaut in ) .
+Darüber hinaus geht die einmal festgelegte Korrespondenz von Phonem und Graphem auch durch den Sprachwandel verloren ( vergleiche englisch und gegenüber lateinisch ) .
+Fehlen in einem Schriftsystem Zeichen für Phoneme , können sprachliche ( inhaltliche ) Unterschiede eventuell nicht schriftlich wiedergegeben werden .
+So bestanden einige Alphabete ursprünglich nur aus Konsonanten ( Konsonantenschrift ) .
+Später wurden sie mit Zeichen für Vokale ergänzt , die als kleine Zusätze ( z. B.
+Punkte , Striche ) zu den Konsonanten gesetzt werden konnten ( z. B.
+arabisches und hebräisches Alphabet ) .
+Sind hingegen in einem Schriftsystem Zeichen für Phoneme im Übermaß vorhanden , können semantische ( inhaltliche ) Unterschiede selbst bei gleicher Lautung schriftlich ausgedrückt werden .
+Zum Beispiel im Deutschen und .
+Die Schriftsysteme für die meisten europäischen Sprachen nutzen Varianten des lateinischen Alphabets .
+Dabei wurden den Zeichen für lateinische Laute ähnliche Laute der jeweiligen Sprache zugeordnet .
+Dieselben Zeichen standen in den verschiedenen Sprachen für teilweise unterschiedliche Laute .
+Zudem ist es im Zuge der Sprachentwicklung zu weiteren Veränderungen der Aussprache gekommen ( vgl. im Deutschen und Englischen ) .
+Da die Zahl und Art der Phoneme in den verschiedenen Sprachen unterschiedlich ist , genügte der Zeichenvorrat des lateinischen Alphabetes oft nicht .
+Deshalb wurden zur Darstellung der betreffenden Phoneme Buchstabenkombinationen ( z. B.
+, , ) und diakritische Zeichen eingeführt ( z. B.
+auf , ) .
+Daneben wurden Varianten der ursprünglichen lateinischen Zeichen ( > , > ) und Ligaturen ( > , / > , / > ) zu eigenständigen Zeichen weiterentwickelt und gelegentlich auch Buchstaben aus anderen Alphabeten übernommen ( ) .
+Lautschrift Ein absolut phonetisches Alphabet wäre in der Praxis unbrauchbar , weil es aufgrund der mannigfaltigen Nuancen einer Sprache sehr viele Zeichen hätte .
+Ein in Bezug auf die phonetische Wiedergabe optimiertes Alphabet ist das IPA , welches möglichst vielen Lautnuancen ein grafisches Zeichen zuordnet .
+Eine phonemische Schreibweise behandelt unterschiedliche Aussprachen desselben Phonems gleich .
+So wird beispielsweise in der deutschen Orthografie die regional unterschiedliche ( phonetische ) Aussprache des Phonems in als norddeutsch und hochdeutsch nicht berücksichtigt .
+Daneben sorgen morphemische Schreibungen für ein konstanteres Schriftbild bei der Flexion , z. B.
+schreibt man wegen des Plurals nicht * , sondern , und bei der Derivation , z. B.
+statt .
+Buchstabieren Wenn Menschen einander mündlich die korrekte Schreibweise eines Wortes mitteilen , indem sie nacheinander alle Buchstaben jenes Wortes nennen , so bezeichnet man diesen Vorgang als Buchstabieren ( Verb : buchstabieren ) .
+Dabei werden Konsonantenbuchstaben meist mit Hilfe von zusätzlichen Vokalen ausgesprochen , im Deutschen zum Beispiel [ beː ] für B oder [ kaː ] für K ( siehe Benennung der Buchstaben ) .
+Um Missverständnisse auszuschließen , können auch festgelegte Namen oder Wörter ausgesprochen werden , die mit dem betreffenden Buchstaben beginnen , zum Beispiel „ Anton “ für A oder „ Berta “ für B ( siehe Buchstabiertafel ) .
+Entstehung und Entwicklung Aus den in Vorderasien gebräuchlichen Keilschriften entwickelten Händler in Ugarit um 1400 v. Chr.
+die erste alphabetische Schrift , die sogenannte ugaritische Schrift .
+Aus dieser Schrift hat sich um 1000 v. Chr.
+unter anderem das phönizische Alphabet entwickelt , das wiederum Ausgangspunkt für die heute gebräuchlichen Alphabete war .
+Die Phönizier verwendeten dabei Elemente vorhandener Bilderschriften .
+Sie lösten die Zeichen vollständig von ihrer bildlichen Bedeutung und wiesen ihnen Lautwerte zu .
+Die phönizische Schrift verlief von rechts nach links .
+Trotz der großen Unterschiede in der Gestalt der Zeichen lassen sich die Buchstaben der Phönizier mit den Keilschrift-Zeichen der ugaritischen Schrift in Verbindung bringen .
+Die phönizische Schrift war eine reine Konsonantenschrift .
+Dies entsprach der Struktur der semitischen Sprachen .
+Die hebräische und die arabische Schrift , die daraus entstanden , verzichten bis heute ( weitgehend ) auf Vokale .
+Als die Griechen etwa im 10. oder 9. Jahrhundert v. Chr.
+die phönizische Schrift übernahmen , benutzten sie Zeichen für bestimmte semitische Konsonanten , die in ihrer Sprache nicht vorkamen , zur Bezeichnung von Vokalen , z. B.
+wurde aus dem Zeichen H für einen rauen Hauchlaut im griechischen Alphabet ein Zeichen für einen Vokal ( siehe Buchstabe Eta ) .
+Einige Zeichen für Konsonanten , die die phönizische Sprache nicht kannte , wurden neu geschaffen , z. B.
+das Psi .
+Im Jahre 403 v. Chr.
+wurde in Athen das Alphabet normiert .
+Es wurde so zum Schriftsystem für ganz Griechenland .
+Anfang des 4. Jahrhunderts v. Chr.
+brachten griechische Siedler das Alphabet nach Italien , wo die Etrusker ( in der heutigen Toskana ) es im Laufe des 4. Jahrhunderts übernahmen .
+Im 3. Jahrhundert v. Chr.
+orientierten sich die Römer an der griechisch-etruskischen Schrift und überlieferten sie im 1. Jahrhundert v. Chr.
+nach Mitteleuropa .
+Historische Bedeutung Durch das Alphabet entstand ein System mit vergleichsweise wenigen Zeichen .
+Um die Aufzeichnungen der alten Ägypter verstehen zu können , musste man Hunderte , später sogar Tausende Hieroglyphen lernen .
+Nun genügten zwei Dutzend Zeichen , um sämtliche Gedanken , die überhaupt formulierbar sind , zu notieren .
+Die Einfachheit dieses Systems begünstigte dessen Verbreitung über die halbe Welt .
+„ Die menschlichen Sprechwerkzeuge können zwar eine riesige Zahl von Lauten erzeugen , doch beruhen fast alle Sprachen auf dem formalen Wiedererkennen von nur ungefähr vierzig dieser Laute durch die Mitglieder einer Gesellschaft . “ ( Jack Goody ) .
+Die Reihenfolge des griechischen und lateinischen Alphabets folgt global ( mit wenigen Ausnahmen ) der Reihenfolge des phönizischen Alphabets , da die Zeichen auch mit einem Zahlwert gekoppelt waren .
+Alphabete im weiteren Sinn Datei :C happe.svg Datei :D eutsche Fingeralphabet.jpg Die Buchstaben ( Schriftzeichen eines Alphabets ) bestehen meist aus Linien und können beispielsweise auf Papier geschrieben werden .
+Das bestimmende Merkmal eines Buchstabens ist jedoch nicht die Form , sondern seine Funktion , einen Sprachlaut oder eine Lautverbindung zu repräsentieren . Deshalb spricht man im weiteren Sinn auch bei den folgenden Zeichensystemen von Alphabeten : Brailleschrift , die häufigste Form einer Blindenschrift
+Fingeralphabet für Gehörlose und Schwerhörige
+Morsezeichen
+Flaggenalphabet
+Winkeralphabet
+optische Telegrafie
+Diese Zeichensysteme kodieren eigentlich Buchstaben – und nur indirekt Laute .
+Zudem enthalten sie auch Zeichen für Ziffern und teilweise weitere Zeichen ( Satzzeichen , Steuerzeichen , Zeichen für Wörter ) .
+In der Informatik werden die Begriffe Alphabet und Buchstabe in einem verallgemeinerten Sinn verwendet .
+Ein „ Buchstabe “ kann hier auch eine Ziffer oder ein sonstiges Symbol sein – „ Alphabete “ und „ Wörter “ können solche beliebigen Symbole enthalten .
+Siehe hierzu Alphabet ( Informatik ) und formale Sprache .
+Siehe auch Genealogie der vom Protosemitischen abgeleiteten Alphabete
+Pangramm
+Universalalphabet
+Literatur Hans Peter Willberg : Wegweiser Schrift . Verlag Hermann Schmidt , Mainz 2001 , ISBN 3-87439-569-3 . Lewis F. Day : Alte und neue Alphabete . Reprint der Ausgabe von 1906 , mit einem Nachwort von Hans A. Halbey .
+Harenberg Edition , Dortmund 1991 , ISBN 3-88379-603-4 . George L. Campbell : Handbook of scripts and alphabets . Routledge , London 1997 , ISBN 0-415-13715-2 . Ludwig D. Morenz : Sinai und Alphabetschrift .
+Die frühesten alphabetischen Inschriften und ihr kanaanäisch-ägyptischer Entstehungshorizont im Zweiten Jahrtausend v. Chr.
+, mit Beiträgen von David Sabel , EB-Verlag Dr. Brandt , Berlin 2019 , ISBN 978-3-86893-252-2 . Weblinks Vollständige Listen europäischer Alphabete Sammlung von Alphabeten der Welt Interaktives ABC zum Erlernen des Alphabetes , mehrsprachig Artikelserie zum Erlernen des Alphabetes für Kinder Einzelnachweise Robert R. Anderson ( Hrsg. bis Band 1 ) , Ulrich Goebel , Oskar Reichmann ( Hrsg. ) : Frühneuhochdeutsches Wörterbuch . 2 Bände , bearbeitet von Oskar Reichmann , De Gruyter , Berlin / New York ( 1986– ) 1989 ff. , Band 1 ( 1989 ) , Sp. 837. DWDS : Vgl. Duden online : . Der Sprachgebrauch zeigt jedoch , dass mit Alphabet meistens nicht die Anordnung gemeint ist , sondern die Buchstaben als geordnete Gesamtheit . Dafür stehen Formulierungen wie „ die Buchstaben des deutschen Alphabets “ , ebenso die im Duden-Artikel genannten Verwendungsbeispiele „ das kleine Alphabet “ , „ das große Alphabet “ und die ebenfalls dort genannten Synonyme Buchstabenfolge , Buchstabenreihe . Bei der im DWDS unter verwendeten Formulierung „ festgelegte Abfolge der Buchstaben “ ist unklar , ob die Reihenfolge der Buchstaben gemeint ist oder die Buchstaben selbst – oder beides zugleich.Vgl . Duden online : Vgl. Duden online : , abgerufen am 8. September 2016.Duden online : 
+
+Datei : Air Chief Marshal Sir Arthur Harris.jpg Sir Arthur Travers Harris , 1. Baronet GCB OBE AFC , genannt Bomber-Harris , ( * 13. April 1892 in Cheltenham ; † 5. April 1984 in Goring-on-Thames ) war ein hochrangiger Offizier der Royal Air Force , zuletzt im Rang eines Marshal of the Royal Air Force .
+Während des Zweiten Weltkriegs war er ab Februar 1942 Oberbefehlshaber des RAF Bomber Command und gehört wegen der von ihm angeordneten Flächenbombardements deutscher Städte zu den umstrittensten Personen des Luftkriegs im Zweiten Weltkrieg .
+Leben Arthur Travers Harris wurde in Cheltenham während eines Urlaubs seiner Eltern geboren .
+Sein Vater war Angehöriger der britischen Beamtenschaft in Indien ( Indian Civil Service ( ICS ) ) . Nach der Schulzeit in Dorset stand laut Biographie von Norman Longmate für Harris im Alter von 16 Jahren eine Entscheidung zwischen der Armee und den Kolonien an .
+Harris entschied sich 1908 für letztere .
+In Rhodesien war er nach eigener Auskunft mit Goldwaschen , Kutschfahrten und Landwirtschaft beschäftigt .
+Erster Weltkrieg 1914 trat er als Trompeter in das 1st Rhodesian Regiment der Britischen Armee ein .
+Er diente für die Südafrikanische Union im Krieg in Deutsch-Südwestafrika ( heute Namibia ) , bevor er 1915 nach England zurückkehrte und in das neu aufgestellte Royal Flying Corps eintrat .
+Harris war in Frankreich und England im Einsatz und errang auf den Doppeldeckern Sopwith 1 ½ Strutter und Sopwith Camel fünf Luftsiege , worauf ihm das Air Force Cross ( AFC ) verliehen wurde .
+Bei Kriegsende hatte er den Rang eines Majors .
+Zwischenkriegszeit 1919 verblieb er bei der neu gegründeten Royal Air Force und wurde im April 1920 Staffelführer und Kommandant des Fliegerhorstes Digby und der No. 3 Flying Training School .
+Später diente er unter anderem in Britisch-Indien , in Mesopotamien und in Persien .
+In Mesopotamien kommandierte er ein Transportgeschwader Vickers Vernon .
+1922 war Harris Führer einer Lufttransportstaffel im Irak , wo die Briten versuchten , den Widerstand der Einheimischen durch Terrorangriffe auf Städte und Dörfer zu brechen , bevor der Einsatz von Infanterie notwendig wurde .
+Harris hatte die Idee , alle Transportflugzeuge zusätzlich mit Bombenträgern auszustatten , „ kam es doch nicht auf Präzisionsangriffe an , sondern auf eine möglichst flächendeckende Terrorisierung der Bevölkerung . “
+Von 1930 an war Harris im Luftstab für den Naher Osten tätig , wo er an der Niederschlagung verschiedener Aufstände der dortigen Bevölkerung gegen die britische Kolonialherrschaft beteiligt war .
+Er begründete dies damit , dass seiner Ansicht nach die Araber nur eine „ Politik der harten Hand “ verstünden ( „ The only thing the Arab understands is the heavy hand “ ) .
+Zweiter Weltkrieg Am 14. Februar 1942 erfolgte die Anweisung „ Area Bombing Directive “ des britischen Luftfahrtministeriums .
+Harris wurde im Februar 1942 zum Oberkommandierenden des Bomber Command der RAF ernannt .
+Basierend auf Vorlagen von Frederick Lindemann , einem engen Berater Churchills , von dem die Wortschöpfung Flächenbombardements ( Carpet Bombing ) stammt , war Harris der Ansicht , allein durch Flächenbombardierungen der Städte das Deutsche Reich zur Kapitulation zwingen zu können .
+Harris unterstützte maßgeblich die Entwicklung eines geplanten Feuersturms ( Zitat A. Harris bei den Planungen des Luftangriffs auf Lübeck am 29. März 1942 : „ Historischer Stadtkern brennt gut “ ) . In der ersten Welle wurden neben Spreng- und Brandbomben vor allem große Luftminen ( Blockbuster – „ Wohnblockknacker “ ) abgeworfen , die die Dächer abdeckten und Fenster zerstörten , um den Kamineffekt zu verstärken .
+In einer zweiten Welle wurden Brandbomben abgeworfen , die in kürzester Zeit einen Flächenbrand entstehen ließen .
+Dies gelang jedoch aufgrund meteorologischer und städtebaulicher Faktoren nicht immer .
+Um die deutsche Flugabwehr und die nach dem sog. „ Himmelbett-Verfahren “ arbeitende Nachtjagd , z. B. entlang der Kammhuber-Linie durch lokale Überlastung zu überrumpeln , entwickelte er die Methode der Bomberströme , bei der möglichst viele Bomber auf demselben Kurs einfliegend in kurzer Zeit ein Ziel angriffen , statt einzeln und in breiter Front einzufliegen .
+Zur Demonstration der Wirksamkeit seines Konzeptes zog Harris im Frühjahr 1942 für die Operation Millennium alle verfügbaren Bomber zusammen , um Ende Mai mit 1047 Maschinen auf Köln den ersten „ Tausend-Bomber-Angriff “ durchzuführen .
+Dieser Angriff war entscheidend , um die zahllosen britischen Skeptiker von der Wirksamkeit von Luftangriffen zu überzeugen und die betriebene Auflösung des Bomber Command zu verhindern .
+Die technischen Voraussetzungen für präzise Schläge gegen strategische Punkte wie Fabriken für Flugzeuge , Panzer und anderes Rüstungsmaterial befanden sich in der Mitte des Krieges noch in der Entwicklung .
+Die schweren Verluste der 8. USAAF bei ihren Angriffen 1943 und Anfang 1944 bestätigten sein Festhalten am Nachtangriff vorerst bis zum Einsatz von neuen amerikanischen Langstreckenbegleitjägern , wobei die Nachtangriffe der RAF durch die Schaffung der 24-Stunden-Bedrohung auch für den Erfolg der amerikanischen Tagesangriffe auf strategische Punktziele weiterhin bedeutend blieben .
+Unter seiner Führung wurden von der RAF zahlreiche deutsche Städte schwer zerstört , so bei der Operation Gomorrha gegen Hamburg im Juli / August 1943 , Kassel ( 22. Oktober 1943 ) , Leipzig ( 4. Dezember 1943 ) , Frankfurt am Main ( 22. März 1944 ) , Darmstadt ( 11. September 1944 ) , Braunschweig ( 15. Oktober 1944 ) , Nürnberg ( 2. Januar 1945 ) , Magdeburg ( 16. Januar 1945 ) , Dresden am 13. / 14. Februar 1945 sowie Pforzheim ( 23. Februar 1945 ) , Mainz ( 27. Februar 1945 ) , Würzburg ( 16. März 1945 ) , Hanau ( 19. März 1945 ) und Hildesheim ( 22. März 1945 ) .
+Bei den Flächenbombardements wurden – neben den im Stadtgebiet befindlichen Industrieanlagen – die Zivilbevölkerung und die Infrastruktur der Stadt primäres Ziel der Angriffe .
+Seiner Meinung nach sollten ganz bewusst zivile Ziele angegriffen werden , um die Moral und den Widerstandswillen der deutschen Bevölkerung zu brechen ( sogenanntes Moral Bombing ) .
+Zu Beginn der Bombardierungen äußerte sich Harris zu seiner Motivation : „ Die Nazis starteten ( ‚ entered ‘ ) den Krieg mit der ziemlich kindischen Vorstellung , dass sie jeden anderen nach Belieben bombardieren könnten und niemand würde zurückbomben .
+In Rotterdam , London , Warschau und an beinahe einem halben Hundert anderer Stätten führten sie ihre ziemlich naive Theorie aus .
+Sie säten Wind und jetzt ernten sie Sturm “
+.
+In seinen Memoiren schrieb er später : „ Trotz all dem , was in Hamburg geschehen ist , bleibt das Bomben eine relativ humane Methode “ .
+Neben den Bombenangriffen auf Deutschland wurden insbesondere in Italien mehrere Großstädte bombardiert , was etwa in Mailand , Neapel und Palermo beträchtliche Schäden auch in Wohngebieten verursachte .
+Nach dem Krieg Datei : Arthur Harris.jpg Am 15. September 1945 schied Harris im Streit mit dem neuen Premierminister Clement Attlee aus der Royal Air Force aus und zog sich verbittert nach Südafrika zurück .
+Seine Ehrungen durch die Ernennung zum erblichen Baronet , of Chipping Wycombe in the County of Buckingham , am 24. Januar 1953 ( eine Erhebung zum Peer hatte er abgelehnt ) sowie die Enthüllung eines von Veteranen finanzierten Denkmals 1992 vor der Kirche St Clement Danes in London durch die Königinmutter Elizabeth waren in der britischen Bevölkerung stark umstritten .
+Innerhalb von 24 Stunden wurde das Denkmal mit roter Farbe überschüttet und später noch mehrfach beschädigt , woraufhin es für mehrere Monate unter Bewachung stand . In diesem Zusammenhang ist auch von Bedeutung , dass seine Luftkriegs-Strategie für die Besatzungen der Flugzeuge verlustreich war .
+Nahezu 45 % kehrten nicht heim , insgesamt kamen 55.573 Flieger bei den Angriffen auf Deutschland um .
+Auch deswegen wurde Harris oft „ Butcher “ ( engl. für Metzger oder Schlächter ) genannt .
+Militärhistorische Wertung Die historische wie rechtliche Qualifizierung der alliierten Luftkriegsstrategie und damit der Position Harris ’ wird unterschiedlich bewertet .
+Nach sachlichen oder militärischen Kriterien war die gezielte Zerstörung von Wohngebieten und Innenstädten umstritten .
+Zwar waren militärisch gesehen die strategischen Folgen des Luftkriegs allgemein erheblich , da angesichts der Angriffe die deutsche Rüstungsproduktion zu umfangreichen produktionsbehindernden Verlagerungen gezwungen wurde – laut Albert Speer führten die alliierten Luftangriffe bei den Luftfahrzeugen zu einer Halbierung der möglichen Produktion .
+Über eine Million Soldaten wurden bei der Flakartillerie eingesetzt und fehlten dadurch an den Fronten , zusätzlich wurde eine halbe Million Behelfspersonal herangezogen , darunter viele Jugendliche als Flakhelfer .
+All dies war aber in erster Linie auf die gegen die Rüstungsindustrie geführten Tagangriffe der USAAF und nicht auf die gegen die Zivilbevölkerung gerichteten und von Arthur Harris verantworteten Nachtangriffe der Royal Air Force zurückzuführen .
+Die bekanntesten Einsätze des Bomber Command außerhalb von Harris ’ Strategie waren : Die Angriffe auf die Talsperren ( Operation Chastise ) , die Versenkung des Schlachtschiffs Tirpitz ( November 1944 ) , die Bombardierung von U-Boot-Bunkern der Kriegsmarine an der französischen Atlantikküste und die Zerstörung von Anlagen des deutschen V-Waffen-Programms ( Operation Hydra , Éperlecques , Mimoyecques ) sowie die direkte taktische Unterstützung während der Landung alliierter Truppen in der Normandie ( Operation Overlord ) .
+Harris hat seinen Standpunkt insbesondere in seinem Buch Bomber Offensive dargestellt , das seinen Lebensweg beschreibt .
+Er argumentiert , das nationalsozialistische Deutschland habe damit begonnen , die Zivilbevölkerung zum Objekt von Terrorangriffen zu machen ( Guernica , Coventry , Rotterdam , Warschau , London ) .
+Aufgabe der britischen Verantwortlichen sei es gewesen , für ein schnelleres Ende des Krieges zu sorgen und eigene Opfer zu vermeiden , die etwa ein Landkrieg oder Stellungskrieg wie im Ersten Weltkrieg mit sich gebracht hätte .
+Vor dem Eintritt der Vereinigten Staaten in den Krieg ( Dezember 1941 ) beziehungsweise vor dem D-Day , der alliierten Landung in der Normandie am 6. Juni 1944 , hätte angesichts der Insellage Großbritanniens einzig die Offensivstrategie des Bomber Commands der Royal Air Force die Sicherheit des Vereinigten Königreichs garantieren können .
+Des Weiteren unterstreicht Harris die Bedeutung der Luftunterstützung für einen erfolgreichen Einsatz von Landtruppen .
+Er verweist zum Vergleich auf die deutsche Blitzkriegstrategie zu Beginn des Krieges , bei der das schnelle Vordringen des Heeres , insbesondere der Panzer , nur aufgrund massiver und rasch abrufbarer Luftunterstützung ( Bomber und Jagdflieger ) möglich gewesen sei .
+Die Tatsache , dass die deutsche Luftwaffe gegen Ende des Krieges zum großen Teil zerstört oder durch die Verteidigung des eigenen Territoriums gegen die alliierten Bomber gebunden waren , habe dazu geführt , dass dem deutschen Heer die notwendige Unterstützung durch die Luftwaffe fehlte .
+Die alliierte Luftüberlegenheit habe den britischen und US-amerikanischen Truppen sowie der Roten Armee entscheidend geholfen , die Deutschen zurückzudrängen .
+Sonstiges In dem 1954 gedrehten britischen Spielfilm Mai 1943 – Die Zerstörung der Talsperren ( The Dam Busters ) von Michael Anderson wird Arthur T. Harris von Basil Sydney dargestellt .
+Siehe auch Carl A. Spaatz – US-Bomberkommando Schriften Bomber offensive . Collins , London , 1947 . Despatch on war operations , 23rd February , 1942 , to 8th May , 1945 , F. Cass , London ; Portland , 1995 .
+ISBN 0-7146-4692-X . Literatur Ralph Barker und die Redaktion der Time-Life-Bücher : Die RAF im Krieg . Bechtermünz , Eltville am Rhein 1993 , ISBN 3-86047-051-5 . Robin Neillands : Der Krieg der Bomber .
+Arthur Harris und die Bomberoffensive der Alliierten 1939–1945 .
+Edition q , Berlin 2002 , ISBN 3-86124-547-7 . Henry Probert : Bomber Harris .
+His Life and Times .
+Greenhill , London 2001 , ISBN 1-85367-555-5 . Dudley Saward : „ Bomber “ Harris : The Authorized Biography .
+Sphere Books , London 1996 , ISBN 0-907675-33-6 . Stanley White : The means of victory . Charterhouse , London 1992 , ISBN 0-9518781-1-5 . Weblinks , Artikel in der Welt , 3. November 2004 Einzelnachweise Rolf-Dieter Müller : Der Bombenkrieg 1939-1945 . Links , Berlin , 2004 , ISBN 3-86153-317-0 , S. 24f . James S. Corum , Wray R. Johnson : Airpower in Small Wars : Fighting Insurgents and Terrorists ( Modern War Studies ) , S. 65 , University Press of Kansas , 2003 . Air Marshal Arthur Harris ( bei historylearningsite.co.uk ) ( bei ukattraction.com ) Horst Boog ( Hrsg. ) : Das Deutsche Reich in der Defensive . Strategischer Luftkrieg in Europa , Krieg im Westen und in Ostasien 1943–1944 / 45. ( = Militärgeschichtliches Forschungsamt ( Hrsg. ) : Das Deutsche Reich und der Zweite Weltkrieg . Band 7. ) Deutsche Verlags-Anstalt , München 2001 , ISBN 3-421-05507-6 , S. 198. 
+
+Datei : Arthur Wellesley , 1st Duke of Wellington by Robert Home cropped.jpg Arthur Wellesley , 1. Duke of Wellington ( * vermutlich 1. Mai 1769 in Dublin , Irland ; † 14. September 1852 in Walmer Castle bei Deal , Kent , England ) , war Feldmarschall und der herausragende britische Militärführer der napoleonischen Zeit sowie britischer Außen- und zweimal Premierminister .
+Er siegte über Napoleon in der Schlacht bei Waterloo .
+Leben Herkunft und Kindheit Wellesley stammte aus verarmtem englisch-irischen Adel und war der dritte überlebende Sohn von Garret Wesley , 1. Earl of Mornington und Anne , der Tochter von Arthur Hill-Trevor , Viscount Dungannon .
+Der Tag seiner Geburt ist nicht sicher bekannt .
+Vermutlich wurde er in Mornington House , 24 Upper Merrion Street in Dublin geboren .
+Sein älterer Bruder Richard Colley Wesley ( 20. Juni 1760 bis 26. September 1842 ) folgte dem Vater als Earl of Mornington ( 1781 bis 1799 ) bevor er 1799 zum Marquis erhoben wurde .
+Er wählte den Titel Marquess Wellesley , so dass sein Bruder Arthur bei seiner Erhebung zum Herzog auf den Familiennamen verzichten musste und den Titel eines Herzogs von Wellington wählte .
+Als Kind kränklich und wenig ehrgeizig , aber musikalisch begabt ( er spielte gerne und oft Violine ) , stand er ganz im Schatten seiner beiden älteren Brüder .
+Nach dem Besuch des Eton College von 1781 bis 1785 , wo er sich wenig hervortat , sandten ihn seine Eltern zunächst zum 73. Infanterie-Regiment der British Army , in das er am 7. März 1787 eintrat , damit „ wenigstens “ ein „ passabler “ Soldat aus ihm würde .
+Danach besuchte er die Militärakademie in Angers ( Frankreich ) .
+Zur gleichen Zeit studierte ein anderer , im selben Jahr geborener Kadett an der Militärakademie in Brienne : Napoleon Bonaparte .
+Militärische Karriere Im Jahre 1788 wurde Wellesley zum Leutnant befördert .
+Nach verschiedenen Zwischenstationen bei der Kavallerie und den 12. und 18. leichten Dragonern wurde er 1793 Oberstleutnant des 33rd Foot , ein schneller Aufstieg , der durch das damals übliche Kaufsystem ermöglicht wurde .
+Während der ganzen Zeit war er Adjutant des Vizekönigs von Irland und nebenbei ( 1790–1797 ) Abgeordneter von Trim ( seinem Familiensitz ) im irischen Parlament ( Irish House of Commons in Dublin , das 1800 aufgelöst wurde , als Irland unter Kriegsrecht gestellt wurde ) .
+Datei : Francisco Goya - Portrait of the Duke of Wellington.jpg
+Seine aktive militärische Karriere begann 1794 , als er im Ersten Koalitionskrieg mit dem Duke of York nach Flandern ging und dort am erfolglosen Feldzug gegen die Franzosen teilnahm .
+Er kommandierte beim Rückzug die Nachhut .
+1796 wurde Wellesley zum Oberst befördert und ging mit seinem Regiment nach Indien , wo im Jahr darauf sein älterer Bruder Richard Generalgouverneur werden sollte .
+Als 1799 der Vierte Mysore-Krieg gegen den Sultan von Mysore , Tipu Sultan , ausbrach , kommandierte er seine erste Division .
+Er führte einen sehr erfolgreichen Feldzug im Zweiten Marathenkrieg und konnte dabei seine militärischen Fähigkeiten erheblich ausbauen .
+Er wurde Oberbefehlshaber der britischen Streitkräfte in Indien und zwang ganz Südindien unter britische Herrschaft .
+Am 11. August 1803 nahm er die Festung Ahmednagar und besiegte eine überlegene Streitmacht der Marathen in der Schlacht von Assaye .
+In den nächsten Wochen gelang es seinen Truppen , Burhanpur und die Festung Asirgarh einzunehmen .
+Er stieß auf Hyderabad vor , siegte am 29. November in der Schlacht von Argaon und stürmte die Festung Gawilgarh .
+1805 kehrte er als dekorierter und zum Ritter geschlagener ( 1804 ) Major General Sir Arthur Wellesley nach Großbritannien zurück , gemeinsam mit Richard , dessen Amtszeit als Generalgouverneur ebenfalls abgelaufen war .
+Datei : Lord Arthur Wellesley the Duke of Wellington.jpg
+1807 nahm Wellesley als Lieutenant General an einer Expedition nach Dänemark teil .
+Anfang August 1808 landete er mit 13.000 Mann in Portugal und besiegte zwei Wochen darauf die französischen Truppen in der Schlacht bei Vimeiro .
+Wellesleys Vorgesetzte Burrard und Dalrymple , die erst nach dem Ende der Schlacht in Portugal eingetroffen waren , schlossen Ende August die Konvention von Cintra ab , welche den Franzosen nicht nur den freien Abzug gewährte , sondern ihnen auch den Erhalt der Kriegsbeute und den Rücktransport auf britischen Schiffen garantierte .
+Diese Bedingungen , welche von der britischen Öffentlichkeit als Sieg für Frankreich empfunden wurden , führten dazu , dass Wellesley , gemeinsam mit Burrard und Dalrymple , nach Großbritannien zurückbefohlen wurde .
+Dort hatten sie sich einer Anhörung vor einem Militärgericht zu stellen .
+Wellesley wurde jedoch entlastet und wurde im Gegensatz zu den beiden anderen Beteiligten , rehabilitiert .
+Am 27. Oktober 1807 schlossen Frankreich und Spanien im Geheimen den Vertrag von Fontainebleau ( 1807 ) .
+In diesem vereinbarten sie die Eroberung und Teilung Portugals .
+Damit die französischen Truppen Portugal auf dem Landweg erreichen konnten , gewährte Spanien den Franzosen den Durchmarsch durch spanisches Hoheitsgebiet .
+Im Frühjahr 1809 versuchten die Franzosen ein zweites Mal , Portugal zu erobern .
+Wellesley kehrte nach Portugal zurück und übernahm den Oberbefehl der dortigen britisch-portugiesischen Truppen .
+Am 12. Mai 1809 schlug er Marschall Nicolas Soult in der Zweiten Schlacht bei Oporto .
+Durch den Sieg in der Schlacht bei Talavera de la Reina am 28. Juli beendete Wellesley die französischen Ambitionen .
+Wellesley gab zum Schutze Portugals am 20. Oktober 1809 beim britischen Ingenieur Richard Fletcher die Befestigung der Linien von Torres Vedras in Auftrag , unter dessen Leitung sie von portugiesischen Militäreinheiten und Arbeitern errichtet wurden .
+Der Vormarsch der Franzosen unter Marschall Masséna hatte am 27. September 1810 in der Schlacht von Buçaco einen empfindlichen Rückschlag erhalten , jedoch blieb die Hauptstadt Lissabon weiterhin bedroht .
+Am 3. April 1811 scheiterte mit der Schlacht von Sabugal der letzte Versuch Frankreichs , Portugal zu erobern .
+Durch diese Erfolge schwenkte die Stimmung in Spanien auf die britische Seite um , und Wellesley wurde auch Oberkommandierender der spanischen Streitkräfte .
+Lord Beresford erhielt den Oberbefehl über die reorganisierte portugiesische Truppenmacht .
+Nachdem bekannt wurde , dass die französischen Truppen im Westen Spaniens reduziert wurden , marschierte Wellington nach Ciudad Rodrigo und nahm diese Stadt nach kurzer Belagerung am 19. Januar 1812 ein , wofür er durch den Prinzregenten Georg zum Earl of Wellington erhoben wurde .
+Ab 27. März 1812 begannen die Verbündeten die dritte Belagerung von Badajoz , Wellington nahm die Stadt nach drei Wochen unter Verlust von etwa 4.000 Mann auf britischer Seite am 7. April ein .
+Die Eroberung erlaubte es den Briten , eigene Operationen im zentralen Spanien einzuleiten .
+Während sich ein britisches Korps unter General Hill zwischen den französischen Armeen Marmont und Soult gegen den Tajo vorschob , wandte sich die britische Hauptmacht nach Leon .
+Am 21. Juli erwarteten die Franzosen den Gegner am Tormes und in Stellungen auf den Arapilen und am 22. Juli schlug Wellington den Gegner in der Schlacht von Salamanca .
+Wellington konnte infolge dieser Kämpfe am 12. August Madrid besetzen , wurde aber kurz darauf wieder aus der Stadt vertrieben und musste die geplante Belagerung von Burgos aufgeben .
+Nach der Niederlage Napoleons in Russland und dem Beginn der Kämpfe in Deutschland erhielten die französischen Truppen in Spanien keine Verstärkung mehr .
+Wellington verbrachte den Winter damit , seine Armee zu reorganisieren und plante für das Frühjahr 1813 die Iberische Halbinsel gänzlich freizukämpfen .
+Im Mai 1813 begann Wellingtons abschließende Offensive von Portugal aus zwischen Duero und Tajo , in der er zunächst die nördlichen Provinzen Spaniens eroberte und sein Hauptquartier von Lissabon nach Santander verlegte .
+Wellingtons Truppen marschierten durch das kastilische Hochland in Richtung auf Kantabrien , um die französische Hauptmacht durch Abschneidung der Verbindungswege zum Rückzug aus Zentralspanien zu zwingen .
+Er griff die französische Hauptmacht unter Joseph Bonaparte am 21. Juni 1813 in der entscheidenden Schlacht von Vitoria mit drei Kolonnen an .
+Die Schlacht beendete Napoleons Herrschaft in Spanien .
+Am 7. Juli begann Wellington die Belagerung von San Sebastian .
+Im Herbst 1813 rang er , inzwischen zum Feldmarschall befördert , mit den Truppen des neuen französischen Oberbefehlshabers Soult auf breiter Front um die Übergänge in den Pyrenäen .
+In Südfrankreich eindringend , lieferte er sich mit Soult noch am 10. April 1814 die blutige Schlacht bei Toulouse , dann folgte mit der Abdankung Napoleons , das Kriegsende .
+Wellesley wurde am 11. Mai 1814 vom Prinzregenten in Vertretung von dessen Vater Georg III . , zum ( ersten ) Duke of Wellington ernannt .
+Datei : Heaphy Duke of Wellington BomannMuseum@20150903.JPG
+Der Herzog nahm im Frühjahr 1815 unter Lord Castlereagh auch an mehreren Sitzungen des Wiener Kongress teil .
+Im Februar wurde Wellington nach dessen Abberufung nach England , Hauptbevollmächtigter in Wien , bevor er März 1815 nach der Rückkehr Napoleons aus Elba den Oberbefehl im neuen Krieg gegen Frankreich erhielt .
+Im Raum Brüssel sammelte Wellington das verbündete Heer gegen Napoleon , darunter nur etwa 35.000 Briten und wartete die geplante Vereinigung mit den Preußen ab .
+Am 18. Juni in der Schlacht von Waterloo ( auch „ Schlacht von Belle-Alliance “ ) von Napoleon angegriffen , hielten Wellingtons Truppen den französischen Angriffen solange erfolgreich stand , bis die Ankunft der Preußen den Sieg der Alliierten entschied .
+Das bekannte Zitat „ Ich wollte , es wäre Nacht , oder die Preußen kämen “ wird Wellesley beim Warten auf die Ankunft Blüchers zugeschrieben , ist aber nicht verbürgt .
+Die Schlacht ging mit der Hilfe Blüchers zu Wellesleys Gunsten aus , Napoleon zog sich geschlagen zurück , für ihn bedeutete diese Schlacht das Ende seiner militärischen Karriere .
+Wellington hingegen wurde von den Briten als Held gefeiert , unter den Militärstrategen galt er fortan als Meister der Defensive .
+1827/28 und noch einmal von 1842 bis zu seinem Tod war Wellesley Oberbefehlshaber der britischen Armee .
+Ab 1829 hatte er auch das Amt des Lord Warden of the Cinque Ports inne .
+Nach seinem Tod wurde er am 18. November 1852 in einem Staatsbegräbnis in der Krypta der St Paul ’ s Cathedral beigesetzt .
+Im Hauptschiff der Kathedrale wurde ihm ein monumentales Grabdenkmal gesetzt .
+Politisches Leben Datei : Wellington Monument ( from 250 Views Of London ) . jpg Im Jahr 1806 zog er als Abgeordneter für den Wahlkreis Rye in Sussex ins britische House of Commons ein .
+1807 wurde er Chief Secretary for Ireland , dieses Amt gab er jedoch noch im gleichen Jahr zugunsten seiner militärischen Karriere wieder auf .
+Nach dem Wiener Kongress wandte er sich wieder einer politischen Laufbahn zu und erhielt 1818 ein Amt in der Tory-Regierung unter Lord Liverpool .
+Am 17. August 1827 wurde er Oberkommandierender der britischen Armee , doch übernahm er 1828 nach dem Tod von Canning und dem Sturz von Lord Goderich widerstrebend das Amt des Premierministers .
+Er führte eine erzkonservative Regierung und eine isolationistische Politik .
+So beendete er trotz des Siegs in der Schlacht von Navarino die Unterstützung des griechischen Freiheitskampfes .
+Infolge dieser Politik lehnte Prinz Leopold die ihm angebotene griechische Krone ab .
+Innenpolitisch setzte Wellington gegen große innerparteiliche Widerstände 1829 das Wahlrecht für Katholiken durch .
+Gleichzeitig versuchte er eine weitere Wahlrechtsreform zu verhindern , weswegen er bei weiten Teilen der Bevölkerung höchst unpopulär wurde .
+Die Verzögerung der Wahlrechtsreform und seine Unbeliebtheit weiteten sich zu Unruhen aus .
+Dennoch erklärte er in völliger Verkennung der Lage bei der Parlamentseröffnung nach dem Tod Georgs IV . , dass er eine Wahlrechtsreform weiter ablehne .
+Diese Erklärung führte zum Sturz seiner Regierung am 22. November 1830 .
+Sein Nachfolger als Premierminister Earl Grey nahm sofort eine Wahlrechtsreform in Angriff und brachte am 1. März 1831 gegen den Widerstand Wellingtons den Reform Act ins Unterhaus ein .
+Nachdem das Gesetz das House of Commons passiert hatte , verweigerte das House of Lords am 8. Oktober 1831 seine Zustimmung .
+Trotz der Gefahr eines drohenden revolutionären Umsturzes blockierte das Oberhaus das Gesetz weiter .
+Am 9. Mai 1832 wurde Wellington erneut zum Regierungschef ernannt .
+Wilhelm IV . bewog ihn , ein gemäßigtes Kabinett zu bilden .
+Da zahlreiche Sparer aus Protest ihre Einlagen aus der Bank of England abzogen , drohte eine Finanzkrise , so dass Wellington schon am 15. Mai wieder aufgab .
+Sein Nachfolger wurde wieder Earl Grey , unter dem am 4. Juni 1832 die Wahlrechtsreform vom Oberhaus verabschiedet wurde .
+Die nächsten beiden Jahre verbrachte Wellington in der Opposition .
+Bei der Trauerfeier für Lord Althorp im Oberhaus entließ Wilhelm IV .
+unerwartet das Whig-Kabinett und beauftragte Wellington am 17. November 1834 mit der Bildung einer Minderheitsregierung .
+Dieser schlug schließlich Robert Peel , seinen langjährigen politischen Weggefährten , als Premierminister vor , während er das Amt des Außenministers übernahm .
+Dies war die letzte britische Regierung , die ein Monarch ohne Mehrheit im Unterhaus ernannte und sie scheiterte schon im April 1835 .
+Peel wurde im September 1841 erneut zum Premierminister ernannt , und Wellington wurde in dieser Regierung als Oberkommandierender der Armee Minister ohne Geschäftsbereich sowie Leader des House of Lords .
+Als Peel 1846 zurücktrat , legte auch Wellington am 27. Juni sein Amt als Leader nieder und zog sich aus der Öffentlichkeit zurück .
+Das Amt des Oberbefehlshabers der Armee behielt er allerdings bis zu seinem Tod .
+Datei :D uke of Wellington Photo.jpg
+Privatleben Datei : Wellington.jpg 1805 heiratete er Kitty Pakenham , die Tochter des 2. Baron Longford .
+Eine Verbindung , die ihm noch ein Jahrzehnt zuvor verweigert worden war , da der damalige Sir Arthur dem Brautvater als Ehemann nicht gut genug gewesen war .
+Aus der Ehe gingen folgende Kinder hervor : Arthur Richard Wellesley ( * 3. Februar 1807 ; † 13. August 1884 in Brighton ) , britischer Generalleutnant Charles Wellesley ( * 16. Januar 1808 ; 9. Oktober 1858 ) , britischer Generalmajor Kittys Bruder Ned war in Spanien einer von Wellingtons wichtigsten Generälen .
+Wellington war seit dem 7. Dezember 1790 ein Mitglied im Bund der Freimaurer ( Trim No. 494 ) und gehörte dem renommierten Londoner Travellers Club an .
+Ehrungen und Auszeichnungen Wellington war Knight Companion des Hosenbandordens , Knight Grand Cross des Order of the Bath , Großkreuzritter des Guelphen-Ordens , Mitglied des Privy Council und Mitglied der Royal Society .
+Die HMS Duke of Wellington , ein 131-Kanonen-Schiff der britischen Royal Navy , wurde 1852 nach ihm benannt .
+Sie war das Flaggschiff von Sir Charles Napier , damals Konteradmiral der Blauen Flagge .
+Auch die HMS Iron Duke , das Flaggschiff der Grand Fleet im Ersten Weltkrieg war nach ihm benannt .
+Trivia Das von Wellington favorisierte Design der hessischen Militärstiefel wurde für die ersten britischen Gummistiefel verwendet , weshalb diese in Großbritannien Wellington boots oder kurz Wellingtons genannt werden .
+Nach ihm benannt sind die neuseeländische Hauptstadt Wellington sowie die Stadt Wellington in Südafrika .
+Das für ihn neu geschaffene Herzogtum erhielt seinen Namen nach dem Ort Wellington , Somerset .
+Dort steht auf dem Wellington Hill das Wellington Monument .
+Das Filet Wellington , ein mit Blätterteig umhülltes Rinderfilet , erhielt seinen Namen zu seinen Ehren .
+Als Premierminister machte ihn seine Ablehnung der Wahlrechtsreform so unpopulär , dass er sein Londoner Stadthaus Apsley House mit eisernen Fensterblenden versehen musste , damit ihm der wütende Mob nicht die Scheiben einwarf und weswegen er den Spitznamen Iron Duke erhielt . Dieser Spitzname wurde bereits dreimal für Kriegsschiffe der Royal Navy verwendet und wurde auch in der Perry-Rhodan-Serie verwendet .
+Berühmt war das Pferd von Wellington , Copenhagen .
+Es gibt mehrere Reiterdenkmäler des Herzogs , die ihn auf Copenhagen reitend darstellen .
+2012 erschien der Film Lines of Wellington – Sturm über Portugal , in dem die Geschichte von Wellingtons Linien von Torres Vedras dargestellt werden .
+Darsteller Wellingtons war John Malkovich .
+Er ist auf der Rückseite einer 5 Pfund-Banknote zu sehen .
+2002 wurde er in einer Umfrage der BBC auf Platz 15 der 100 größten Briten gewählt .
+Zitate „ Die Geschichte einer Schlacht schreiben ?
+Man könnte genauso gut die Geschichte einer Ballnacht schreiben wollen . “
+„ Das größte Unglück ist eine verlorene Schlacht , das zweitgrößte eine gewonnene . “
+„ Nichts außer einer verlorenen Schlacht kann halb so melancholisch stimmen wie eine gewonnene Schlacht . “
+„ Geschichte ist jene Fabel bzw. Lüge , auf die man sich geeinigt hat . “
+„ Ich kenne keine Frau , die an Liebeskummer gestorben wäre .
+Sie alle werden ohne größere Schwierigkeiten damit fertig und sehen dabei noch bezaubernd aus . “
+„ Verschiebe nicht auf morgen , was du auch heute tun kannst , denn wenn es dir heute Spaß macht , kannst du es morgen wiederholen . “
+„ Erfahrung ist die Summe der Fehler , die man gemacht hat . “
+„ Das Glück dient der Tüchtigkeit . “
+„ Ich wollte , es würde Nacht oder die Preußen kämen . “ – Unbestätigtes Zitat .
+„ Das geht so nicht .
+Schreiben wir uns einen Sieg . “
+Literatur Michael Glover : Wellington as Military Commander .
+Sphere Books , London 1973 , ISBN 0-7221-3903-9 . Richard Holmes : Wellington .
+The Iron Duke
+.
+HarperCollins , London 2003 , ISBN 0-0071-3748-6 . John Keegan : Die Maske des Feldherrn .
+Quadriga , Berlin 2000 , ISBN 3-88679-283-8 . Elizabeth Longford : Wellington .
+Weidenfeld and Nicolson , London 1992 , ISBN 0-297-81273-4 . Weblinks Number 10 : Duke of Wellington bbc History : Duke of Wellington Einzelnachweise The London Gazette Nr. 16984 vom 3. Mai 1814 , S. 936. Abgerufen am 20. Juli 2012 Wilhelm Liebknecht : Karl Marx zum Gedächtnis . In : Mohr und General . Erinnerungen an Marx und Engels . Dietz Verlag , Berlin 1965 , S. 122. MQ Magazin von Yasha Beresiner ( 9. April 2004 ) . Abgerufen am 21. Mai 2014nach der unentschieden ausgegangenen Schlacht bei Albuera zu General Beresford , der die Schlacht als verloren angesehen hatte 
+
+Datei : Ing telescopes sunset la palma july 2001.jpg Die Astronomie ( griechisch für „ Sternenkunde “ , von ástron „ Stern “ und nómos „ Gesetz “ ) ist die Wissenschaft von den Gestirnen .
+Sie erforscht mit naturwissenschaftlichen Mitteln die Positionen , Bewegungen und Eigenschaften der Objekte im Universum , also der Himmelskörper ( Planeten , Monde , Asteroiden , Sterne einschließlich der Sonne , Sternhaufen , Galaxien und Galaxienhaufen ) , der interstellaren Materie und der im Weltall auftretenden Strahlung .
+Darüber hinaus strebt sie nach einem Verständnis des Universums als Ganzes , seiner Entstehung und seinem Aufbau .
+Obwohl die Astronomie nur an wenigen Schulen ein Unterrichtsfach ist , finden ihre Forschungsergebnisse in der Öffentlichkeit viel Interesse ; als Amateurastronomie ist sie ein weit verbreitetes Hobby .
+Dies hängt einerseits mit dem „ erhebenden “ Eindruck zusammen , den der Sternhimmel auch bei freisichtiger Beobachtung macht , andererseits mit ihrer thematischen Vielfalt , der Berührung philosophischer Fragen und der Verbindung zur Raumfahrt .
+Im Gegensatz zu früheren Zeiten wird die Astronomie als Naturwissenschaft heute streng abgegrenzt von der Astrologie , die aus Stellung und Lauf der Gestirne auf irdische Geschehnisse schließen will .
+Die Abgrenzung erfolgt auch , da viele in der Astrologie eine Pseudowisschenschaft sehen – während die Astronomie auf empirischer Basis die Beschaffenheit , Bewegungen und Beziehungen von Himmelskörpern untersucht .
+Dennoch werden , wohl wegen der Ähnlichkeit beider Bezeichnungen , Astrologie und Astronomie von Laien nicht selten verwechselt .
+An den Universitäten wurde die Astronomie um etwa 1800 zu einer eigenen Studienrichtung , wird aber heute zunehmend dem Physik-Studium zugeordnet .
+In der deutschen Hochschulpolitik wird sie gemeinsam mit der Astrophysik als Kleines Fach eingestuft .
+Geschichte der Astronomie Datei : Equinozio da Pizzo Vento , tramonto fondachelli fantina , sicilia.JPG Datei : Flammarion.jpg Datei : Saturn from Cassini Orbiter ( 2004-10-06 ) . jpg
+Die Astronomie gilt als eine der ältesten Wissenschaften .
+Ihre Anfänge liegen im Nachdenken über die Himmelserscheinungen , in der kultischen Verehrung der Gestirne und im Erarbeiten von Kalender bzw. Zeitbestimmung In einem jahrtausendelangen Prozess – besonders gut erkennbar in der Himmelskunde Mesopotamiens und Griechenlands – trennten sich zunächst Astronomie und ( „ Natur “ ) - Religion , später Astronomie und Meteorologie , in der Frühmoderne dann Astronomie und Astrologie .
+Wesentliche Meilensteine für unser Wissen über das Weltall waren die Erfindung des Fernrohrs vor etwa 400 Jahren , das die kopernikanische Wende vollendete , sowie später im 19. Jahrhundert die Einführung der Fotografie und Spektroskopie .
+Seit den 1960er-Jahren haben Astronomen mit der unbemannten und bemannten Raumfahrt die Möglichkeit , die Erdatmosphäre zu überwinden und ohne ihre Einschränkungen zu beobachten – also ohne Luftunruhe und in allen Bereichen des elektromagnetischen Spektrums .
+Dazu kommt erstmals die Möglichkeit , die untersuchten Objekte direkt zu besuchen und dort andere als nur rein beobachtende Messungen durchzuführen .
+Parallel dazu werden immer größere Teleskope für bodengebundene Beobachtungen gebaut .
+Fachgebiete der Astronomie Datei : Messier51.jpg Die astronomische Wissenschaft unterteilt sich allgemein nach den untersuchten Objekten , sowie danach , ob die Forschung theoretischer oder beobachtender Natur ist .
+Wichtige grundlegende Fachgebiete sind die beobachtende Astronomie , die Astrophysik , die Astrometrie und die Himmelsmechanik , während die theoretische Astronomie analytische und numerisch-physikalische Modelle der Himmelskörper und Phänomene entwickelt .
+Die wichtigsten Untersuchungsgebiete der Himmelskunde sind die Physik des Sonnensystems , insbesondere die Planetologie , die Galaktische Astronomie , die die Milchstraße und ihr Zentrum erforscht , die Extragalaktische Astronomie , die den Aufbau anderer Galaxien und ihrer aktiven Kerne , oder Gammablitze als die energiereichsten Vorgänge im Universum untersucht , sowie die relativistische Astrophysik , die sich etwa mit Schwarzen Löchern beschäftigt .
+Die Stellarastronomie untersucht Geburt , Entwicklung und Tod der Sterne .
+Die Kosmologie hat die Geschichte und die Entstehung des Universums zum Gegenstand , während die Kosmogonie die Geschichte unseres eigenen Sonnensystems beschreibt .
+Sie erlebt derzeit eine Erweiterung durch das neueste Fachgebiet Exoplanetologie .
+Die Integration vieler Messmethoden bringt es mit sich , dass man die Beobachtende Astronomie immer weniger nach benutzten Wellenlängenbereichen ( Radioastronomie , Infrarotastronomie , Visuelle Astronomie , Ultraviolettastronomie , Röntgenastronomie und Gammaastronomie ) einteilt , weil die Forschergruppen und ( im Idealfall ) auch der einzelne Wissenschaftler Informationen aus allen diesen Quellen heranziehen kann .
+Die bis etwa 1900 vorherrschenden Methoden der klassischen Astronomie sind weiterhin als Basis für andere Teilgebiete unentbehrlich .
+Sie erforschen als Positionsastronomie mittels astrometrischer Verfahren , der Himmelsmechanik und Stellarstatistik den Aufbau des Weltalls und katalogisieren die Himmelskörper ( v. a.
+durch Sternkataloge , Bahnbestimmungen und Ephemeriden ) .
+Im Gegensatz zu diesen überwiegend geometrischen Verfahren erforscht die Astrophysik mit ihren heute sehr vielfältigen Beobachtungstechniken die Physik der astronomischen Objekte und des ferneren Weltalls .
+Daneben kann die Raumfahrt als experimentelle Astronomie angesehen werden , und die Kosmologie als theoretische Disziplin .
+Astronomie und andere Wissenschaften Datei : Ring Nebula.jpg Mit der Astronomie sehr eng verbunden sind die Physik und die Mathematik ; die Fachgebiete haben sich vielfach befruchtet und sind auch im Astronomie-Studium als Einheit zu sehen .
+Das Universum erweist sich in vielen Fällen als Laboratorium der Physik , viele ihrer Theorien können nur in seinen Weiten und an heißen , energiereichen Objekten getestet werden .
+Nicht zuletzt waren die aufwändigen Berechnungen der Astronomie Triebfeder der modernen numerischen Mathematik und der Datenverarbeitung .
+Traditionell ist die Zusammenarbeit der Astronomie mit der Geodäsie ( Astrogeodäsie , Orts- und Zeitbestimmung , Bezugsysteme , Navigation ) , mit der Zeit- und Kalenderrechnung ( Astronomische Chronologie ) sowie mit der Optik ( Entwicklung astronomischer Instrumente und Sensoren ) .
+Instrumentell und methodisch sind auch starke Bezüge zur Technik , Raumfahrt und Mathematik gegeben ( Messgeräte , Satellitentechnik , Modellierung von Bahnen und Himmelskörpern ) .
+Geodätische Methoden werden auch zur Bestimmung des Gravitationsfeldes sowie der Figur anderer Himmelskörper angewandt .
+In den letzten Jahrzehnten ist auch die Zusammenarbeit der Astronomie mit der modernen Geologie und der Geophysik immer wichtiger geworden , da sich das Arbeitsgebiet der Geowissenschaften mit Teilen der Planetologie deckt .
+Die Mineralogie analysiert die Gesteine der Erde mit ähnlichen Methoden wie jene anderer Himmelskörper .
+Die Kosmochemie als Teil der Chemie untersucht die Entstehung und Verteilung der chemischen Elemente und Verbindungen im Universum und die chemische Evolution , die Astrobiologie die Umstände von Entstehung , Ursprung und Existenz von Leben im Universum .
+Des Weiteren kommt es zunehmend zu interdisziplinärer Forschung mit ursprünglich eher geisteswissenschaftlich ausgerichteten Disziplinen der Wissenschaft : Die Astronomiegeschichte als Teil der Geschichtswissenschaften untersucht die Geschichte der Astronomie .
+Bauten und Funde aus vor- und frühgeschichtlicher Zeit werden vermehrt in astronomischem Zusammenhang interpretiert ( Archäoastronomie ) .
+Da sich die Astronomie außerdem im Rahmen der Kosmologie mit den Fragen nach der Entstehung , der Entwicklung und dem Ende des Universums beschäftigt , gibt es darüber hinaus Schnittpunkte zu Theologie und Philosophie .
+Siehe auch Astrophysik
+Astronomiepark
+Amateurastronomie
+Internationales Jahr der Astronomie 2009
+Literatur Einzelwerke Albrecht Unsöld , Bodo Baschek : Der neue Kosmos . ISBN 3-540-42177-7 Alfred Weigert , Heinrich Johannes Wendker , Lutz Wisotzki : Astronomie und Astrophysik .
+Ein Grundkurs .
+Wiley-VCH , Weinheim 2010 , ISBN 978-3-527-40793-4 . Jeffrey Bennett et al. : Astronomie .
+Die kosmische Perspektive
+( Hrsg. Harald Lesch ) , 5. , aktualisierte Auflage 2010 . Pearson Studium Verlag , München , ISBN 978-3-8273-7360-1 Meyers Handbuch Weltall , Wegweiser durch die Welt der Astronomie .
+1994 ( 7. , überarbeitete Auflage ) , ISBN 3-411-07757-3 P. Murdin ( Hrsg. ) : Encyclopedia of Astronomy & Astrophysics .
+2001 , ISBN 0-333-75088-8 – http://eaa.crcpress.com/
+Der Brockhaus Astronomie : Planeten , Sterne , Galaxien .
+F. A. Brockhaus , Mannheim – Leipzig 2006 , ISBN 3-7653-1231-2 Joachim Herrmann : dtv-Atlas Astronomie , 15. Auflage 2005 .
+Deutscher Taschenbuch-Verlag München , ISBN 3-423-03267-7 Kurt Hopf : Von der Erde ins All – Das Weltall in Beispielen – Didaktische Materialsammlung auf CD-ROM für Kindergärten , Schulen , Sternwarten und Planetarien , COTEC-Verlag Rosenheim Harry Nussbaumer : Das Weltbild der Astronomie .
+2007 , ISBN 978-3-7281-3106-5 , 2. , erweiterte und aktualisierte Auflage .
+vdf Hochschulverlag .
+M. Wächter : Kleine Entdeckungsgeschichte ( n ) der Astronomie im Kontext von Zeitgeschichte und Physik , Verlag Königshausen und Neumann , Würzburg 2018 , ISBN 978-3-8260-6511-8 R. A.
+Freedman , W. J.
+Kaufmann : Universe .
+Freeman , NY 2004 , ISBN 0-7167-9884-0 Arnold Hanslmeier : Einführung in Astronomie und Astrophysik . Spektrum Akad .
+Verl. , Berlin 2007 , ISBN 978-3-8274-1846-3 Hans-Ulrich Keller : Kompendium der Astronomie : Einführung in die Wissenschaft vom Universum . Franckh-Kosmos , 6. aktual .
+& erw. Auflage , Stuttgart 2019 , ISBN 978-3-440-16276-7 Periodika Siehe auch : Abschnitt Literatur unter Amateurastronomie
+Sterne und Weltraum , Monatszeitschrift für Astronomie Sternenbote , österreichische Monatszeitschrift für Astronomie Interstellarum , ehemalige 2-Monats-Zeitschrift für Astronomie Astronomie + Raumfahrt , 2-Monats-Zeitschrift für Unterricht , Fortbildung , Freizeit Orion , 2-Monats-Zeitschrift der Schweizerischen Astronomischen Gesellschaft Regiomontanusbote , Quartalsschrift der Nürnberger Astronomischen Gesellschaft und Nürnberger Astronomischen Arbeitsgemeinschaft , Weblinks Weltraumbild des Tages ( APOD ) – Deutsche Übersetzung von Astronomy Picture of the Day
+NASA ADS – Datenbank astronomischer Forschungsliteratur ( englisch ) Astronomie.de – Deutschsprachige Website über Astronomie AstroSkript – eine freie Einführung in die Astronomie – E-Book zum Download ( PDF-Datei ; 6,92 MB ) sternsucher.com – Astronomie für Einsteiger und Fortgeschrittene mit Blog und Tipps für die eigene Beobachtung Astrotreff-Deep-Sky.de – Informationen zum Einstieg in das Hobby Astronomie Videos Vorlesung Einführung in die Astronomie I und Einführung in die Astronomie II .
+Videoaufzeichnungen von zwei Vorlesungen .
+Von TIMMS , Tübinger Internet Multimedia Server der Eberhard Karls Universität Tübingen .
+Einzelnachweise siehe Website der Arbeitsstelle Kleine Fächer über Astronomie und Astrophysik , abgerufen am 17. August 2015 Dazu im Schöpfungsbericht der Genesis 1,14 : Und Gott sprach : Lichter sollen am Himmelsgewölbe sein , um Tag und Nacht zu scheiden [ ... ] und zur Bestimmung von Festzeiten , von Tagen und Jahren dienen [ ... ] . Vgl. z. B. Ferenc Némethy : Astronomisches und medizinisches Doppelfragment zu Budapest . Untersuchung der lateinischen und der deutschen Handschrift im Kodex 19167/S.91 der Semmelweis-Bibliothek für Geschichte der Medizin ( mit kritischer Textausgabe ) , Würzburg 1998 ( = Würzburger medizinhistorische Forschungen , 26 ) 
+
+Datei : Angelina Jolie 2 June 2014 ( cropped ) . jpg Angelina Jolie [ ] , DCMG ( * 4. Juni 1975 als Angelina Jolie Voight in Los Angeles , Kalifornien ) ist eine US-amerikanische Schauspielerin , Filmregisseurin , Filmproduzentin und Drehbuchautorin .
+Während ihrer Ehe mit Brad Pitt trug sie den Namen Angelina Jolie Pitt .
+Sie wurde mit der Darstellung der Videospielheldin Lara Croft in Lara Croft : Tomb Raider ( 2001 ) international bekannt .
+Weitere kommerzielle Erfolge hatte sie mit den Filmen Mr.
+& Mrs. Smith
+( 2005 ) , Wanted ( 2008 ) , Salt ( 2010 ) und Maleficent – Die dunkle Fee ( 2014 ) .
+Für ihre schauspielerischen Leistungen erhielt Jolie drei Golden Globes , zwei Screen Actors Guild Awards und für ihre Rolle einer psychisch Kranken in dem Film Durchgeknallt ( 1999 ) einen Oscar als beste Nebendarstellerin .
+Mit dem Kriegsdrama In the Land of Blood and Honey gab Jolie 2011 ihr Debüt als Spielfilmregisseurin und Drehbuchautorin .
+Sie ist zudem Sondergesandte des UN-Flüchtlingshochkommissars Filippo Grandi , Mitglied des Council on Foreign Relations und war Sonderbotschafterin für das UNO-Hochkommissariat für Flüchtlinge .
+Frühe Jahre Herkunft Angelina Jolie ist die Tochter der Schauspieler Jon Voight und Marcheline Bertrand .
+Sie ist die jüngere Schwester des Schauspielers James Haven und die Nichte des Songwriters Chip Taylor .
+Ihre Taufpaten sind die Schauspieler Jacqueline Bisset und Maximilian Schell . Jolie hat deutsche und slowakische Vorfahren väterlicherseits sowie frankokanadische , niederländische , deutsche und angeblich irokesische Vorfahren mütterlicherseits . Letzteres wurde von Jon Voight in einem Interview allerdings bestritten .
+Die irokesische Abstammung Bertrands sei erfunden worden , um ihr aus Karrieregründen ein exotisches Image zu verleihen . Ein Urgroßelternpaar Jolies stammt aus Büren in Westfalen , ein anderes aus Košice in der Slowakei .
+Kindheit Jolies Eltern , die am 12. Dezember 1971 geheiratet hatten , trennten sich 1976 .
+Bertrand reichte 1978 die Scheidung ein , die am 14. April 1980 rechtskräftig wurde . Nach der Trennung ihrer Eltern wuchs Jolie zusammen mit ihrem Bruder bei ihrer Mutter auf , die ihre eigenen Schauspielambitionen aufgab und mit den Kindern und ihrem neuen Lebensgefährten Bill Day nach Palisades in den US-Bundesstaat New York zog , wo Jolie im Nachbarort Tappan die William O. Schaefer Elementary School besuchte . Zeit mit ihrem Vater verbrachte Jolie daraufhin meist nur während der Schulferien oder wenn er sie und ihren Bruder zu Dreharbeiten mitnahm . Jolie erklärte später , dass nicht ihr berühmter Vater , der 1979 für seine Rolle in dem Film Coming Home – Sie kehren heim ( 1978 ) den Oscar als bester Hauptdarsteller gewann , ihr Interesse an der Schauspielerei geweckt habe , sondern die regelmäßigen Kino- und Theaterbesuche mit ihrer Mutter und ihrem Bruder während ihrer Kindheit .
+Schulzeit Als Jolie elf Jahre alt war , zog die Familie zurück nach Los Angeles . Dort besuchte sie bis 1989 die El Rodeo Elementary School im Stadtteil Beverly Hills . In ihrer Zeit an der Beverly Hills High School fühlte sie sich oftmals isoliert unter ihren Mitschülern , die größtenteils aus wohlhabenden Familien stammten , während ihre Mutter mit einem bescheidenen Einkommen auskommen musste .
+Jolie trug Kleidung aus Secondhand-Läden und wurde von anderen Schülern auf Grund ihrer ausgeprägten Gesichtszüge und äußerst schlanken Erscheinung geneckt .
+Mit wachsender Unzufriedenheit durchlebte sie in ihrer Jugend eine Phase autoaggressiven Verhaltens ; sie beschrieb dies später mit den Worten : „ Ich sammelte Messer und hatte immer bestimmte Dinge um mich .
+Aus irgendeinem Grund war das Ritual , mich selbst zu schneiden und die Schmerzen zu spüren , vielleicht sich lebendig zu fühlen und ein Gefühl der Befreiung zu verspüren , irgendwie therapeutisch für mich . “ Heute blickt Jolie auf diese Phase ihres Lebens mit der Bemerkung zurück : „ Im Herzen bin ich noch immer nur ein Punk-Kid mit Tattoos . “ Erster Schauspielunterricht Neben der Schule nahm Jolie Schauspielunterricht am Lee Strasberg Theatre and Film Institute , an dem sie zwei Jahre lang das Method Acting erlernte und in mehreren Bühnenproduktionen auftrat .
+Mit 14 Jahren erhielt sie einen Vertrag als Fotomodell bei der Agentur Finesse Model Management ; ihre Versuche , in diesem Geschäft Fuß zu fassen , blieben jedoch ohne nennenswerten Erfolg .
+Mit 16 Jahren machte Jolie im Rahmen eines eigenverantwortlichen Lernprogramms vorzeitig ihren Schulabschluss und mietete sich ein eigenes Apartment in der Nähe der Wohnung ihrer Mutter .
+Sie dachte einige Zeit darüber nach , Bestattungsunternehmerin zu werden , nachdem ihr Großvater gestorben war , entschied sich aber letztlich doch für die Schauspielerei .
+Karriere Karrierebeginn ( 1980 bis 1997 ) In Zwei in der Tinte stand Jolie gemeinsam mit ihren Eltern zum ersten Mal für einen Film vor der Kamera . Während ihr Vater in der Komödie an der Seite von Ann-Margret die männliche Hauptrolle spielte , waren Jolie und ihre Mutter in kleineren Nebenrollen zu sehen .
+Voight beschrieb das Verhalten seiner damals fünfjährigen Tochter während der Dreharbeiten im Jahr 1980 als „ gelangweilt “ . „ Sie war nicht gerade begeistert , mitzuwirken .
+Aber sie hat uns die Schau gestohlen , weil sie so ehrlich und echt war . “
+Ihre ersten professionellen Engagements als Schauspielerin erhielt Jolie in den Musikvideos zu Lenny Kravitz ’ Stand by My Woman , Antonello Vendittis Alta Marea ( beide 1991 ) , The Lemonheads ’ It ’ s About Time und Meat Loafs Rock and Roll Dreams Come Through ( beide 1993 ) .
+Außerdem stand sie für fünf Studentenfilme ihres Bruders vor der Kamera , als dieser die USC School of Cinematic Arts in Los Angeles besuchte .
+Sie spielte auch in den Kurzfilmen Angela & Viril sowie Alice & Viril ( beide 1993 ) von Regisseur Steven Shainberg mit .
+In dem darauf folgenden Low-Budget-Film Cyborg 2 ( 1993 ) verkörperte sie einen menschenähnlichen Roboter , der darauf programmiert ist , sich mit Verführungskünsten den Weg ins Hauptquartier des Feindes zu bahnen und dort zu explodieren .
+Jolie über den Film : „ Nachdem ich ihn gesehen hatte , ging ich nach Hause und musste mich übergeben . “ Die New York Times schrieb jedoch über ihre Darstellung : „ Auch wenn sich ihr Schauspiel in Cyborg 2 noch in seiner Versuch und Irrtum-Phase befand , enthielt es bereits die Saat ihrer heutigen Darstellungsweise .
+Bereits als Teenager [ … ] wusste Jolie , die Leinwand mit ihrer Präsenz auszufüllen . “
+Nach einer Rolle in dem Thriller Without Evidence ( 1995 ) spielte Jolie an der Seite von Jonny Lee Miller und Matthew Lillard die Hackerin Kate „ Acid Burn “ Libby in dem Spielfilm Hackers – Im Netz des FBI ( 1995 ) .
+Die New York Times schrieb : „ Kate ( Angelina Jolie ) fällt auf .
+Sie zieht ein noch mürrischeres Gesicht als die übrigen Darsteller und sie ist diese seltene Hackerin , die bewusst in einem durchsichtigen Top an ihrer Tastatur sitzt .
+Trotz ihres verdrießlichen Auftretens , und das ist alles , was die Rolle erfordert , hat Frau Jolie das süße engelhafte Aussehen ihres Vaters Jon Voight geerbt . “ Der Film spielte keinen Gewinn ein , entwickelte sich aber zu einem Kulthit , nachdem er auf Video erschienen war .
+In der Komödie Liebe und andere … ( 1996 ) , einer modernen Adaption von Romeo und Julia unter zwei rivalisierenden italienischen Restauranteigentümern in der New Yorker Bronx , trat sie in der Rolle der Gina Malacici vor die Kamera .
+Im Roadmovie Nichts als Trouble mit den Frauen ( 1996 ) spielte sie den Teenager Eleanor Rigby , der sich in Danny Aiellos Filmfigur verliebt , während dieser versucht , ihre Mutter ( Anne Archer ) zu erobern .
+Im Jahr 1996 erschien sie außerdem in dem Film Foxfire als Margret „ Legs “ Sadovsky , eines von fünf Mädchen , die einen ungewöhnlichen Bund eingehen , nachdem sie einen Lehrer zusammengeschlagen haben , der sie sexuell belästigt hatte .
+Die Los Angeles Times schrieb über Jolies Leistung : „ Es bedurfte einer Menge , diese Figur zu entwickeln , aber Jolie , Jon Voights umwerfende Tochter , hat die Präsenz , das Stereotyp zu überwinden .
+Obwohl die Geschichte von Maddy erzählt wird , ist Legs das Thema und der Katalysator . “
+1997 spielte Jolie zusammen mit David Duchovny in dem Thriller Playing God .
+Der Film erzählt die Geschichte eines Chirurgen , der seine Approbation verliert und tief in die kriminelle Unterwelt hineingezogen wird , wo er Jolies Figur Claire trifft .
+Der Film fand bei den Kritikern wenig Beifall , sodass Roger Ebert zu erklären versuchte : „ Angelina Jolie findet eine gewisse Wärme in einer Rolle , die normalerweise hart und aggressiv ist ; sie erscheint zu nett , um die Freundin eines Verbrechers zu sein , und vielleicht ist sie es auch . “ Danach wirkte sie in dem Fernsehfilm True Women ( 1997 ) mit , einem historisch-romantischen Drama im Wilden Westen , basierend auf dem gleichnamigen Roman von Janice Woods Windle .
+Im selben Jahr spielte sie außerdem eine Stripperin in dem Musikvideo der Rolling Stones zu Anybody Seen My Baby ?
+Schauspielerischer Durchbruch ( 1998–2000 ) Jolies Karriere erhielt Auftrieb , als sie 1998 für ihre Rolle in der Filmbiografie Wallace mit dem Golden Globe als Beste Nebendarstellerin in einem Fernsehfilm ausgezeichnet wurde und eine Nominierung für den Emmy erhielt .
+Unter der Regie von John Frankenheimer sowie an der Seite von Gary Sinise und Mare Winningham verkörperte Jolie in dem Film Cornelia Wallace , die zweite Ehefrau von George Wallace , seinerzeit Gouverneur von Alabama und Anhänger der Rassentrennung , der angeschossen und querschnittsgelähmt wurde , als er für die US-amerikanische Präsidentschaft kandidierte .
+1998 spielte Jolie im HBO-Projekt Gia – Preis der Schönheit , einem Fernsehfilm über das Leben des lesbischen Supermodels Gia Carangi mit .
+Der Film beschreibt eine Welt von Sex und Drogen sowie Carangis emotionalen Niedergang und ihren Tod durch AIDS .
+Vanessa Vance von Reel.com schrieb : „ Angelina Jolie erntete große Anerkennung für ihre Rolle als Gia , und es ist leicht zu verstehen warum .
+Jolie ist ergreifend in ihrer Darstellung , die den Film mit Nerv , Charme und Verzweiflung füllt , und ihre Rolle ist möglicherweise das schönste Wrack , das jemals gefilmt wurde . “ Jolie gewann ihren zweiten Golden Globe und erhielt erneut eine Nominierung für den Emmy , außerdem ihren ersten Screen Actors Guild Award .
+Jolie zog es in ihren Anfangsjahren häufig vor , entsprechend Lee Strasbergs Method Acting auch in Drehpausen vollkommen in ihrer Rolle zu bleiben .
+Während der Dreharbeiten zu Gia erklärte sie ihrem damaligen Ehemann Jonny Lee Miller , sie sei nicht in der Lage , ihn anzurufen .
+„ Ich sagte ihm : ‚ Ich bin allein ; ich sterbe ; ich bin lesbisch ; ich werde dich in den nächsten Wochen nicht sehen . ‘ “
+Nach Gia zog Jolie kurzzeitig nach New York , da sie das Gefühl hatte , sie habe „ nichts mehr zu geben . “ Sie schrieb sich an der New York University ein , um Film zu studieren , und besuchte Kurse für Drehbuchautoren .
+Später beschrieb sie diese Zeit als „ einfach gut , um mich selbst zu finden . “ 1998 kehrte sie als Gloria McNeary in dem Gangsterfilm Hell ’ s Kitchen – Vorhof zur Hölle auf die Leinwand zurück und trat im selben Jahr auch als junge Partygängerin Joan in dem Episodenfilm Leben und lieben in L. A. auf .
+Das Ensemble umfasste unter anderem Sean Connery , Gillian Anderson , Ryan Phillippe und Jon Stewart .
+Der Film erhielt überwiegend positive Kritiken und Jolie erntete besonderes Lob .
+Der San Francisco Chronicle schrieb : „ Jolie , die sich durch ein überzogenes Skript kämpft , ist eine Sensation als die verzweifelte Klubgängerin , die lernen muss , was sie bereit ist , aufs Spiel zu setzen . “ Das amerikanische National Board of Review zeichnete sie als beste Nachwuchsdarstellerin aus .
+1999 erschien sie neben John Cusack , Billy Bob Thornton und Cate Blanchett in Mike Newells Komödiendrama Turbulenzen – und andere Katastrophen , ein Film über die Rivalität zweier Fluglotsen .
+Sie spielte Thorntons verführerische Ehefrau Mary Bell , und im darauffolgenden Jahr heiratete sie Thornton auch im echten Leben .
+Der Film hinterließ gemischte Reaktionen , Jolies Figur wurde besonders kritisiert .
+Die Washington Post schrieb : „ Mary ( Angelina Jolie ) ist eine völlig lächerliche Autorenkreation ; eine Frau , die über sterbende Hibiskuspflanzen weint , eine Menge türkiser Ringe trägt und furchtbar einsam wird , wenn ihr Mann nachts nicht nach Hause kommt . “ Dann arbeitete sie mit Denzel Washington zusammen in Der Knochenjäger ( 1999 ) , einer Adaption des gleichnamigen Romans von Jeffery Deaver .
+Sie spielte Amelia Donaghy , eine Polizeibeamtin , die vom Suizid ihres Vaters gequält wird und nur widerwillig zustimmt , dem ehemaligen Detective Rhyme zu helfen , einen Serienmörder zu jagen .
+Der Film spielte weltweit 151 Mio. US-Dollar ein , wurde jedoch überwiegend negativ besprochen .
+Die Detroit Free Press schrieb : „ Jolie , auch wenn sie immer köstlich anzusehen ist , ist schlicht und einfach fehlbesetzt . “
+Danach nahm Jolie die Nebenrolle Lisa Rowe in Durchgeknallt ( 1999 ) an .
+Der Film erzählt die Geschichte der Psychiatriepatientin Susanna Kaysen und basiert auf Kaysens Memoiren Girl , Interrupted .
+Das Psychodrama war ursprünglich als Comeback für die Hauptdarstellerin Winona Ryder konzipiert , wurde stattdessen aber zu Jolies endgültiger Etablierung in Hollywood .
+Sie gewann ihren dritten Golden Globe , ihren zweiten Screen Actors Guild Award und den Oscar als beste Nebendarstellerin .
+Variety schrieb , „ Jolie ist ausgezeichnet als das extravagante , unverantwortliche Mädchen , das sich letztendlich als viel entscheidender für Susannas Rehabilitation erweist als die Ärzte “ und Roger Ebert urteilte über ihre Leistung : „ Jolie entwickelt sich zu einem der großen Freigeister gegenwärtiger Filme , eine lose Kanone , die dennoch tödlich ins Ziel trifft . “
+Im Sommer 2000 spielte Jolie in ihrem ersten Blockbuster , Nur noch 60 Sekunden die Rolle der Sarah „ Sway “ Wayland , die Ex-Freundin eines Autodiebs , der von Nicolas Cage verkörpert wird .
+Die Rolle war verhältnismäßig klein und die Washington Post kritisierte : „ Alles was sie in diesem Film tut , ist herumstehen , sich abkühlen und ihre fleischigen , pulsierenden Muskelröhren zur Schau stellen , die so provozierend um ihre Zähne herum nisten . “ Sie erklärte später , der Film sei für sie nach der anstrengenden Rolle in Durchgeknallt eine willkommene Abwechslung gewesen – und es wurde zunächst ihr kommerziell erfolgreichster Film mit einem internationalen Einspielergebnis von 237 Mio. US-Dollar .
+Internationaler Erfolg ( seit 2001 ) Obwohl sie nach dem Oscargewinn für ihre schauspielerischen Fähigkeiten bekannt war , hatten ihre Filme bis dahin selten ein breites Publikum erreicht , doch Lara Croft : Tomb Raider ( 2001 ) machte sie zu einem internationalen Superstar .
+Die Titelrolle des bekannten Videospiels verlangte von Jolie einen britischen Akzent und ein umfassendes Martial-Arts-Training .
+Sie erhielt große Anerkennung für ihre Darbietung , der Film wurde jedoch allgemein negativ aufgenommen .
+Das Slant Magazine schrieb : „ Angelina Jolie wurde geboren , um Lara Croft zu spielen , aber Regisseur Simon West erlaubt ihr nur einen Ausflug in ein billiges Computerspiel . “ Der Film wurde trotzdem zu einem großen internationalen Erfolg , er spielte weltweit 275 Millionen US-Dollar ein und begründete Jolies Reputation als weiblicher Action-Star .
+Anschließend erschien Jolie als Katalogbraut Julia Russell neben Antonio Banderas in Original Sin ( 2001 ) , einem auf Cornell Woolrichs Roman Waltz into Darkness basierenden Thriller .
+Der Film fiel bei der Kritik weitgehend durch und die New York Times bemerkte : „ Die Geschichte sinkt steiler in sich zusammen als Frau Jolies gewagtes Dekolleté . “ 2002 spielte sie Lanie Kerrigan in Leben oder so ähnlich , einem Film über eine ehrgeizige Fernsehreporterin , der prophezeit wird , binnen einer Woche zu sterben .
+Der Film erhielt negative Kritiken , auch wenn Jolies Spiel häufig positiv hervorgehoben wurde .
+Paul Clinton von CNN urteilte : „ Jolie ist ausgezeichnet in ihrer Rolle .
+Trotz eines teilweise lächerlichen Plots in der Mitte des Films ist die Oscar-gekrönte Schauspielerin äußerst glaubhaft in ihrer Selbstfindung um die wahre Bedeutung vom erfüllten Leben . “
+Datei : Angelina Jolie Cannes 2007.jpg Jolie kehrte 2003 in ihrer Rolle als Lara Croft in Lara Croft : Tomb Raider – Die Wiege des Lebens zurück .
+Die Fortsetzung erwies sich als weniger erfolgreich als der erste Teil , spielte aber dennoch 157 Mio. US-Dollar an den internationalen Kinokassen ein . Im selben Jahr trat sie außerdem in Jenseits aller Grenzen auf , einem Film über humanitäre Hilfe in Afrika .
+Der Film fiel bei Kritikern und Publikum durch und Jolie wurde für die Goldene Himbeere als schlechteste Schauspielerin nominiert .
+Die Los Angeles Times schrieb : „ Jolie kann Lebhaftigkeit und Glaubwürdigkeit in Figuren bringen , die eine für sie nachvollziehbare Realität haben , wie sie es in ihrer Oscar-Rolle in ‚ Durchgeknallt ‘ bewies .
+Sie kann auch bekannte Cartoons spielen , was sie in den Lara-Croft-Filmen zeigte .
+Aber der Limbo eines gespaltenen Charakters , einer schlecht geschriebenen Figur in einer von Fliegen befallenen und mit Blut und Eingeweiden übersäten Welt , besiegt sie völlig . “ Weiterhin war sie im Musikvideo zu Did My Time der Band Korn zu sehen .
+2004 war Jolie zusammen mit Ethan Hawke und Kiefer Sutherland in dem Thriller Taking Lives auf der Leinwand zu sehen .
+Sie spielte Illeana Scott , eine FBI-Profilerin , die die Polizei in Montreal dabei unterstützen soll , einen Serienmörder zu überführen .
+Der Film stieß auf gemischte Reaktionen und brachte ihr eine zweite Himbeeren-Nominierung ein .
+Der Hollywood Reporter schrieb : „ Angelina Jolie spielt eine Rolle , die sich wie etwas anfühlt , das sie schon einmal getan hat , aber sie fügt einen unverkennbaren Schuss von Aufregung und Glamour hinzu . “ Jolie lieferte die Stimme für Lola , einem Fisch im DreamWorks SKG Animationsfilm Große Haie – Kleine Fische ( 2004 ) ; weitere Rollen wurden von Will Smith , Martin Scorsese , Renée Zellweger , Jack Black und Robert De Niro gesprochen .
+Jolie übernahm 2004 auch einen kurzen Gastauftritt als Franky in Sky Captain and the World of Tomorrow neben Jude Law , einem Science-Fiction-Film , der komplett vor einem Bluescreen gedreht wurde und bei dem fast alle Sets und Requisiten in der Nachbearbeitung computergeneriert eingefügt wurden .
+Jolie spielte außerdem Olympias in Alexander ( 2004 ) , Oliver Stones Filmbiographie über das Leben von Alexander dem Großen .
+Der Film fiel in den Vereinigten Staaten durch , was Stone mit der Darstellung von Alexander als homosexuell in Verbindung brachte , außerhalb Nordamerikas spielte er jedoch 133 Mio. US-Dollar ein . Newsday schrieb über Jolies Leistung : „ Jolie ist die Einzige im gesamten Film , die Spaß mit ihrer Rolle zu haben scheint , und man vermisst sie jedes Mal , wenn sie nicht auf der Leinwand zu sehen ist . “
+Jolies einziger Film aus dem Jahr 2005 , Doug Limans Actionkomödie Mr.
+& Mrs. Smith
+, wurde ihr größter kommerzieller Erfolg .
+Der Film erzählt eine Geschichte von gelangweilten Eheleuten , die herausfinden , dass sie beide ein Doppelleben als Profikiller führen .
+Jolie spielte die Agentin Jane Smith neben Brad Pitt .
+Der Film wurde überwiegend positiv aufgenommen und besonders die gute Chemie zwischen den beiden Hauptdarstellern hervorgehoben .
+Die Star Tribune erklärte : „ Während die Geschichte willkürlich erscheint , lebt der Film von seinem geselligen Charme , der galoppierenden Energie und der thermonuklearen Chemie zwischen den beiden Stars . “ Der Film spielte weltweit über 478 Mio. US-Dollar ein und wurde zu einem der größten Erfolge des Kinojahres .
+In dem folgenden Jahr übernahm Jolie neben Matt Damon eine Nebenrolle in Robert De Niros Der gute Hirte , einem Film über die frühe Geschichte der CIA , erzählt aus der Sicht von Edward Wilson .
+Jolie trat als Margaret Russell auf , Wilsons vernachlässigte Ehefrau , die zunehmend unter den Auswirkungen der Arbeit ihres Ehemanns leidet .
+Die Chicago Tribune kommentierte : „ Jolie altert überzeugend im Laufe des Films und ist erfreulich unbesorgt , wie ihre spröde Figur beim Publikum ankommen könnte . “
+Jolie spielte außerdem Mariane Pearl in Michael Winterbottoms Dokumentardrama Ein mutiger Weg ( 2007 ) über die Entführung und Ermordung des Wall-Street-Journal-Reporters Daniel Pearl in Pakistan .
+Der Film basiert auf Mariane Pearls Memoiren Ein mutiges Herz : Leben und Tod des Journalisten Daniel Pearl und hatte seine Uraufführung bei den Filmfestspielen in Cannes .
+Der Hollywood Reporter beschrieb Jolies Darstellung als „ akkurat und bewegend , respektvoll gespielt und den schwierigen Akzent dabei fest im Griff . “ Sie erhielt für die Rolle ihre vierte Golden-Globe - und die dritte Screen-Actors-Guild-Award-Nominierung .
+Daneben trat sie als Grendels Mutter in einer Nebenrolle in Robert Zemeckis ’ animiertem Epos Die Legende von Beowulf ( 2007 ) auf , der mit Hilfe der Motion-Capture-Technik gefilmt wurde .
+Im Sommer 2008 war sie in dem Actionfilm Wanted , einer Adaption der gleichnamigen Graphic Novel von Mark Millar zu sehen sowie in dem Animationsfilm Kung Fu Panda ( DreamWorks SKG ) als Stimme der Tigerin zu hören .
+Wanted , der in Deutschland keine Jugendfreigabe erhielt , löste eine Diskussion um die Darstellung von Gewalt im Kino aus , war jedoch mit einem Einspielergebnis von 343 Mio. US-Dollar weltweit erfolgreich .
+Datei : Angelina Jolie 25 July 2010 2.jpg
+Clint Eastwood wählte sie als Hauptdarstellerin für seinen Thriller Der fremde Sohn .
+Dieser Film erhielt sehr gute Kritiken und wurde 2008 bei den Filmfestspielen von Cannes gezeigt .
+Jolie wurde für ihre Darstellung der um ihren Sohn kämpfenden Christine Collins erstmals für den Oscar als Beste Hauptdarstellerin nominiert .
+2009 begann sie mit den Dreharbeiten zu dem Action-Thriller Salt , in dem sie die Agentin Evelyn Salt spielt , die der Spionage bezichtigt wird und daraufhin eine neue Identität annehmen muss .
+Salt kam im Sommer 2010 in die deutschen Kinos .
+Im Februar 2010 begannen die Dreharbeiten zu dem Film The Tourist , bei dem Florian Henckel von Donnersmarck Regie führte und Jolie an der Seite von Johnny Depp die Hauptrolle spielte . Der Film feierte seine Weltpremiere am 6. Dezember 2010 in New York und spielte weltweit über 278 Mio. US-Dollar an den Kinokassen ein .
+Sowohl Depp als auch Jolie wurden für ihre schauspielerischen Leistungen in dem Thriller für den Golden Globe Award nominiert , gingen aber bei der Verleihung am 16. Januar 2011 leer aus .
+Bei den Teen Choice Awards 2011 wurde Jolie für ihre Darbietung in The Tourist als beste Action-Schauspielerin ausgezeichnet .
+Am 18. Juni 2012 begannen die Dreharbeiten zu Maleficent – Die dunkle Fee , in dem Jolie die titelgebende Hauptrolle spielt .
+Maleficent ist eine auf dem Disney-Zeichentrickklassiker Dornröschen ( 1959 ) basierende Realverfilmung , deren Weltpremiere am 7. Mai 2014 in London stattfand .
+In mehreren Interviews betonte Jolie , dass sie selbst Maleficent schon als Kind bewundert habe .
+Regie Mit dem Dokumentarfilm A Place in Time gab Jolie 2007 ihr Regiedebüt .
+Der Film beschreibt das Geschehen an 27 verschiedenen Orten der Welt innerhalb einer Woche .
+An dem Projekt , das vor allem zur Vorführung an Schulen gedacht ist , wirkten unter anderen ihre Schauspielkollegen Jude Law , Hilary Swank , Colin Farrell und ihr Ex-Mann Jonny Lee Miller mit .
+Im Herbst 2010 fanden die Dreharbeiten zu In the Land of Blood and Honey statt .
+Das Kriegsdrama , bei dem Jolie Regie führte und für das sie das Drehbuch schrieb , erzählt eine Liebesgeschichte während des Bosnienkrieges von 1992 bis 1995 .
+Jolie besetzte die Rollen ausschließlich mit bosnischen , serbischen und kroatischen Schauspielern wie Zana Marjanović , Nikola Djuricko und Rade Šerbedžija , die den Krieg selbst miterlebt hatten .
+„ [ Sie ] waren außergewöhnlich .
+Ich fühlte mich privilegiert und geehrt , mit ihnen arbeiten zu dürfen und freue mich sehr darauf , dass alle bald deren unglaubliches Talent sehen können “ , sagte Jolie der Branchenzeitschrift The Hollywood Reporter . Nachdem Gerüchte über die Filmhandlung in Umlauf gebracht worden waren , wonach der Film die Liebe einer bosnischen Frau zu ihrem serbischen Vergewaltiger thematisieren würde , rief dies scharfe Kritik und Proteste unter anderem von der bosnischen Vereinigung Women Victims of War hervor .
+Bosniens Kulturminister Gavrilo Grahovac entzog Jolie daraufhin vorübergehend die Drehgenehmigung für die Hauptstadt Sarajevo , weshalb große Teile des Films in Budapest gedreht wurden .
+Die Gerüchte sollten sich später als falsch erweisen . Der Film lief am 23. Dezember 2011 in den amerikanischen Kinos an . Er wurde als bester fremdsprachiger Film bei den Golden Globe Awards 2012 nominiert .
+Im Oktober 2013 begann Jolie in Australien unter dem Titel Unbroken mit der Verfilmung der Lebensgeschichte von Louis Zamperini .
+Der Film , für den Ethan und Joel Coen das Drehbuch schrieben , basiert auf Laura Hillenbrands Buch Unbeugsam : eine wahre Geschichte von Widerstandskraft und Überlebenskampf aus dem Jahr 2010 .
+Von August bis November 2014 fanden auf Malta die Dreharbeiten des Filmdramas By the Sea statt , für das sie das Drehbuch geschrieben hatte und bei dem sie die Regie und die Hauptrolle an der Seite von Brad Pitt übernahm .
+Es war das erste Mal seit Mr.
+& Ms. Smith
+, dass Jolie und Pitt wieder Seite an Seite vor der Kamera standen .
+Die Kritiken für den Film waren weitestgehend negativ .
+Humanitäres Engagement Datei : Ms. magazine Cover - Winter 2015.jpg Bei den Dreharbeiten zu Lara Croft : Tomb Raider im zu großen Teilen verminten Kambodscha kam Jolie zum ersten Mal persönlich mit konkreten humanitären Problemen in Kontakt .
+Sie wandte sich an das UN-Flüchtlingshilfswerk UNHCR , um weitere Informationen über internationale Krisenherde zu erhalten und stimmte in den darauf folgenden Monaten zu , verschiedene Flüchtlingslager zu besuchen .
+Im Februar 2001 brach sie zu ihrer ersten Reise auf , einer achtzehntägigen Mission durch Sierra Leone und Tansania ; sie berichtete später , wie schockiert sie von den Bedingungen war , die sie dort vorfand .
+Sie kehrte für zwei Wochen nach Kambodscha zurück und besuchte danach afghanische Flüchtlinge in Pakistan , für die sie im Rahmen eines internationalen UNHCR-Dringlichkeitsappells eine Million US-Dollar spendete . Sie bestand darauf , alle im Zusammenhang ihrer Reisen entstandenen Kosten selbst zu übernehmen , und teilte bei ihren Besuchen die spärlichen Arbeitsbedingungen und Unterbringungen mit den Helfern vor Ort .
+UNHCR zeigte sich von Jolies Interesse für Flüchtlinge beeindruckt und ernannte sie am 27. August 2001 im Genfer Hauptquartier Palais des Nations zur UNHCR-Sonderbotschafterin . In einer Pressekonferenz erklärte sie ihre Beweggründe , der Flüchtlingsorganisation beizutreten : „ Wir können uns nicht vor Informationen verschließen und die Tatsache ignorieren , dass es Millionen von Menschen auf der Welt gibt , die leiden .
+Ich möchte helfen .
+Ich glaube nicht , dass ich mich dabei von anderen Menschen unterscheide .
+Ich denke , wir wünschen uns alle Gerechtigkeit und Gleichheit , eine Chance für ein Leben mit Bedeutung .
+Wir alle würden gerne daran glauben , dass uns jemand beistünde , sollten wir einmal in eine schlechte Situation geraten . “
+Während ihrer ersten drei Jahre als Sonderbotschafterin konzentrierte Jolie ihre Bemühungen auf Reisen und besuchte Flüchtlinge in verschiedenen Teilen der Welt .
+Auf die Frage , was sie zu erreichen erhoffe , antwortete sie : „ Mehr Bewusstsein über die Lage dieser Menschen zu schaffen .
+Ich denke , sie sollten dafür gelobt werden , was sie überlebt haben und nicht auf sie herab gesehen werden . “ 2002 besuchte Jolie das Tham Hin-Flüchtlingslager in Thailand und kolumbianische Flüchtlinge in Ecuador.
+Sie reiste außerdem zu UNHCR-Einrichtungen im Kosovo und stattete dem Kakuma-Flüchtlingslager in Kenia , das Vertriebene aus dem Sudan aufnahm , einen Besuch ab .
+Während der Dreharbeiten zu Jenseits aller Grenzen besuchte sie außerdem angolanische Flüchtlinge in Namibia .
+Im Film wurde das humanitäre Engagement Jolies für das UN-Flüchtlingshilfswerk UNHCR eingebunden .
+2003 unternahm Jolie eine sechstägige Mission nach Tansania , wo sie Lager für kongolesische Flüchtlinge in der westlichen Grenzregion besuchte , und sie reiste für eine Woche nach Sri Lanka .
+Sie begab sich außerdem auf eine viertägige Mission in den Nordkaukasus in Russland und veröffentlichte zum Kinostart von Jenseits aller Grenzen im Oktober 2003 das Buch Tagebuch einer Reise – Begegnungen mit Flüchtlingen in Afrika , Kambodscha , Pakistan und Ecuador , eine Zusammenstellung von Notizen ihrer frühen Reisen ( 2001–2002 ) .
+Bei einem privaten Aufenthalt in Jordanien im Dezember 2003 besuchte sie irakische Flüchtlinge in der jordanischen Wüste und sudanesische Flüchtlinge in Ägypten .
+Angelina Jolie und Brad Pitt unterstützen die SOS-Kinderdörfer bereits seit Längerem mit größeren finanziellen Beiträgen .
+Dabei sorgen sie insbesondere für Darfur und Haiti .
+Angelina Jolie hat sich schon im Jahr 2003 ein persönliches Bild von der Situation vor Ort verschafft und die Kinder im Katastrophengebiet in Haiti , genauer gesagt im SOS-Kinderdorf Santo bei Port-au-Prince , besucht .
+Auf ihrer ersten UNO-Reise innerhalb der USA begab sich Jolie im Jahr 2004 nach Arizona , wo sie Asylbewerber in drei Einrichtungen besuchte , und sie besichtigte in Phoenix Unterbringungen für Kinder und Jugendliche ohne Begleitung oder rechtlichen Beistand .
+Als Reaktion auf die sich durch den Darfur-Konflikt verschlechternde humanitäre Situation im Westen Sudans flog sie im Juni 2004 nach Tschad und inspizierte Flüchtlingslager im Grenzgebiet zu Darfur .
+Vier Monate später kehrte sie in die Region zurück und begab sich direkt nach West-Darfur .
+Jolie besuchte 2004 auch afghanische Flüchtlinge in Thailand und stattete während eines privaten Aufenthalts im Libanon zur Weihnachtszeit dem regionalen UNHCR-Büro in Beirut einen Besuch ab und traf sich dort mit jungen Flüchtlingen und Krebspatienten .
+Jolie besuchte im Mai 2005 afghanische Flüchtlinge in Pakistan und traf sich mit Pakistans Präsidenten Pervez Musharraf und Premierminister Shaukat Aziz .
+Sie kehrte im November zusammen mit Brad Pitt nach Pakistan zurück , um die Folgen des Erdbebens in Kaschmir zu sehen .
+2006 besuchten Jolie und Pitt eine vom Hip-Hop-Musiker Wyclef Jean und seiner Wohltätigkeitsorganisation Yéle Ha-ti unterstützte Schule in Haiti und statteten im November während der Dreharbeiten zu Ein mutiger Weg in Indien afghanischen und birmanischen Flüchtlingen in Neu-Delhi einen Besuch ab .
+Jolie verbrachte den ersten Weihnachtstag 2006 mit kolumbianischen Flüchtlingen in San José , Costa Rica , wo sie Geschenke verteilte und sich mit Regierungsbeamten traf .
+Im Februar 2007 kehrte Jolie für eine zweitägige Mission nach Tschad zurück , um sich ein Bild von der sich verschlechternden Sicherheitslage für Flüchtlinge aus Darfur zu machen ; Jolie und Pitt spendeten daraufhin eine Million US-Dollar an drei Hilfsorganisationen in Tschad und Darfur .
+Im August 2007 unternahm Jolie ihre erste Reise nach Syrien und in den Irak , wo sie neben irakischen Flüchtlingen auch US-Truppen traf .
+Sechs Monate später kehrte sie in den Irak zurück .
+Dabei reiste sie in die Grüne Zone nach Bagdad und traf sich unter anderem mit dem irakischen Ministerpräsidenten Dschawad al-Maliki und dem US-Oberbefehlshaber in der Region , General David Petraeus .
+Datei : 2005 06 15 rice-jolie 600.jpg
+Mit zunehmender Erfahrung begann Jolie humanitäre Probleme auch auf einer politischen Ebene zu thematisieren .
+Sie nimmt regelmäßig an den Feierlichkeiten zum Weltflüchtlingstag in Washington , D. C. teil und war 2005 und 2006 Gastrednerin auf dem Weltwirtschaftsforum in Davos .
+Daneben versucht sie , Einfluss auf die Gesetzgebung in Washington zu nehmen .
+Sie traf sich seit 2003 mindestens zwanzig Mal mit Kongressabgeordneten und Senatoren .
+Sie erklärte : „ Auch wenn ich es vorziehen würde , nie nach Washington kommen zu müssen , ist das der Ort , um etwas zu bewegen . “
+Jolie unterstützte unter anderem ein Gesetz zum Schutz von minderjährigen Asylbewerbern und sie war im März 2005 an der Gründung einer nationalen Organisation beteiligt , die minderjährige Asylbewerber , die ohne Eltern oder Verwandte in die USA einreisen , kostenlos vor Gericht vertritt ; Jolie finanzierte die Einrichtung mit einer Spende von 500.000 US-Dollar für die ersten zwei Jahre . Daneben unterstützte sie verschiedene Gesetzesvorhaben des US-Kongresses , die Entwicklungshilfe für Kinder in der Dritten Welt zu verbessern .
+Neben ihren politischen Aktivitäten begann Jolie , das öffentliche Interesse an ihrer Person darauf zu verwenden , humanitäre Probleme in den Massenmedien zu platzieren .
+Im Mai 2005 filmte sie die MTV-Sendung , The Diary Of Angelina Jolie & Dr. Jeffrey Sachs in Africa , eine Dokumentation , die sie und den bekannten Wirtschaftswissenschaftler Jeffrey Sachs auf einer Reise nach Sauri , einer entlegenen Gruppe von Dörfern im westlichen Kenia , begleitete .
+Dort arbeitet Sachs ’ Team des UN-Millennium-Projekts mit Einheimischen zusammen , um Armut , Hunger und Krankheiten zu beenden .
+Im September 2006 verkündete Jolie die Schaffung der Jolie / Pitt Foundation ; die Stiftung tätigte zur Gründung zwei Spenden von jeweils einer Million US-Dollar an Global Action for Children und Ärzte ohne Grenzen .
+Jolie erntete breite Anerkennung für ihre humanitäre Arbeit .
+2003 war sie die erste Preisträgerin des neu geschaffenen Citizen of the World Award des Verbandes der UNO-Korrespondenten und 2005 erhielt Jolie den Global Humanitarian Award von der UNA-USA , einer amerikanischen Einrichtung zur Unterstützung der UNO . Kambodschas König Norodom Sihamoni verlieh Jolie am 12. August 2005 die kambodschanische Staatsbürgerschaft als Dank für ihre Arbeit zur Erhaltung der Umwelt in seinem Land ; sie sicherte fünf Millionen US-Dollar zu , um die Tierwelt innerhalb eines Nationalparks in der nordwestlichen Provinz Battambang zu erhalten , in der sie ein Haus besitzt .
+2007 wurde Jolie Mitglied des Council on Foreign Relations und mit dem Freedom Award des International Rescue Committee ausgezeichnet .
+2010 unterstützte Jolie die Initiative Ein Logo für Menschenrechte .
+Datei : Angelina Jolie at the launch of the UK initiative on preventing sexual violence in conflict , 29 May 2012 ( cropped ) . jpg Im April 2012 wurde Jolie zur Ehrenbürgerin Sarajevos ernannt . In der Begründung hieß es , sie habe mit ihrem Regiedebüt In the Land of Blood and Honey dazu beigetragen , ein Stück Geschichte zu wahren und „ die Prinzipien der Menschlichkeit , Demokratie , ebenso wie die Toleranz und die Solidarität von Menschen unterschiedlicher ethnischer Herkunft , Religion und kulturellem Hintergrund zu schützen . “ Am 16. November 2013 wurde Angelina Jolie bei den Governors Awards in Los Angeles mit dem Jean Hersholt Humanitarian Award ( „ Ehrenoscar “ ) für ihr humanitäres Engagement unter anderem als Sondergesandte des UN-Flüchtlingshochkommissariats ausgezeichnet .
+Nach dem Erscheinen ihres Films In the Land of Blood and Honey führte Jolie zusammen mit dem britischen Außenminister William Hague eine zweijährige Kampagne gegen Vergewaltigung als Kriegstaktik , die im Juni 2014 mit einer Gipfelkonferenz in London abgeschlossen wurde .
+Ziel der Kampagne war es , die Verdrängung und Banalisierung des Themas zu beenden und die Weltgemeinschaft zum Engagement gegen sexuelle Gewalt in Konflikten aufzurufen . Aufgrund ihres Engagements wurde Angelina Jolie 2014 von Königin Elizabeth II . mit dem Ordenszeichen Honorary Dame Commander des Most Distinguished Order of St. Michael and St. George geehrt .
+Seit 2012 lässt sich Jolie von der britischen Politikerin und Menschenrechtlerin Arminka Helic und der britischen Außenpolitik-Spezialistin Chloe Dalton beraten .
+Privatleben Am 28. März 1996 heiratete Jolie den britischen Schauspieler Jonny Lee Miller , den sie während der Dreharbeiten zu Hackers – Im Netz des FBI kennengelernt hatte .
+Jolie und Miller trennten sich ein Jahr später , wurden im Februar 1999 geschieden , blieben aber befreundet . Während der Dreharbeiten zu Foxfire ( 1996 ) ging Jolie eine sexuelle Beziehung mit ihrer Filmpartnerin Jenny Shimizu ein . Als sie 2003 in einem Interview mit Barbara Walters gefragt wurde , ob sie bisexuell sei , bestätigte Jolie dies .
+Am 5. Mai 2000 heiratete Jolie den 20 Jahre älteren Schauspieler Billy Bob Thornton , ihren Filmpartner aus Turbulenzen – und andere Katastrophen .
+Am 10. März 2002 adoptierten sie einen kambodschanischen Jungen ( * 5. August 2001 ) aus einem Waisenhaus in Phnom Penh und gab ihm den Namen Maddox Chivan .
+Nach der Scheidung von Thornton am 27. Mai 2003 erhielt Jolie das alleinige Sorgerecht . Datei : Angelina Jolie Brad Pitt Cannes.jpg Im Juli 2002 reichte Jolie einen Antrag auf Namensänderung ein , um Voight als Familiennamen zu streichen und ihren bürgerlichen Namen in Angelina Jolie zu ändern ; die Änderung wurde am 12. September 2002 offiziell bestätigt . Im August desselben Jahres sagte Jon Voight im US-amerikanischen Fernsehen , seine Tochter habe „ ernste emotionale Schwierigkeiten “ . Jolie erklärte 2004 , sie sei nicht länger an einer Beziehung zu ihrem Vater interessiert .
+Sie gab an , dass sie die genauen Gründe für die Entfremdung von ihrem Vater nicht öffentlich machen wolle , aber sie glaube , es sei schädlich für sie , sich weiterhin mit ihrem Vater einzulassen , da sie gerade ein Kind adoptiert habe .
+Datei : AngelinaJolieClintEastwoodCroppedMay08.jpg Im Frühjahr 2005 geriet Jolie ins Visier der Boulevardpresse .
+Sie sei der Trennungsgrund des Schauspielerehepaares Brad Pitt und Jennifer Aniston .
+Die Boulevardmedien spekulierten , ob sie und Pitt während der Dreharbeiten von Mr.
+& Mrs. Smith
+eine Affäre begonnen hätten .
+Jolie bestritt dies in verschiedenen Interviews . Am 6. Juli 2005 adoptierte Jolie einen Säugling aus einem Waisenhaus in Addis Abeba und gab dem äthiopischen Mädchen ( * 8. Januar 2005 ) den Namen Zahara Marley .
+Nach einem Jahr intensiver Berichterstattung der Boulevardmedien , in dem sich beide – auch nach der Scheidung Pitts von Aniston im Oktober 2005 – nie zum Wesen ihrer Beziehung geäußert hatten , offenbarte Jolie am 11. Januar 2006 gegenüber der Zeitschrift , dass sie ein Kind von Pitt erwarte .
+Kurz darauf wurde die von Pitt beantragte Adoption von Jolies Adoptivkindern rechtsgültig .
+Die erste leibliche Tochter des Paares wurde am 27. Mai 2006 in Namibia geboren .
+Für die Erlaubnis zur Veröffentlichung der ersten Fotos von Shiloh Nouvel Jolie-Pitt zahlte die Zeitschrift People dem Paar 4,1 Millionen US-Dollar – den bis dahin höchsten Preis für sogenannte „ Celebrity-Fotos “ . Am 15. März 2007 adoptierte Jolie – wegen des vietnamesischen Adoptionsrechts zunächst allein – einen Jungen ( * 29. November 2003 ) aus einem Waisenhaus in Ho-Chi-Minh-Stadt .
+Ein Jahr später wurde auch Pitts Adoption von Pax Thien rechtskräftig .
+Beim Filmfestival von Cannes im Mai 2008 bestätigte Jolie ihre Schwangerschaft mit Zwillingen .
+Knox Léon und Vivienne Marcheline Jolie-Pitt wurden am 12. Juli 2008 in Nizza geboren .
+Die Rechte an den ersten öffentlichen Fotos der Zwillinge gingen für 14 Millionen US-Dollar erneut an die Zeitschrift People .
+Am 14. Mai 2013 veröffentlichte Jolie im Op-Ed der New York Times einen Debattenbeitrag mit dem Titel My Medical Choice , in dem sie davon berichtete , dass sie sich einer beidseitigen prophylaktischen Mastektomie unterzogen habe , um ihr hohes individuelles Brustkrebsrisiko zu minimieren .
+Ohne Operation habe ihr Risiko , an Brustkrebs zu erkranken , aufgrund einer Mutation im BRCA1-Gen 87 % betragen .
+Ihr Risiko eines Eierstockkrebses sei auf 50 % geschätzt worden . Die Berichterstattung bewirkte , dass sich Frauen weltweit vermehrt für Brust-Diagnostik und genetische Beratung interessierten ( Jolie-Effekt ) . Am 24. März 2015 veröffentlichte Jolie unter dem Titel Diary of a Surgery einen weiteren Gastbeitrag in der New York Times , in dem sie mitteilte , dass sie sich inzwischen auch einer prophylaktischen Entfernung beider Eierstöcke und der Eileiter unterzogen habe .
+Nachdem Pitts Managerin im April 2012 bereits die Verlobung des Paares bekanntgegeben hatte , heirateten Jolie und Pitt am 23. August 2014 auf ihrem Weingut Ch.teau Miraval an der Côte d ’ Azur im Beisein von Familie und Freunden . Ihr bürgerlicher Name lautet seit der Eheschließung Jolie Pitt .
+Angelina Jolie hat mindestens 20 Tätowierungen ( Stand Februar 2016 ) . Darunter befindet sich ein traditionelles Khmer-Tattoo , das Unglück und Unfälle abwenden soll , ein Ausspruch von Tennessee Williams „ A prayer for the wild at heart , kept in cages “ , ein zwölf Zoll großer Tiger und die geographischen Koordinaten der Geburtsorte von Brad Pitt und ihrer Kinder . Sie ließ verschiedene Tätowierungen entfernen , darunter auch den Schriftzug Billy Bob , den Vornamen ihres zweiten Ehemanns . Im September 2016 reichte Jolie die Scheidung von Pitt ein .
+Medienpräsenz Jolie ist heute eine der bekanntesten Persönlichkeiten weltweit .
+Laut Q-Score-Index von Marketing Evaluations Inc .
+kannten Jolie nach ihrem Oscargewinn 31 % der Befragten in den Vereinigten Staaten im Jahr 2000 , 2006 war sie bereits für 81 % aller Amerikaner ein Begriff . In einer globalen Studie auf 42 internationalen Märkten von ACNielsen aus dem Jahr 2006 wurde Jolie zusammen mit Brad Pitt zur weltweit bevorzugten Werbeträgerin für Marken und Produkte ermittelt . Daneben wurde Jolie 2006 und 2008 von Time in deren jährliche Liste der 100 einflussreichsten Personen der Welt aufgenommen . Vom US-amerikanischen Wirtschaftsmagazin Forbes wurde Jolie auf der sogenannten „ Celebrity 100 “ , einer Rangliste der einflussreichsten Prominenten , 2006 auf Position 35 und 2007 auf Rang 14 geführt .
+Im Februar 2007 wurde sie im Rahmen der britischen Fernsehshow The 100 Greatest Sex Symbols vor Elvis Presley und Marilyn Monroe zum größten Sexsymbol aller Zeiten gewählt . 2008 wählten die Leser der deutschen FHM Jolie auf einer Liste der 100 schönsten Frauen auf Platz 12.
+2008 zählte Jolie laut Forbes Magazine zu den am besten verdienenden Schauspielerinnen in Hollywood .
+Zwischen Juni 2007 und Juni 2008 erhielt sie Gagen in Höhe von 14 Mio. US-Dollar . 2011 hatte sie in einem neuerlichen Forbes-Ranking die Spitzenposition durch ihr Mitwirken in Salt und The Tourist ( 30 Mio. US-Dollar ) gemeinsam mit Sarah Jessica Parker inne .
+Das Ausmaß der Berichterstattung über Angelina Jolie wird auch daran deutlich , dass die Schauspielerin zwischen Mai 2011 und Mai 2012 auf den Titelblättern von mindestens 78 Zeitschriften zu sehen war .
+Filmografie Schauspielerin
+Die deutsche Synchronstimme von Jolie ist seit dem Jahr 2000 bis auf wenige Ausnahmen Claudia Urbschat-Mingues .
+Regisseurin
+2007 : A Place in Time ( Dokumentation )
+2011 : In the Land of Blood and Honey
+2014 : Unbroken
+2015 : By the Sea
+2017 : Der weite Weg der Hoffnung ( First They Killed My Father : A Daughter of Cambodia Remembers )
+Drehbuchautorin
+2011 : In the Land of Blood and Honey
+2015 : By the Sea
+Produzentin
+2005 : Lovesick 2005 : A Moment in The World 2011 : In the Land of Blood and Honey
+2014 : Unbroken
+2015 : By the Sea
+2017 : Der weite Weg der Hoffnung ( First They Killed My Father : A Daughter of Cambodia Remembers )
+Synchronsprecherin
+2004 : Große Haie – Kleine Fische ( Shark Tale )
+2008 : Kung Fu Panda
+2011 : Kung Fu Panda 2
+2016 : Kung Fu Panda 3
+Musikvideos
+1991 : Stand By My Woman von Lenny Kravitz
+1991 : Alta Marea ( Don ’ t Dream It ’ s Over ) von Antonello Venditti
+1993 : Rock and Roll Dreams Come Through von Meat Loaf
+1997 : Anybody Seen My Baby ? von The Rolling Stones
+2001 : Elevation von U2 2003 : Did My Time von Korn
+Auszeichnungen ( Auswahl ) Auszeichnungen für ihre Leistungen als Schauspielerin Academy Award of Merit ( „ Oscar “ )
+2000 : Auszeichnung als Beste Nebendarstellerin für Durchgeknallt
+2009 : Nominierung als Beste Hauptdarstellerin für Der fremde Sohn
+British Academy Film Award
+2009 : Nominierung als beste Hauptdarstellerin für Der fremde Sohn
+Emmy Award
+1998 : Nominierung als beste Hauptdarstellerin in einer Miniserie oder einem Fernsehfilm für Gia – Preis der Schönheit
+1998 : Nominierung als beste Hauptdarstellerin in einer Miniserie oder einem Fernsehfilm für Wallace
+Golden Globe Award
+1998 : Auszeichnung als beste Hauptdarstellerin in einem Fernsehfilm für Wallace
+1999 : Auszeichnung als beste Hauptdarstellerin in einem Fernsehfilm für Gia – Preis der Schönheit
+2000 : Auszeichnung als Beste Nebendarstellerin für Durchgeknallt
+2008 : Nominierung als Beste Hauptdarstellerin in einem Drama für Ein mutiger Weg
+2009 : Nominierung als beste Hauptdarstellerin in einem Drama für Der fremde Sohn
+2011 : Nominierung als Beste Hauptdarstellerin in einer Komödie oder einem Musical für The Tourist
+Nickelodeon Kids ’ Choice Awards
+2015 : Auszeichnung als Favorite Villain für Maleficent
+National Board of Review Award
+1998 : Auszeichnung als beste Nachwuchsdarstellerin für Leben und lieben in L. A.
+Screen Actors Guild Award
+1999 : Auszeichnung als beste Hauptdarstellerin in einem Fernsehfilm für Gia – Preis der Schönheit
+2000 : Auszeichnung als beste Nebendarstellerin für Durchgeknallt
+2008 : Nominierung als beste Hauptdarstellerin für Ein mutiger Weg
+2009 : Nominierung als beste Hauptdarstellerin für Der fremde Sohn
+Negativpreise
+2002 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Lara Croft : Tomb Raider
+2002 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Original Sin
+2003 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Leben oder so ähnlich
+2004 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Jenseits aller Grenzen
+2004 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Lara Croft : Tomb Raider – Die Wiege des Lebens
+2005 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Alexander
+2005 : Nominierung für die Goldene Himbeere als schlechteste Schauspielerin für Taking Lives – Für Dein Leben würde er töten
+2005 : Nominierung als größte Verliererin in den ersten 25 Jahren der Verleihung der Goldenen Himbeere Auszeichnungen als Regisseurin und Drehbuchautorin Hollywood Film Award
+2017 : Auszeichnung mit dem Hollywood Foreign Language Film Award für Der weite Weg der Hoffnung , gemeinsam mit Loung Ung
+Auszeichnungen für ihr humanitäres Engagement 2003 : ( Sergio Vieira de Mello ) Citizen of the World Award des Verbandes der UNO-Korrespondenten 2005 : Global Humanitarian Award der United Nations Association of the USA ( UNA-USA ) und des Business Council for the United Nations 2005 : Verleihung der kambodschanischen Staatsbürgerschaft
+2007 : Freedom Award des International Rescue Committee
+2012 : Ernennung zur Ehrenbürgerin der Stadt Sarajevo
+2014 : Jean Hersholt Humanitarian Award ( verliehen bei den Governors Awards am 16. November 2013 in Los Angeles )
+2014 : Ernennung zur Honorary Dame Commander des Order of St. Michael and St. George ( DCMG ) durch Königin Elisabeth II .
+Literatur Angelina Jolie : Tagebuch einer Reise – Begegnungen mit Flüchtlingen in Afrika , Kambodscha , Pakistan und Ecuador. Bombus , München 2004 , ISBN 3-936261-31-8 . Brandon Hurst : Angelina Jolie . Schwarzkopf & Schwarzkopf Verlag , Berlin 2007 , ISBN 978-3-89602-764-1 . Harald Keller : Angelina Jolie . Bertz + Fischer Verlag , Berlin 2001 , ISBN 3-929470-33-0 . Andrew Morton : Angelina Jolie . Droemer , München 2010 , ISBN 978-3-426-27532-0 . Englischsprachige Literatur und Quellen
+UNHCR .
+UNHCR.org UNHCR .
+UNHCR.org Chris Heath : Rolling Stone .
+Juli 2001 Jonathan Van Meter : Vogue .
+April 2002 Bruce Kirkland : jam !
+Showbiz .
+19. Oktober 2003 Jonathan Van Meter : Vogue .
+März 2004 Fred Schruers : Premiere Magazine .
+Oktober 2004 Kevin Sessums : Allure .
+November 2004 Matthew Swibel : Forbes .
+12. Juni 2006 Jonathan Van Meter : Vogue .
+Januar 2007 Weblinks Tobias Rapp : auf Spiegel Online vom 31. Juli 2010 UNHCR Goodwill Ambassador Angelina Jolie , offizielle Homepage bei UNHCR.org ( englisch ) Angelina Jolie ’ s Refugee Journals , Jolies Reisetagebücher ( englisch ) Journey Through Eastern Congo , Multimedia-Tagebuch , das von Jolie selbst besprochen wurde ( englisch ) Bilder von Angelina Jolie , umfangreiche Sammlung von Fotos auf moviepilot Einzelnachweise und Anmerkungen | AMT = [[ Sexiest Woman Alive ]] | ZEIT = [[ 2004 ]] | VORGÄNGER_GESCHLECHT = w | VORGÄNGER = — | NACHFOLGER_GESCHLECHT = w | NACHFOLGER = [[ Jessica Biel ]] UNHCR.ch , abgerufen am 12. Juni 2012 . . Allure . November 2004 . Inside the Actors Studio , Episode 169. Bravo . 5. Juni 2005 . Marcheline Bertrand Biografie IMDb.com , abgerufen am 4. Juni 2012 . Angelina Jolie – Biography IMDb.com , abgerufen am 8. Oktober 2012 . ( englisch ) Paula Zahn Now . CNN . com – Transcripts . 9. Juni 2005 . Angelina Jolie interviews featuring Jonny Lee Miller . JonnyLeeMiller.co.uk . Inside the Actors Studio , Episode 169 Bravo . June 5 , 2005 ‚ Heart ‘ Barely Misses a Beat , Small life stories come together . San Francisco Chronicle . 22. Januar 1999 . ‘ Pushing Tin ’ ( R ) . Washington Post . 23. April 1999 . . Rotten Tomatoes . , Variety , Dec . 10 , 1999 . Reviews : Girl , Interrupted . Chicago Sun-Times . 14. Januar 2000 . ‘ Gone in 60 Seconds ’ : Lost in the Exhaust . Washington Post . 9. Juni 2000 . . Slant Magazine . 2001 . Boxofficemojo 16. April 2007 ELVIS MITCHELL : Original Sin – Review . The New York Times . 3. August 2001 . Jolie shines in up-and-down ‘ Life ’ . CNN . com. 25. April 2002 . . Los Angeles Times . 24 October 2003 . . The Hollywood Reporter . 15. März 2004 . Stone blames ‘ moral fundamentalism ’ for US box office flop . The Guardian . January 6 , 2005 . . Newsday . 24. November 2004 . . Rotten Tomatoes . . Chicago Tribune.boxofficemojo.com : “ Wanted ” ( Stand : 30. Januar 2009 ) . Die Welt , 24. Februar 2010 unhcr.org : Angelina Jolie responds to UNHCR emergency appeal Angelina Jolie named UNHCR Goodwill Ambassador for refugees . UNHCR.org . 23. August 2001 . forbes.com : Bad Girl Interrupted Interview with Angelina Jolie . UNHCR.org . 21. Oktober 2002.United Nations High Commissioner for Refugees , Hoher Kommissar der Vereinten Nationen für Flüchtlinge Angelina Jolie und die SOS-Kinderdörfer Bad Girl Interrupted . Forbes . 12. Juni 2006 . Angelina Jolie launches centre for unaccompanied children . UNHCR.org . 9. März 2005 . Welt Online , abgerufen am 7. August 2012 . Berliner Zeitung , abgerufen am 7. August 2012 . , ORF . at vom 13. Juni 2014 Honorary Awards 2014 Gov . uk , abgerufen am 15. Oktober 2014 . http://people.com/movies/all-about-angelina-jolie-pitts-new-partnership/ People , abgerufen am 6. Mai 2012 . ( englisch ) Angelina Jolie am 24. März 2015 in der New York Times , abgerufen am 17. April 2015 . [ 1 ] Kölner Stadtanzeiger vom 28. August 2014 . Angelina Jolie Pitt CBS NEWS , abgerufen am 23. April 2015 Angelina Jolie Has Three Giant New Tattoos Vanity Fair vom 9. Februar 2016 , abgerufen am 21. Oktober 2016 What to say when your children ask for a tattoo The Telegraph vom 10. Dezember 2014 , abgerufen am 21. Oktober 2016 Angelina Jolie , tattoo diarist USA Today vom 7/17/2003 , abgerufen am 21. Oktober 2016 , Forbes , 12. Juni 2006 . AgencyFaqs.com . . Time Magazine . vgl. Johnson , Wesley : Hollywood ’ s Top Earners . Press Association Newsfile , 23. Juli 2008 , 4:38 PM BST Forbes.com , abgerufen am 19. Juni 2012 ( englisch ) . Angelina Jolie & Loung Ung to Receive Award at Hollywood Film Awards for ‘ First They Killed My Father ’ In : justjared.com , 2. November 2017 . Governors Awards 2013 Oscars.org , abgerufen am 17. November 2013 . 
+
+Datei : Retrato de un erudito ( ¿ Arquímedes ? ) , por Domenico Fetti.jpg Archimedes von Syrakus ( griechisch Ἀρχιμήδης ὁ Συρακούσιος Archimḗdēs ho Syrakoúsios ; * um 287 v. Chr. vermutlich in Syrakus ; † 212 v. Chr. ebenda ) war ein griechischer Mathematiker , Physiker und Ingenieur .
+Er gilt als einer der bedeutendsten Mathematiker der Antike .
+Seine Werke waren auch noch im 16. und 17. Jahrhundert bei der Entwicklung der höheren Analysis von Bedeutung .
+Leben Datei : Fvs Schule.jpg Über das Leben des Archimedes ist wenig bekannt und vieles gilt als Legende .
+Archimedes , geboren ca. 287 v. Chr. wahrscheinlich in der Hafenstadt Syrakus auf Sizilien , war der Sohn des Pheidias , eines Astronomen am Hof Hierons II . von Syrakus .
+Mit diesem und dessen Sohn und Mitregenten Gelon II .
+war er befreundet und möglicherweise verwandt .
+Bei einem längeren Aufenthalt in Alexandria lernte Archimedes die dortigen Mathematiker Konon , Dositheos und Eratosthenes kennen , mit denen er später weiter korrespondierte .
+Als er nach Syrakus zurückgekehrt war , betrieb er Mathematik und praktische Physik ( Mechanik ) .
+Seine Wurfmaschinen wurden bei der Verteidigung von Syrakus gegen die römische Belagerung im Zweiten Punischen Krieg eingesetzt .
+Bei der Eroberung von Syrakus 212 v. Chr.
+nach dreijähriger Belagerung durch den römischen Feldherrn M. Claudius Marcellus wurde er sehr zum Bedauern von Marcellus , der ihn lebend gefangensetzen wollte , von einem römischen Soldaten getötet .
+Über die Umstände referiert Plutarch in seiner Biographie des Marcellus mehrere überlieferte Versionen , nach einer war er mit einem mathematischen Beweis beschäftigt und forderte einen beim Plündern der Stadt eindringenden Soldaten auf , ihn nicht zu stören , worauf der ihn erschlug .
+Sprichwörtlich wurden die Worte Noli turbare circulos meos ( lateinisch für : „ Störe meine Kreise nicht “ ) , die Archimedes dabei gesprochen haben soll .
+Nach Plutarch hatte Archimedes sich testamentarisch ein Grab mit der Darstellung von Kugel und Zylinder gewünscht , da er offensichtlich auf seine Abhandlung perì sphaíras kaì kylíndrou ( „ Über Kugel und Zylinder “ ) besonders stolz war .
+Cicero berichtet in den Tuskulanischen Gesprächen , dass er in seiner Zeit als Quästor in Sizilien ( 75. v. Chr. ) nach dem Grab suchte und es von Gestrüpp zugewuchert fand .
+Eine von seinem Freund Heracleides geschriebene Biographie ist nicht erhalten .
+Schriften Die erhaltenen Hauptschriften sind : Über das Gleichgewicht ebener Flächen , griechisch Περὶ ἐπιπέδων ἰσορροπιῶν , transkribiert Peri epipédōn isorrhopíai , lateinisch De planorum aequilibriis , in zwei Büchern .
+Quadratur der Parabel , lateinisch De quadratura parabolae .
+Inhalt : Fläche eines Parabelsegments .
+Über die Methode , lateinisch De methodo .
+Als Fragment erhalten im von Heiberg gefundenen Archimedes-Palimpsest .
+Über Kugel und Zylinder , griechisch Περὶ σφαίρας καὶ κυλίνδρου , transkribiert Peri sphaíras kai kylíndrou , lateinisch De sphaera et cylindro , 2 Bände .
+Inhalt : Volumen von Kugel und Zylinder .
+Über Spiralen , lateinisch De lineis spiralibus .
+Inhalt : Fläche eines von ihm erfundenen Objekts , der Spirallinie .
+Die archimedische Spirale wurde aber wahrscheinlich von seinem Freund Konon erfunden .
+Über Konoide und Sphäroide , lateinisch De conoidibus et sphaeroidibus .
+Inhalt : Volumina von Hyperbeln und Ellipsen .
+Über schwimmende Körper , 2 Bücher , griechisch transkribiert Peri ochoumenon , lateinisch De corporibus fluitantibus .
+Inhalt : Volumen und spezifisches Gewicht von Körpern , Hydrostatik .
+Kreismessung , griechisch Κύκλου μέτρησις , transkribiert Kýklou métrēsis , lateinisch Dimensio circuli .
+Die Sandrechnung , griechisch transkribiert Psammites , lateinisch Arenarius .
+Inhalt : Darstellung beliebig großer Zahlen , Heliozentrisches Weltbild des Aristarchos von Samos .
+Hinzu kommen : Das Rinderproblem des Archimedes , lateinisch Problema bovinum , ein zahlentheoretisches Problem .
+Es ist in einem Gedicht von Archimedes an Eratosthenes erhalten , das Lessing entdeckte .
+Ostomachion ( oder Stomachion ) , griechisch Ὀστομάχιον , ein Puzzle-Problem .
+Fragment , zum Beispiel im Archimedes-Palimpsest erhalten .
+Zuschreibung fraglich .
+Buch der Lemmata , lateinisch Liber assumptorum .
+Wohl nicht archimedisch ( der Text zitiert Archimedes ) , geht aber inhaltlich vielleicht auf Archimedes zurück .
+Es ist nur in einer arabischen Übersetzung von Thabit Ibn Qurra aus dem 9. Jahrhundert erhalten .
+Die hier angegebene Reihenfolge der Hauptschriften bis zur Sandrechnung entspricht der chronologischen Reihenfolge , wie sie von Thomas Heath angegeben wurde , wobei die Quadratur der Parabel zwischen den Büchern 1 und 2 von Gleichgewicht ebener Flächen eingeordnet wurde und Über die Methode zwischen Gleichgewicht ebener Flächen , Buch 2 , und Über Kugel und Zylinder .
+An der Chronologie gab es aber auch Kritik .
+In der Quadratur der Parabel wird der kürzliche Tod seines Freundes Konon erwähnt , so dass sich diese Schrift um 240 v. Chr. datieren lässt . Nach der erwähnten relativen Datierung sind die meisten Werke des Archimedes erst danach entstanden .
+Das Buch über Spiralen wurde nach Archimedes Angaben viele Jahre nach dem Tod des Konon geschrieben , so dass es nach Ivo Schneider etwa 230 v. Chr. zu datieren ist .
+Schneider ordnet die Methodenlehre Ende der 220er Jahre ein und die Schwimmenden Körper als letztes Werk in die letzten acht Lebensjahre , aber wohl vor 216 v. Chr. wegen der nachfolgenden Kriegsereignisse .
+Es gibt Hinweise auf einige heute verloren gegangene Schriften , zum Beispiel über Polyeder und über Hebel ( von Pappos erwähnt ) , über die Darstellung von Zahlen ( von Archimedes in seinem Sandrechner erwähnt ) und über Spiegel ( Catoptrica , von Theon von Alexandria erwähnt ) .
+Aus der Unvollständigkeit der mechanischen Schriften des Archimedes ( Gleichgewicht ebener Flächen , Quadratur der Parabel ) und mehrerer Hinweise bei Archimedes ( und zum Beispiel bei Heron von Alexandria ) wurde auf die Existenz verloren gegangener Teile seiner Mechanik geschlossen , die A. G. Drachmann zu rekonstruieren versuchte . Diese teilweise rekonstruierten mechanischen Schriften stehen chronologisch am Anfang der Werke des Archimedes .
+Es gibt einige Hinweise auf verloren gegangene Schriften des Archimedes in arabischer Übersetzung , so ein Buch über das Parallelenpostulat , das im Bücherkatalog von Ibn al-Nadim aufgeführt ist und möglicherweise die Behandlung des Themas bei Thabit Ibn Qurra beeinflusste . Von Thabit Ibn Qurra stammt auch die Übersetzung einer Abhandlung von Archimedes über die Konstruktion des regulären Heptagons , die erhalten ist . Die Konstruktion darin ist unvollständig , wurde aber von Abu Sahl al-Quhi vervollständigt .
+Werk Datei : Archimedes ( Idealportrait ) . jpg Archimedes war sowohl in der Mathematik als auch im Bereich der heutigen Physik gleichermaßen schöpferisch tätig .
+Physik Es wurden ihm auch die Erfindung und Kombination verschiedener Maschinenelemente ( wie Schrauben , Seilzüge mit Wellrädern , Flaschenzüge und Zahnräder ) zugeschrieben , die er auch praktisch demonstrierte .
+Nach Plutarch bevorzugte er abstraktes Denken und sah auf praktische Anwendungen und die Arbeiten eines Ingenieurs , obwohl er sich ihnen im Auftrag seines Königs Hieron widmete , mit Verachtung herab .
+Aus diesem Grund hinterließ er auch keine Abhandlung über praktische Erfindungen .
+Seine Schriften zur Mechanik und Hydrostatik sind nach dem Vorbild der Geometrie streng axiomatisch aufgebaut .
+Hebelgesetz Archimedes formulierte die Hebelgesetze ( in seiner Schrift Über das Gleichgewicht ebener Flächen ) und schuf dadurch die theoretische Grundlage für die spätere Entwicklung der Mechanik .
+Er selbst entwickelte aus dem Hebelgesetz bereits die wissenschaftlichen Grundlagen der Statik für statisch bestimmte Systeme .
+Die Beschreibung des Hebels selbst findet sich schon in älteren griechischen Schriften aus der Schule des Aristoteles .
+Er soll ( wie Pappos und andere überlieferten ) gesagt haben : „ “ ( „ Gebt mir einen festen Punkt , und ich hebe die Welt aus den Angeln “ ) . Darauf gründet sich der Begriff des archimedischen Punktes .
+Als er sich einmal gegenüber Hieron so äußerte , verlangte dieser nach Plutarch einen praktischen Beweis , und Archimedes bewerkstelligte unter anderem mit Flaschenzügen ( Plutarch ) und Seilwinden die Bewegung eines großen voll beladenen Schiffs durch einen einzigen Mann .
+Archimedisches Prinzip Nach Vitruv sollte Archimedes den Goldgehalt einer vom Herrscher Hieron II . den Göttern geweihten Krone prüfen , ohne sie jedoch zu beschädigen .
+Der König verdächtigte den Goldschmied , ihn betrogen zu haben .
+Um die gestellte Aufgabe zu lösen , tauchte er einmal die Krone und dann einen Goldbarren ( sowie einen Silberbarren ) , der genauso viel wog wie die Krone , in einen vollen Wasserbehälter und maß die Menge des überlaufenden Wassers .
+Die Krone verdrängte mehr Wasser als der Goldbarren .
+Dadurch war bewiesen , dass die Krone ein kleineres spezifisches Gewicht hatte und daher nicht ganz aus Gold gefertigt war .
+Archimedes soll der Legende nach das Archimedische Prinzip beim Baden entdeckt haben .
+Aus dem randvollen Wasserbehälter sei jene Wassermenge ausgelaufen , die er beim Hineinsteigen ins Bad mit seinem Körpervolumen verdrängte .
+Glücklich über seine Entdeckung soll er mit dem Ausruf „ Heureka ! “ ( altgriechisch : , „ Ich hab ’ s gefunden ! “ ) nackt auf die Straße gelaufen sein .
+Die Anekdote von der Überprüfung des Goldgehalts der Krone Hierons durch Wasserverdrängung ist aber kritisiert worden – diese wäre mit den Mitteln der damaligen Zeit nur schwer durchzuführen gewesen und ist wahrscheinlich eine Legende . Schon Galileo Galilei vermutete deshalb 1586 , Archimedes hätte stattdessen eine Waage benutzt zur Messung der Gewichte unter Auftrieb .
+Das Archimedische Prinzip kann bei jedem schwimmenden Körper Anwendung finden .
+Es stellt beim Schiffbau eine zwingend zu berücksichtigende Tatsache dar .
+Bei seinen hydrostatischen Experimenten entdeckte er zudem das Prinzip der kommunizierenden Gefäße .
+Mathematik Datei : Gerhard Thieme Archimedes.jpg
+Flächenberechnungen Archimedes bewies , dass sich der Umfang eines Kreises zu seinem Durchmesser genauso verhält wie die Fläche des Kreises zum Quadrat des Radius .
+Er nannte dieses ( heute als Pi oder Kreiszahl bezeichnete ) Verhältnis noch nicht π ( Pi ) , gab aber eine Anleitung , wie man sich dem Verhältnis bis zu einer beliebig hohen Genauigkeit nähern kann , vermutlich das älteste numerische Verfahren der Geschichte .
+Mit seinen Überlegungen zur Flächen- und Volumenberechnung ( u. a.
+mit einer exakten Quadratur der Parabel ) nahm Archimedes Ideen der Integralrechnung viel später folgender Denker vorweg .
+Er ging dabei über die Eudoxos von Knidos zugeschriebene Exhaustionsmethode ( Ausschöpfungsmethode ) hinaus ; beispielsweise wandte er bereits eine Form des Prinzips von Cavalieri an .
+1906 fand Johan Ludvig Heiberg ( 1854–1928 ) , ein dänischer Philologe und Professor an der Universität Kopenhagen , in Istanbul ein auf das 10. Jahrhundert datiertes Manuskript , das unter anderem eine Abschrift von Archimedes ’ Schrift Die Methode enthielt .
+Darin gibt er eine mechanische Methode preis , mit der er viele seiner Resultate erzielt hatte , bevor er sie in geometrisch strenger Weise bewies .
+Die Methode entspricht einem Wiegen der zu vergleichenden Volumina bzw. Flächenstücke , allerdings in geometrischer Form. Bei seiner Beschreibung erwähnt Archimedes auch ein älteres Verfahren von Demokrit , bei dem es sich möglicherweise um das Wiegen von Modellen handelt .
+Stellenwertbasiertes Zahlensystem Außerdem entwickelte Archimedes ein stellenwertbasiertes Zahlensystem mit der Basis 108.
+Er benutzte es , um astronomisch große Zahlen ( bis zur Größe von 1064 ) mathematisch fassen zu können – dies in einer Zeit , in der seine Mitwelt eine Myriade ( lit. 10.000 ) bereits mit „ unendlich “ gleichsetzte .
+Anlass dafür war die Abhandlung Über schwimmende Körper und die Sandzahl , auch kurz Sandrechner genannt , die er dem Sohn von Hieron II . , Gelon , widmete .
+Darin heißt es : „ Es gibt Leute , König Gelon , die der Meinung sind , die Zahl des Sandes sei unendlich groß [ … ] Andere glauben zwar nicht , dass die Zahl unendlich sei , aber doch , dass noch keine Zahl genannt worden sei , die seine Menge übertreffen könnte . “ Da Gelon als König angesprochen wird , entstand die Schrift nach 240 v. Chr. , als er Mitregent wurde ( und vor Gelons Tod 216 v. Chr. ) .
+Er widerlegte diese Vorstellungen , indem er in der Abhandlung die Anzahl der Sandkörner , die alle Strände der Erde bedeckten , abschätzte und benannte .
+Er ging sogar noch weiter und berechnete die Anzahl der Sandkörner , die man benötigte , um das ganze Universum mit Sand anzufüllen .
+Damals stellte man sich das Universum allerdings noch wesentlich kleiner vor – nämlich als Kugel von etwa der Größe unseres Sonnensystems .
+Archimedes ’ Rechnung besagt demnach , dass in eine gedachte Kugel von der Größe unseres Sonnensystems etwa 1064 Sandkörner hineinpassen würden .
+Archimedisches Axiom Obwohl nach ihm benannt , stammt das archimedische Axiom nicht von Archimedes , sondern geht auf Eudoxos von Knidos zurück , der dieses Prinzip im Rahmen seiner Größenlehre einführte .
+Archimedische Körper Nach Pappos stammen die Archimedischen Körper von ihm .
+Technik Archimedes hat die Technik seiner Zeit und die spätere Entwicklung der Technik , insbesondere der Mechanik , maßgeblich beeinflusst .
+Er selbst konstruierte allerlei mechanische Geräte , nicht zuletzt auch Kriegsmaschinen .
+Archimedische Schraube Datei : Archimedes.png Archimedes wird die Erfindung der sogenannten archimedischen Schraube zugeschrieben , zu der er angeregt wurde , nachdem er bei seinem Studienaufenthalt in Ägypten die dortigen einfachen Vorrichtungen zur Feldbewässerung gesehen hatte . Das Prinzip der archimedischen Schraube kommt heutzutage in modernen Förderanlagen , sogenannten Schneckenförderern zum Einsatz .
+Datei :P arigi griffe.jpg
+Möglicherweise wurde sie von Archimedes als Lenzpumpe für Schiffe entwickelt , denn nach Athenäus von Naukratis beauftragte König Hieron Archimedes mit dem Bau des größten Schiffs der damaligen Zeit , der Syracusia .
+Kriegsmaschinen bei der Belagerung von Syrakus Archimedes soll nach Plutarch die Römer bei ihrer langwierigen Belagerung mit den von ihm entwickelten Kriegsmaschinen aufgehalten haben : So entwickelte er beispielsweise Wurfmaschinen und Katapulte oder auch Seilwinden , welche ein komplettes Schiff , voll beladen und mit gesamter Besatzung , durch Ziehen an einem einzigen Seil bewegten .
+Auch mächtige Greifarme , die feindliche Boote packten und angeblich in Stücke rissen , gehörten dazu .
+Die Kralle von Archimedes soll eine Waffe gegen angreifende Flotten gewesen sein , die in der Stadtmauer von Syrakus eingebaut war und bei dessen Belagerung gegen die Römische Flotte eingesetzt wurde .
+Die genaue Funktion dieser Waffe ist allerdings unklar .
+In alten Schriften wird die Waffe als ein Hebel mit einem großen Eisenhaken dargestellt . Bereits im Jahre 425 v. Chr.
+verfügte die Stadt Syrakus über eine als „ Eisenhand “ beschriebene Seekriegswaffe , mit der man Schiffe entern konnte ( Thukydides , Pel .
+Kr. IV , 25 ) , möglicherweise ein Enterhaken .
+Datei : Thesaurus opticus Titelblatt.jpg
+Brennspiegel Außerdem soll Archimedes die Schiffe der Römer sogar über große Entfernung mit Hilfe von Spiegeln , die das Sonnenlicht umlenkten und fokussierten , in Brand gesteckt haben .
+Das wird von Lukian von Samosata und später von Anthemios von Tralleis berichtet .
+Dazu gibt es eine über 300 Jahre währende , heftige Kontroverse .
+Historisch sprechen die Quellenlage , Übersetzungsfragen ( pyreia wurde oft mit Brennspiegel übersetzt , obwohl es nur „ Entzündung “ heißt und auch Brandpfeile umfasst ) und das erst Jahrhunderte spätere Auftauchen der Legende dagegen .
+Physikalische Gegenargumente sind die notwendige Mindestgröße und Brennweite eines solchen Spiegels , die zu erreichende Mindesttemperatur zur Entzündung von Holz ( etwa 300 Grad Celsius ) und die Zeit , die das zu entzündende Holzstück konstant beleuchtet bleiben muss .
+Technische Gegenargumente diskutieren die Herstellbarkeit solcher Spiegel zur damaligen Zeit , die Montage eines Spiegels oder Spiegelsystems und die Bedienbarkeit .
+Ein moderner Kritiker der Legende war der Pyrotechniker Dennis L. Simms . Zur Machbarkeit wurden mehrfach Experimente durchgeführt .
+Studenten des Massachusetts Institute of Technology und der University of Arizona haben 2005 erfolgreich mit 127 kleinen Spiegeln ein 30 Meter entferntes Modell einer Schiffswand entzündet , nachdem der Versuch zuvor mit zwei Spiegeln misslungen war . Allerdings musste der Himmel wolkenlos sein und das Schiff für rund 10 Minuten konstant bestrahlt werden .
+Ein unter Beteiligung der MIT-Studenten im Hafen von San Francisco an einem Fischerboot wiederholter Versuch in der Fernsehsendung MythBusters mit 500 Freiwilligen ( gesendet im Januar 2006 ) , der zu ähnlichen Ergebnissen kam , wurde deshalb als Fehlschlag eingestuft .
+Zusätzlich wurde angemerkt , dass das Meer in Syrakus im Osten liegt , die römische Flotte also am Morgen hätte angreifen müssen , und dass Wurfgeschosse und Brandpfeile effektiver gewesen wären .
+Möglicherweise entstand die Geschichte als Rückschluss aus der verlorenen Schrift von Archimedes Katóptrika ( Optik ) .
+Weitere Erfindungen Nach Cicero ( De re publica ) brachte Marcellus zwei von Archimedes entwickelte mechanische Planetarien zurück nach Rom .
+Ähnliche Geräte wurden nach Cicero schon von Eudoxos von Knidos und Thales von Milet gebaut – archäologische Beweise für solche Instrumente fanden sich später im Antikythera-Mechanismus . Möglicherweise handelt die verlorengegangene , von Pappos erwähnte Schrift des Archimedes Über die Herstellung von Sphären vom Bau von Planetarien .
+Ihm wird auch die Erfindung eines Odometers zugeschrieben .
+Ein entsprechendes Odometer mit einem Zählmechanismus mit Bällen wurde von Vitruv beschrieben .
+Vitruv verrät den Erfinder nicht ( nur , dass er von den Alten überliefert wurde ) , doch wurde auch hier Archimedes als Erfinder vermutet . Auch ein Wasseruhr-Mechanismus , der Bälle als Zähl-Hilfsmittel freigibt , beschrieben in einem arabischen Manuskript , wurde ihm zugeschrieben .
+Leonardo da Vinci und Petrarca ( der sich auf eine Cicero-Handschrift berief ) schrieben Archimedes die Erfindung einer Dampfkanone zu .
+Leonardo fertigte auch Rekonstruktionsskizzen für die von ihm Architronito genannte Maschine an . Es gab später Versuche von Nachbauten , wie von dem Griechen Ioannis Sakas 1981 und dem italienischen Ingenieur Cesare Rossi von der Universität Neapel 2010 . Rossi gab dort auch den Brennspiegeln eine neue Interpretation – sie hätten demnach die Hitze für die Dampferzeugung geliefert .
+In den überlieferten antiken Schriften von und über Archimedes finden sich dafür aber keine Hinweise und Experten wie Serafina Cuomo sehen darin nur einen weiteren Beweis für den legendären Ruf von Archimedes , dem man alle möglichen Erfindungen zuschrieb .
+Prinzipiell war den Griechen die Dampfkraft bekannt ( Heronsball , 1. Jahrhundert n. Chr. ) .
+Überlieferung Die Kenntnis der Werke des Archimedes war trotz seiner von Legenden gespeisten Bekanntheit in der Antike nicht sehr verbreitet , im Gegensatz etwa zu Euklid , der sein Buch im damaligen wissenschaftlichen Zentrum Alexandria zusammenstellte . Allerdings wird er von den Mathematikern Heron , Pappos und Theon in Alexandria häufig erwähnt .
+Die Schriften wurden zwischen dem 6. und 10. Jahrhundert in Byzanz systematisch gesammelt und kommentiert .
+Bekannt ist der Kommentar des Eutokios ( der von Ende des 5. Jahrhunderts bis Anfang des 6. Jahrhunderts lebte ) zu den wichtigsten Archimedes-Schriften ( Über Kugel und Zylinder , Kreismessung , Gleichgewicht ebener Flächen ) , der auch im Mittelalter in Westeuropa viel zur Kenntnis der Werke beitrug und anregend wirkte .
+Bei der ersten Zusammenstellung der Schriften in Byzanz spielten die Architekten der Hagia Sophia Isidor von Milet und Anthemios von Tralleis eine wichtige Rolle .
+Weitere Schriften kamen hinzu , bis im 9. Jahrhundert Leon von Thessaloniki die als Kodex A ( Heiberg ) bekannte Sammlung fast aller überlieferten Archimedischen Schriften ( außer Stomachion , Rinderproblem , Über die Methode und Über schwimmende Körper ) herausbrachte .
+Das war eine der beiden Quellen für die lateinischen Übersetzungen von Wilhelm von Moerbeke ( abgeschlossen 1269 ) .
+Das andere ihm zur Verfügung stehende griechische Manuskript des Archimedes enthielt Gleichgewicht ebener Flächen , Quadratur der Parabel , Über schwimmende Körper , vielleicht auch Über Spiralen und wurde von Heiberg Kodex B genannt .
+Das 1906 von Heiberg entdeckte Archimedes-Palimpsest ( Kodex C , das vorher in Jerusalem war , es enthielt Über die Methode , Stomachion und Über Schwimmende Körper ) war den Übersetzern in Mittelalter und Renaissance unbekannt .
+Die Kodices A und B kamen aus dem Besitz der normannischen Könige in Sizilien in den Vatikan , wo Moerbeke sie für seine Übersetzung benutzte .
+Während Moerbekes Übersetzungs-Manuskript im Vatikan erhalten ist , ist Kodex B verloren . Von Kodex A sind dagegen mehrere Abschriften erhalten ( neun sind bekannt ) , die zum Beispiel im Besitz von Kardinal Bessarion ( heute in der Biblioteca Marciana ) und Giorgio Valla waren .
+Das Original von Kodex A ist ebenfalls verschwunden .
+Die Übersetzungen Wilhelms von Moerbeke regten insbesondere die Gelehrten der Pariser Schule an ( Nicole Oresme , Johannes de Muris ) .
+Es gibt auch eine arabische Textüberlieferung .
+Archimedes ' wichtigste Werke Über Kugel und Zylinder und Über Kreismessung wurden schon im 9. Jahrhundert ins Arabische übersetzt und mindestens bis ins 13. Jahrhundert immer wieder neu herausgegeben .
+Sie wirkten auch ab dem 12. Jahrhundert im Westen .
+Insbesondere eine Übersetzung der Kreismessung aus dem Arabischen ins Lateinische , die wahrscheinlich von Gerhard von Cremona ( 12. Jahrhundert ) stammt , war im Mittelalter einflussreich . Von ihm stammt auch eine lateinische Übersetzung eines Traktats der Banū Mūsā Brüder , das weitere Ergebnisse von Archimedes enthielt : neben Kreismessung und Satz des Heron ( den die Araber häufig Archimedes zuschrieben ) Teile aus Über Kugel und Zylinder .
+Dieses als Verba filiorum bekannte Manuskript regte zum Beispiel auch Leonardo Fibonacci und Jordanus Nemorarius an .
+Beide wirkten als Mathematiker vor der Zeit , in der Moerbekes Übersetzung entstand .
+Um 1460 ließ Papst Nikolaus V. von Jakob von Cremona eine neue Übersetzung ins Lateinische anfertigen , basierend auf Kodex A. Sie enthielt auch die von Moerbeke noch nicht übersetzten Teile des Werks ( Sandrechner und Kommentar des Eutokios zur Kreismessung ) .
+Da ihm Kodex B nicht zur Verfügung stand , enthält die Ausgabe nicht Über schwimmende Körper .
+Diese Übersetzung wurde unter anderem von Nikolaus von Kues benutzt .
+Die erste gedruckte Ausgabe ( von Auszügen abgesehen , die Giorgio Valla 1501 druckte ) waren die lateinischen Übersetzungen von Kreismessung und Quadratur der Parabel von Luca Gaurico in Venedig 1503 ( nach einem Manuskript aus Madrid ) .
+Sie wurden 1543 von Nicolo Tartaglia wieder veröffentlicht zusammen mit Moerbekes Übersetzungen von Gleichgewicht ebener Flächen und Über schwimmende Körper .
+Die erste Ausgabe des griechischen Textes erschien 1544 in Basel ( herausgegeben von Thomas Venatorius , deutsch Gechauff ) zusammen mit einer lateinischen Übersetzung von Jakob von Cremona ( korrigiert von Regiomontanus ) .
+Die Ausgabe enthielt auch die Kommentare von Eutokios .
+Für den lateinischen Text benutzte er eine von Regiomontanus um 1468 nach Deutschland gebrachte Abschrift der Übersetzung von Jakob von Cremona ( bearbeitet von Regiomontanus ) sowie für den griechischen Text eine von Willibald Pirckheimer aus Rom nach Nürnberg gebrachte Handschrift . Sie war eine Abschrift von Kodex A , weshalb in dieser Editio Princeps-Ausgabe auch Über Schwimmende Körper fehlt .
+1558 erschien eine lateinische Übersetzung einiger Hauptschriften von Federicus Commandinus in Venedig .
+Wichtige weitere Ausgaben vor der Heiberg-Ausgabe waren von D ´ Rivault ( Paris 1615 ) , der nur die Propositionen auf Griechisch bringt und die Beweise in Latein , und von Giuseppe Torelli ( Oxford 1794 ) .
+Sonstiges Ein Bildnis von Archimedes ist auf der höchsten Mathematikerauszeichnung , der Fields-Medaille , geprägt .
+Ihm zu Ehren wurde auf dem Mare Imbrium ein Mondkrater Archimedes genannt ; siehe Archimedes ( Mondkrater ) .
+Auch der Asteroid ( 3600 ) Archimedes trägt seinen Namen .
+István Száva schrieb den Roman Der Gigant von Syrakus ( Prisma , Leipzig 1960 , Corvina , Budapest 1960 , 1968 , 1978 ) .
+Textausgaben Archimedis Opera Omnia .
+Cum commentariis Eutocii
+, 3 Bände , Stuttgart , Teubner 1972 ( Bibliotheca scriptorum Graecorum et Romanorum Teubneriana , Nachdruck der 2. Auflage , Teubner , Leipzig 1910–1915 , erste Auflage 1880/81 , Ausgabe von Heiberg , mit den Kommentaren von Eutokios ) als Band 4 des Nachdrucks von 1972 erschien von Yvonne Dold-Samplonius , H. Hermelink , M. Schramm Archimedes : Über einander berührende Kreise , Stuttgart 1975 Archimède ( 4 vol. ) , ed. Charles Mugler , Paris 1971 ( mit französischer Übersetzung ) Übersetzungen Datei : Archimedous Panta Sozomena.tif
+Archimedes , Werke , Darmstadt , Wissenschaftliche Buchgesellschaft 1963 , 1972 ( Übersetzung Arthur Czwalina nach der Ausgabe von Heiberg für Ostwalds Klassiker in einem Band ) Archimedes , Werke , Verlag Harri Deutsch , 3. Auflage 2009 , ISBN 978-3-8171-3425-0 , ( Nach der Übersetzung von Arthur Czwalina ) , umfasst Reprints von : Über schwimmende Körper und die Sandzahl , Ostwalds Klassiker , Band 213 , Leipzig , Akademische Verlagsgesellschaft 1925 Die Quadratur der Parabel und Über das Gleichgewicht ebener Flächen oder über den Schwerpunkt ebener Flächen , Ostwalds Klassiker , Band 203 , Leipzig , Akademische Verlagsgesellschaft 1923 Kugel und Zylinder , Ostwalds Klassiker , Band 202 , Leipzig , Akademische Verlagsgesellschaft 1922 Über Paraboloide , Hyberboloide und Ellipsoide , Ostwalds Klassiker , Band 210 , Leipzig , Akademische Verlagsgesellschaft 1923 Über Spiralen , Ostwalds Klassiker , Band 201 , Leipzig , Akademische Verlagsgesellschaft 1922 Ferdinand Rudio : Archimedes , Huygens , Lambert , Legendre .
+Vier Abhandlungen über die Kreismessung .
+Teubner , Leipzig 1892 . ( Digitalisat ) ( Archimedes Abhandlung über die Kreismessung ) Heiberg Eine neue Archimedeshandschrift , Hermes : Zeitschrift für Philologie , Band 42 , 1907 , S. 235–303 ( Archimedes lange verschollene Abhandlung über die Methode ) Englische Übersetzung : Geometrical solutions derived from mechanics , a treatise of Archimedes , recently discovered and translated from the Greek by Dr. J. L. Heiberg , Chicago , the Open Court Publishing Company 1909 ( Einführung David Eugene Smith ) , Online bei Gutenberg The method of Archimedes – recently discovered by Heiberg .
+A supplement to the works of Archimedes 1897
+, Herausgeber Thomas L. Heath , Cambridge University Press 1912 Thomas Little Heath ( Hrsg. ) : The Works of Archimedes . Cambridge 1897 , Dover Publications , Mineola NY 1953 , 2002 .
+ISBN 0-486-42084-1 . ( in der Dover Ausgabe mit der Methode ) Deutsche Übersetzung von Fritz Kliem , Berlin 1914 Reviel Netz ( Herausgeber und Übersetzer ) : Works of Archimedes ( with a critical edition of the diagrams and a translation of Eutocius commentary ) , Bd. 1 , Cambridge University Press 2004 ( mit Kommentar , auf drei Bände angelegt ) , ISBN 0-521-66160-9 . Paul ver Eecke Les œuvres complètes d ’ Archimède , traduites du grec en français avec une introduction et des notes , Paris , Brüssel 1921 , 2. Auflage , Paris 1960 mit der Übersetzung der Kommentare von Eutokios Literatur Übersichtsdarstellungen
+Markus Asper : Archimedes von Syrakus . In : Bernhard Zimmermann , Antonios Rengakos ( Hrsg. ) : Handbuch der griechischen Literatur der Antike . Band 2 : Die Literatur der klassischen und hellenistischen Zeit . C. H. Beck , München 2014 , ISBN 978-3-406-61818-5 , S. 465–468 Marshall Clagett : Archimedes . In : Dictionary of Scientific Biography , Scribner ´ s , New York Hans-Joachim Waschkies : Archimedes . In : Hellmut Flashar ( Hrsg. ) : Grundriss der Geschichte der Philosophie .
+Die Philosophie der Antike
+, Band 2/1 , Schwabe , Basel 1998 , ISBN 3-7965-1036-1 , S. 393–399 Gesamtdarstellungen und Untersuchungen
+Ivo Schneider : Archimedes .
+Ingenieur , Naturwissenschaftler und Mathematiker .
+Wissenschaftliche Buchgesellschaft , Darmstadt 1979 .
+ISBN 3-534-06844-0 Reviel Netz , William Noel : Der Codex des Archimedes – das berühmteste Palimpsest der Welt wird entschlüsselt . C. H. Beck 2007 , ISBN 3-406-56336-8 ( englisch : The Archimedes Codex . Weidenfeld and Nicholson 2007 ) Günter Aumann : Archimedes .
+Mathematik in bewegten Zeiten .
+Wissenschaftliche Buchgesellschaft , 2013 Klaus Geus : Mathematik und Biografie : Anmerkungen zu einer Vita des Archimedes . In : Michael Erler , Stefan Schorn ( Hrsg. ) : Die griechische Biographie in hellenistischer Zeit : Akten des internationalen Kongresses vom 26. bis 29. Juli 2006 in Würzburg . Walter de Gruyter , Berlin 2007 .
+S. 319–333 ( Beiträge zur Altertumskunde ; 245 ) .
+Dennis Simms : Archimedes the Engineer . In : History of Technology . Band 17 , 1995 , S. 45–111 . Sherman Stein : Archimedes .
+What did he do besides cry Eureka ?
+Mathematical Association of America , 1999 Andre Koch , Torres Assis : Archimedes , the Center of Gravity , and the First Law of Mechanics . Aperion Publishers , Montreal 2008 ( online ) Chris Rorres : Completing Book 2 of Archimedes On Floating Bodies . In : Mathematical Intelligencer . Band 26 , Nr. 3 , 2004 ( online ) Eduard Jan Dijksterhuis : Archimedes . Groningen 1938 ( niederländisch ) , englische Übersetzung Kopenhagen 1956 , Nachdruck Princeton University Press 1987 ( mit einer Übersicht über die neuere Forschung von Wilbur Richard Knorr ) Isabella Grigorjewna Baschmakowa : Les méthodes différentielles d ’ Archimède . Archive History Exact Sciences , Band 2 , 1962/66 , S. 87–107 Rezeption
+Marshall Clagett : Archimedes in the Middle Ages . 5 Bände , Band 1 : University of Wisconsin Press 1964 , Band 2 bis 5 : Memoirs of the American Philosophical Society 1976 , 1978 , 1980 , 1984 Band 1 : The Arabo-Latin tradition Band 2 : The translations from the Greek by William of Moerbeke ( in zwei Büchern , mit englischem und lateinischem Text ) Band 3 : The fate of the medieval Archimedes 1300–1565 , in drei Büchern ( Teil 1 : The Moerbeke translations of Archimedes at Paris in the fourteenth century , Teil 2 : The Arabo-Latin and handbook traditions of Archimedes in the fourteenth and early fifteenth centuries , Teil 3 : The medieval Archimedes in the renaissance , 1450–1565 ) Band 4 : A supplement on the medieval Latin traditions of conic sections ( 1150–1566 ) , in zwei Büchern Band 5 : Quasi-Archimedean geometry in the thirteenth century , in zwei Büchern Weblinks Digitalisate : Archimdus tu Syrakusiu ta mechri nyn szomena , hapanta .
+Basileae 1544 , Online-Ausgabe der Sächsischen Landesbibliothek – Staats- und Universitätsbibliothek Dresden Des Unvergleichlichen Archimedis Sand-Rechnung , Oder Tiefsinnige Erfindung einer , mit verwunderlicher Leichtigkeit aussprechlichen , Zahl.
+Nürnberg 1667 , Online-Ausgabe der Sächsischen Landesbibliothek – Staats- und Universitätsbibliothek Dresden Des Unvergleichlichen Archimedis Kunst-Bücher Oder Heutigs Tags befindliche Schrifften .
+Nürnberg 1670 , Online-Ausgabe der Sächsischen Landesbibliothek – Staats- und Universitätsbibliothek Dresden Das Palimpsest des Archimedes .
+Von Archimedes
+Archimedes in der „ Bibliotheca Augustana “ Darunter besonders hervorzuheben ist : Die Messung des Kreises
+Archimedes über die Parabel
+Über Archimedes
+Fakten über Archimedes ( englisch ) – Abschnitt über „ Archimedes und die Krone “ auf deutsch bei LEIFI
+Archimedes – Das Genie der Antike
+Archimedes ’ Leben und Werk
+.
+In Our Time , BBC , 25. Januar 2007 ( audio , 45 Min. , englisch ) Einzelnachweise Sherman K. Stein : Archimedes : What Did He Do Besides Cry Eureka ? MAA , 1999 , ISBN 0-88385-718-9 , S. 2–3 ( ) So berichtet Archimedes selbst in seinem Sandrechner . So berichtet Plutarch in Leben des Marcellus . Archimedes widmete den Sandrechner Gelon.Plutarch , Plutarch , Marcellus 17,12 . Cicero : Lateinischer Text , Latin Library Buch 5 , XXIII , 64 , 65 Heath : The works of Archimedes . Dover , S. XXXII . Sie geht auf Heiberg und Hultsch zurück . Ivo Schneider : Archimedes . S. 32 gibt folgende Reihenfolge : 1. Gleichgewicht ebener Flächen , Buch 1 , 2. Quadratur Parabel , 3. Kugel und Zylinder , 4. Spiralen , 5. Konoide und Sphäroide , 6. Gleichgewicht ebener Flächen , Buch 2 , 7. Methode , 8. Schwimmende Körper Ivo Schneider : Archimedes . S. 33f . Ptolemaios III . war 241 v. Chr. vom Syrischen Krieg zurückgekehrt . Seine Gattin Berenike weihte ihr Haar als Dank deshalb der Aphrodite . Bald darauf verschwand es , und man kann die Konon zugeschriebene Benennung eines Sternbildes nach der Locke der Berenike als Wiederentdecken der verlorenen Haare im Himmel deuten . Danach hat Konon , der relativ jung starb , 241 v. Chr. noch gelebt . Ivo Schneider : Archimedes . Kapitel 2.3 A. G. Drachmann : Fragments of Archimedes in Heron ´ s mechanics . Centaurus , Band 8 , 1963 , S. 91–146 , weitere Schriften von Drachmann zur Technologie der Antike und speziell bei Archimedes : The mechanical technology of greek and roman antiquity , Kopenhagen 1963 , Archimedes and the science of physics , Centaurus , Band 12 , 1967 , S. 1–11 , Große griechische Erfinder , Zürich 1967 Boris Rosenfeld : A history of non euclidean geometry , Springer Verlag 1988 , S. 40 f. Sie wird z. B. dargestellt in Henry Mendel : . Chris Rorres : Courant Institute Ivo Schneider : Archimedes . 1979 , Kapitel 3.3 . Zur Interpretation des Ausspruchs von Archimedes auch Drachmann : How Archimedes expected to move the earth . Centaurus , Band 5 , 1958 , S. 278–282 De Architectura IX , Vorwort , Paragraph 9–12 , Deutsche Übersetzung bei Ivo Schneider Archimedes , Kultur und Technik , 1979 , pdf Chris Rorres : Drexel University , 2009Chris Rorres : NOVA | Infinite Secrets | TV Program Description | PBS Zum Beispiel findet sich in Proposition 2 der Vergleich eines Kugelvolumens mit dem eines Zylinders und eines Kreiskegels , Cut the knot , mit der Übersetzung von Heath Ivo Schneider : Archimedes . Wiss. Buchges . 1979 , S. 39 Archimedes : In : Ostwalds Klassiker der exakten Wissenschaften . Nr. 213. Leipzig 1925.Rorres : Aage Drachmann : The screw of Archimedes . Actes du VIIIe Congres International d ´ Histoire des Sciences , Florenz 1958 , Band 3 , S. 940. John Peter Oleson : Greek and Roman Mechanical Water-lifting Devices . Toronto 1984 John Peter Oleson : Water lifting . In : Örjan Wikander ( Hrsg. ) : Handbook of ancient water technology . Leiden 2000 Nach Stephanie Dalley , John Peter Oleson : Sennacherib , Archimedes , and the Water Screw : The Context of Invention in the Ancient World . In : Technology and Culture . Band 44 , 2003 , S. 1–26 , war die Technik möglicherweise schon den Assyrern im 7. Jahrhundert v. Chr. bekannt . Abstract Kurt von Fritz : Grundprobleme der antiken Wissenschaft . Verlag de Gruyter , Berlin 1971 , ISBN 3-11-001805-5 . S. 114. Plutarch , Marcellus , Deutsche Übersetzung von Kaltwasser , Magdeburg 1801 , S. 255 , DigitalisatThukydides , Geschichte des Peloponnesischen Krieges , Teil 1 , Hrsg. Georg Peter Landmann , Sammlung Tusculum , Artemis / Winkler 1993 , S. 525. Nach dem Kommentar von Landmann war das die erste Erwähnung eines Enterhakens . Nach Plinius hat Perikles diesen erfunden . A. A. Mills , R. Clift : Archimedes In : European Journal of Physics . Volume 13 , Number 6 , 1992 Newsoffice 2005 : Archimedes MITnews , 5. Oktober 2005 Gerhard Löwe , Heinrich Alexander Stoll : Die Antike in Stichworten . Bassermann , München 1970 , s. v. Archimedes Vgl. Cicero : De re publica , Buch I , Kap. 21–22 . a maioribus traditam Vitruv : Buch 10 , Kapitel 9 , Bill Thayer , mit Kommentar . André Wegener Sleeswijk : Vitruvius ´ waywiser . Archives internationales d ’ histoire des sciences , Band 29 , 1979 , S. 11–22 , Vitruvius Odometer , Scientific American , Oktober 1981 . Sleeswijk fertigte eine Replik des bei Vitruv beschriebenen Odometers an und vermutete , dass es auf Archimedes zurückging D. R. Hill : On the Construction of Water Clocks : Kit.b Arshimídas fi`amal al‑binkam.t . Turner & Devereux , London 1976 Lahanas zu Katapulten und anderen Kriegsmaschinen der Griechen Jo Marchant : In : New Scientist . 2010 . Eine Stelle bei Plutarch , dass die Römer bei der Belagerung von etwas Pfahlartigem erschreckt waren , das aus den Mauern ragte , und davonliefen , kann auch anders gedeutet werden , z. B. durch die ebenfalls Klaue des Archimedes . Ivo Schneider : Archimedes . S. 160. Die hauptsächlichen Quellen für die Überlieferungsgeschichte sind Heiberg und Claggett ( siehe auch dessen Artikel Archimedes in Dictionary of Scientific Biography ) Es war noch 1311 in einem Katalog der Bibliothek des Vatikan aufgeführt.Seine Benutzung ist zuletzt 1544 nachweisbar . Ivo Schneider : Archimedes . S. 164 De expedentis et fugiendis rebus opus . Venedig 1501 In Nürnberg in der Stadtbibliothek erhalten aus dem Nachlass von Regiomontanus . Astronomie in Nürnberg , Regiomontanus Claggett : Archimedes . Dictionary of Scientific Biography Heath : The works of Archimedes . Dover , S. xxviii 
+
+Aristoteles ( , Betonung lateinisch und deutsch : Aristóteles ; * 384 v. Chr. in Stageira ; † 322 v. Chr. in Chalkis auf Euböa ) war ein griechischer Gelehrter .
+Er gehört zu den bekanntesten und einflussreichsten Philosophen und Naturforschern der Geschichte .
+Sein Lehrer war Platon , doch hat Aristoteles zahlreiche Disziplinen entweder selbst begründet oder maßgeblich beeinflusst , darunter Wissenschaftstheorie , Naturphilosophie , Logik , Biologie , Physik , Ethik , Staatstheorie und Dichtungstheorie .
+Aus seinem Gedankengut entwickelte sich der Aristotelismus .
+Datei : Aristotle Altemps Inv8575.jpg Datei : Aristoteles Louvre.jpg
+Überblick Leben Der aus einer Arztfamilie stammende Aristoteles kam mit siebzehn Jahren nach Athen .
+Im Jahr 367 v. Chr. trat er in Platons Akademie ein .
+Dort beteiligte er sich an Forschung und Lehre .
+Nach Platons Tod verließ er 347 Athen .
+343/342 wurde er Lehrer Alexanders des Großen , des Thronfolgers im Königreich Makedonien .
+335/334 kehrte er nach Athen zurück .
+Er gehörte nun nicht mehr der Akademie an , sondern lehrte und forschte selbständig mit seinen Schülern im Lykeion .
+323/322 musste er wegen politischer Spannungen Athen erneut verlassen und begab sich nach Chalkis , wo er bald darauf verstarb .
+Werk Die an eine breite Öffentlichkeit gerichteten Schriften des Aristoteles in Dialogform sind verloren .
+Die erhalten gebliebenen Lehrschriften waren größtenteils nur für den internen Gebrauch im Unterricht bestimmt und wurden fortlaufend redigiert .
+Themenbereiche sind : Logik , Wissenschaftstheorie , Rhetorik : In den logischen Schriften arbeitet Aristoteles auf der Grundlage von Diskussionspraktiken in der Akademie eine Argumentationstheorie ( Dialektik ) aus und begründet mit der Syllogistik die formale Logik .
+Auf der Basis seiner Syllogistik erarbeitet er eine Wissenschaftstheorie und liefert unter anderem bedeutende Beiträge zur Definitionstheorie und Bedeutungstheorie .
+Die Rhetorik beschreibt er als die Kunst , Aussagen als plausibel zu erweisen , und rückt sie damit in die Nähe der Logik .
+Naturlehre : Aristoteles ’ Naturphilosophie thematisiert die Grundlagen jeder Naturbetrachtung : die Arten und Prinzipien der Veränderung .
+Der damals aktuellen Frage , wie Entstehen und Vergehen möglich ist , begegnet er mit Hilfe seiner bekannten Unterscheidung von Form und Materie : Dieselbe Materie kann unterschiedliche Formen annehmen .
+In seinen naturwissenschaftlichen Werken untersucht er auch die Teile und die Verhaltensweisen der Tiere sowie des Menschen und ihre Funktionen .
+In seiner Seelenlehre – in der „ beseelt sein “ „ lebendig sein “ bedeutet – argumentiert er , dass die Seele , die die verschiedenen vitalen Funktionen von Lebewesen ausmache , dem Körper als seine Form zukomme .
+Er forscht aber auch empirisch und liefert bedeutende Beiträge zur zoologischen Biologie .
+Metaphysik : In seiner Metaphysik argumentiert Aristoteles ( gegen Platons Annahme von abstrakten Entitäten ) zunächst dafür , dass die konkreten Einzeldinge ( wie Sokrates ) die Substanzen , d. h.
+das Grundlegende aller Wirklichkeit sind .
+Dies ergänzt er um seine spätere Lehre , wonach die Substanz konkreter Einzeldinge ihre Form ist .
+Ethik und Staatslehre : Das Ziel des menschlichen Lebens , so Aristoteles in seiner Ethik , ist das gute Leben , das Glück .
+Für ein glückliches Leben muss man Verstandestugenden und ( durch Erziehung und Gewöhnung ) Charaktertugenden ausbilden , wozu ein entsprechender Umgang mit Begierden und Emotionen gehört .
+Seine politische Philosophie schließt an die Ethik an .
+Demnach ist der Staat als Gemeinschaftsform eine Voraussetzung für das menschliche Glück .
+Aristoteles fragt nach den Bedingungen des Glücks und vergleicht zu diesem Zweck unterschiedliche Verfassungen .
+Die Staatsformenlehre , die er entwickelt hat , genoss über viele Jahrhunderte unangefochtene Autorität .
+Dichtungstheorie : In seiner Theorie der Dichtung behandelt Aristoteles insbesondere die Tragödie , deren Funktion aus seiner Sicht darin besteht , Furcht und Mitleid zu erregen , um beim Zuschauer eine Reinigung von diesen Emotionen zu bewirken ( katharsis ) .
+Nachwirkung Das naturwissenschaftliche Forschungsprogramm des Aristoteles wurde nach seinem Tod von seinem Mitarbeiter Theophrastos fortgesetzt , der auch die aristotelische Schule , den Peripatos , im juristischen Sinne gründete .
+Die Aristoteles-Kommentierung setzte erst im 1. Jahrhundert v. Chr. ein und wurde insbesondere von Platonikern betrieben .
+Durch die Vermittlung von Porphyrios und Boethius wurde die aristotelische Logik für das lateinischsprachige Mittelalter wegweisend .
+Seit dem 12. / 13.
+Jahrhundert lagen alle grundlegenden Werke des Aristoteles in lateinischer Übersetzung vor .
+Sie waren für den Wissenschaftsbetrieb der Scholastik bis in die Frühe Neuzeit maßgeblich .
+Die Auseinandersetzung mit der aristotelischen Naturlehre prägte die Naturwissenschaft des Spätmittelalters und der Renaissance .
+Im arabischsprachigen Raum war Aristoteles im Mittelalter der am intensivsten rezipierte antike Autor .
+Sein Werk hat auf vielfältige Weise die Geistesgeschichte geprägt ; wichtige Unterscheidungen und Begriffe wie „ Substanz “ , „ Akzidenz “ , „ Materie “ , „ Form “ , „ Energie “ , „ Potenz “ , „ Kategorie “ , „ Theorie “ und „ Praxis “ gehen auf Aristoteles zurück .
+Leben Aristoteles wurde 384 v. Chr. in Stageira , einer damals selbständigen ionischen Kleinstadt an der Ostküste der Chalkidike , geboren .
+Daher wird er mitunter „ der Stagirit “ genannt .
+Sein Vater Nikomachos war Leibarzt des Königs Amyntas III . von Makedonien , seine Mutter Phaestis stammte aus einer Arztfamilie von Chalkis auf Euboia .
+Nikomachos starb , bevor Aristoteles volljährig wurde .
+Proxenos aus Atarneus wurde zum Vormund bestimmt .
+Erster Athenaufenthalt 367 v. Chr. kam Aristoteles als Siebzehnjähriger nach Athen und trat in Platons Akademie ein .
+Dort beschäftigte er sich zunächst mit den mathematischen und dialektischen Themen , die den Anfang der Studien in der Akademie bildeten .
+Schon früh begann er Werke zu verfassen , darunter Dialoge nach dem Vorbild derjenigen Platons .
+Er setzte sich auch mit der zeitgenössischen Rhetorik auseinander , insbesondere mit dem Unterricht des Redners Isokrates .
+Gegen das auf unmittelbaren Nutzen abzielende pädagogische Konzept des Isokrates verteidigte er das platonische Erziehungsideal der philosophischen Schulung des Denkens .
+Er nahm eine Lehrtätigkeit an der Akademie auf .
+In diesem Zusammenhang entstanden als Vorlesungsmanuskripte die ältesten seiner überlieferten Lehrschriften , darunter die logischen Schriften , die später unter der Bezeichnung Organon ( „ Werkzeug “ ) zusammengefasst wurden .
+Einige Textstellen lassen erkennen , dass der Hörsaal mit Gemälden geschmückt war , die Szenen aus dem Leben von Platons Lehrer Sokrates zeigten .
+Reisejahre Nach Platons Tod verließ Aristoteles 347 v. Chr. Athen .
+Möglicherweise war er nicht damit einverstanden , dass Platons Neffe Speusippos die Leitung der Akademie übernahm ; außerdem war er in politische Schwierigkeiten geraten .
+Im Jahr 348 v. Chr. hatte König Philipp II . von Makedonien die Chalkidike erobert , Olynthos zerstört und auch Aristoteles ’ Heimatstadt Stageira eingenommen .
+Dieser Feldzug wurde von der antimakedonischen Partei in Athen als schwere Bedrohung der Unabhängigkeit Athens erkannt .
+Wegen der traditionellen Verbundenheit der Familie des Aristoteles mit dem makedonischen Hof richtete sich die antimakedonische Stimmung auch gegen ihn .
+Da er kein Athener Bürger war , sondern nur ein Metöke von zweifelhafter Loyalität , war seine Stellung in der Stadt relativ schwach .
+Er folgte einer Einladung des Hermias , der die Städte Assos und Atarneus an der kleinasiatischen Küste gegenüber der Insel Lesbos beherrschte .
+Zur Sicherung seines Machtbereichs gegen die Perser war Hermias mit Makedonien verbündet .
+In Assos fanden auch andere Philosophen Zuflucht .
+Der sehr umstrittene Hermias wird von der ihm freundlichen Überlieferung als weiser und heldenhafter Philosoph , von der gegnerischen aber als Tyrann beschrieben . Aristoteles , der mit Hermias befreundet war , blieb zunächst in Assos ; 345/344 v. Chr. übersiedelte er nach Mytilene auf Lesbos .
+Dort arbeitete er mit seinem aus Lesbos stammenden Schüler Theophrastos zusammen , der sein Interesse für Biologie teilte .
+Später begaben sich beide nach Stageira .
+343/342 v. Chr. ging Aristoteles auf Einladung von Philipp II .
+nach Mieza , um dessen damals dreizehnjährigen Sohn Alexander ( später „ der Große “ genannt ) zu unterrichten .
+Die Unterweisung endete spätestens 340/339 v. Chr. , als Alexander für seinen abwesenden Vater die Regentschaft übernahm .
+Aristoteles ließ für Alexander eine Abschrift der Ilias anfertigen , die der König als Verehrer des Achilleus später auf seinen Eroberungszügen mit sich führte .
+Das Verhältnis zwischen Lehrer und Schüler ist nicht näher überliefert ; es hat zur Legendenbildung und vielerlei Spekulationen Anlass gegeben .
+Sicher ist , dass ihre politischen Überzeugungen grundverschieden waren ; ein Einfluss des Aristoteles auf Alexander ist jedenfalls nicht erkennbar . Aristoteles soll allerdings am makedonischen Hof den Wiederaufbau seiner zerstörten Heimatstadt Stageira erreicht haben ; die Glaubwürdigkeit dieser Nachricht ist aber zweifelhaft .
+Die Hinrichtung des Hermias durch die Perser 341/340 berührte Aristoteles tief , wie ein dem Andenken des Freundes gewidmetes Gedicht zeigt .
+Als nach dem Tode des Speusippos 339/338 v. Chr. in der Akademie das Amt des Scholarchen ( Schulleiters ) frei wurde , konnte Aristoteles nur wegen seiner Abwesenheit an der Wahl des Nachfolgers nicht teilnehmen ; er galt aber weiterhin als Akademiemitglied .
+Später ging er mit seinem Großneffen , dem Geschichtsschreiber Kallisthenes , nach Delphi , um im Auftrag der dortigen Amphiktyonen eine Siegerliste der Pythischen Spiele anzufertigen .
+Zweiter Athenaufenthalt Mit der Zerstörung der rebellischen Stadt Theben 335 v. Chr. brach der offene Widerstand gegen die Makedonen in Griechenland zusammen , und auch in Athen arrangierte man sich mit den Machtverhältnissen .
+Daher konnte Aristoteles 335/334 v. Chr. nach Athen zurückkehren und begann dort wieder zu forschen und zu lehren , war aber nun nicht mehr an der Akademie tätig , sondern in einem öffentlichen Gymnasium , dem Lykeion .
+Hier schuf er eine eigene Schule , deren Leitung nach seinem Tod Theophrastos übernahm .
+Neue Grabungen haben möglicherweise die Identifizierung des Gebäudekomplexes ermöglicht . Im juristischen Sinne hat aber erst Theophrastos die Schule gegründet und das Grundstück erworben – die später üblichen Bezeichnungen Peripatos und Peripatetiker speziell für diese Schule sind für die Zeit des Theophrastos noch nicht bezeugt .
+Die Fülle des Materials , das Aristoteles sammelte ( etwa zu den 158 Verfassungen der griechischen Stadtstaaten ) , lässt darauf schließen , dass er über zahlreiche Mitarbeiter verfügte , die auch außerhalb von Athen recherchierten .
+Er war wohlhabend und besaß eine große Bibliothek .
+Sein Verhältnis zum makedonischen Statthalter Antipatros war freundschaftlich .
+Rückzug aus Athen , Tod und Nachkommen Nach dem Tod Alexanders des Großen 323 v. Chr. setzten sich in Athen und anderen griechischen Städten zunächst antimakedonische Kräfte durch .
+Delphi widerrief ein Aristoteles verliehenes Ehrendekret .
+In Athen kam es zu Anfeindungen , die ihm ein ruhiges Weiterarbeiten unmöglich machten .
+Daher verließ er 323/322 v. Chr. Athen .
+Angeblich äußerte er bei diesem Anlass , dass er nicht wollte , dass die Athener sich ein zweites Mal gegen die Philosophie vergingen ( nachdem sie bereits Sokrates zum Tode verurteilt hatten ) . Er zog sich nach Chalkis auf Euboia in das Haus seiner Mutter zurück .
+Dort starb er im Oktober 322 v. Chr.
+Aristoteles war mit Pythias , einer Verwandten seines Freundes Hermias , verheiratet .
+Von ihr hatte er eine Tochter , die ebenfalls Pythias hieß .
+Nach dem Tod seiner Gattin wurde Herpyllis , die niedriger Herkunft war , seine Lebensgefährtin ; sie war möglicherweise die Mutter seines Sohnes Nikomachos .
+In seinem Testament , dessen Vollstreckung er Antipatros anvertraute , regelte Aristoteles unter anderem die künftige Verheiratung seiner noch minderjährigen Tochter und traf Vorkehrungen zur materiellen Absicherung von Herpyllis .
+Werk Hinweis : Belege aus Werken des Aristoteles sind folgendermaßen angegeben : Titelangabe ( Abkürzungen werden an der ersten Stelle im Kapitel per Link aufgelöst ) und gegebenenfalls Buch- und Kapitelangabe sowie Bekker-Zahl .
+Die Bekker-Zahl gibt eine genaue Stelle im Corpus an .
+Sie ist in guten modernen Ausgaben vermerkt .
+Aufgrund von Brüchen und Inkonsequenzen im Werk des Aristoteles ist die Forschung von der früher verbreiteten Vorstellung abgekommen , das überlieferte Werk bilde ein abgeschlossenes , durchkomponiertes System .
+Diese Brüche gehen vermutlich auf Entwicklungen , Perspektivwechsel und unterschiedliche Akzentuierungen in verschiedenen Kontexten zurück .
+Da eine sichere chronologische Reihenfolge seiner Schriften nicht bestimmt werden kann , bleiben Aussagen über Aristoteles ’ tatsächliche Entwicklung Vermutungen .
+Zwar bildet sein Werk de facto kein fertiges System , doch besitzt seine Philosophie Eigenschaften eines potentiellen Systems .
+Überlieferung und Charakter der Schriften Verschiedene antike Verzeichnisse schreiben Aristoteles fast 200 Titel zu .
+Sofern die Angabe des Diogenes Laertios stimmt , hat Aristoteles ein Lebenswerk von über 445.270 Zeilen hinterlassen ( wobei in dieser Zahl zwei der umfangreichsten Schriften – die Metaphysik und die Nikomachische Ethik – vermutlich noch nicht berücksichtigt sind ) .
+Nur etwa ein Viertel davon ist überliefert .
+In der Forschung werden zwei Gruppen unterschieden : exoterische Schriften ( die für ein breiteres Publikum veröffentlicht worden sind ) und esoterische ( die zum internen Gebrauch der Schule dienten ) .
+Alle exoterischen Schriften sind nicht oder nur in Fragmenten vorhanden , die meisten esoterischen sind hingegen überliefert .
+Die Schrift Die Verfassung der Athener galt als verloren und wurde erst Ende des 19. Jahrhunderts in Papyrusform gefunden .
+Exoterische und esoterische Schriften Die exoterischen Schriften bestanden vor allem aus Dialogen in der Tradition Platons , z. B.
+der Protreptikos – eine Werbeschrift für die Philosophie – , Untersuchungen wie Über die Ideen , aber auch propädeutische Sammlungen .
+Cicero lobt ihren „ goldenen Fluss der Rede “ . Die auch Pragmatien genannten esoterischen Schriften sind vielfach als Vorlesungsmanuskripte bezeichnet worden ; gesichert ist dies nicht und für einige Schriften oder Abschnitte auch unwahrscheinlich .
+Weitgehend herrscht die Auffassung , dass sie aus der Lehrtätigkeit erwachsen sind .
+Weite Teile der Pragmatien weisen einen eigentümlichen Stil voller Auslassungen , Andeutungen , Gedankensprünge und Dubletten auf .
+Daneben finden sich jedoch auch stilistisch ausgefeilte Passagen , die ( neben den Dubletten ) deutlich machen , dass Aristoteles wiederholt an seinen Texten gearbeitet hat , und die Möglichkeit nahelegen , dass er an die Veröffentlichung mindestens einiger der Pragmatien gedacht hat .
+Aristoteles setzt bei seinen Adressaten große Vorkenntnisse fremder Texte und Theorien voraus .
+Verweise auf die exoterischen Schriften zeigen , dass deren Kenntnis ebenfalls vorausgesetzt wird .
+Die Manuskripte des Aristoteles Nach dem Tod des Aristoteles blieben seine Manuskripte zunächst im Besitz seiner Schüler .
+Als sein Schüler und Nachfolger Theophrast starb , soll dessen Schüler Neleus die Bibliothek des Aristoteles erhalten und mit dieser – aus Ärger darüber , nicht zum Nachfolger gewählt worden zu sein – mit einigen Anhängern Athen Richtung Skepsis in der Nähe Trojas in Kleinasien verlassen haben .
+Die antiken Berichte erwähnen eine abenteuerliche und zweifelhafte Geschichte , nach der die Erben des Neleus die Manuskripte zur Sicherung vor fremdem Zugriff im Keller vergruben , wo sie dann aber verschollen blieben .
+Weitgehend gesichert ist , dass im ersten Jahrhundert v. Chr. Apellikon von Teos die beschädigten Manuskripte erworben und nach Athen gebracht hat und dass sie nach der Eroberung von Athen durch Sulla im Jahr 86 v. Chr. nach Rom gelangten .
+Dessen Sohn beauftragte Mitte des Jahrhunderts Tyrannion , die Manuskripte zu sichten und durch weiteres Material zu ergänzen .
+Weitere Überlieferungswege Auch wenn mit der Bibliothek des Aristoteles seine Manuskripte jahrhundertelang verschollen waren , ist es unbestritten , dass seine Lehre im Hellenismus mindestens teilweise bekannt war , vor allem durch die exoterischen Schriften und indirekt wohl auch durch Theophrasts Wirken .
+Daneben müssen einige Pragmatien bekannt gewesen sein , von denen es möglicherweise Abschriften in der Bibliothek des Peripatos gab .
+Andronikos von Rhodos .
+Die erste Ausgabe Auf der Grundlage der Arbeit Tyrannions besorgte dessen Schüler Andronikos von Rhodos in der zweiten Hälfte des ersten Jahrhunderts v. Chr. die erste Ausgabe der aristotelischen Pragmatien , die wohl nur zum Teil auf den Manuskripten des Aristoteles beruhte .
+Die Schriften dieser Edition bilden das Corpus Aristotelicum .
+Vermutlich gehen einige Zusammenstellungen von zuvor ungeordneten Büchern sowie einige Titel auf diese Ausgabe zurück .
+Möglicherweise hat Andronikos auch darüber hinaus Eingriffe in den Text – wie etwa Querverweise – vorgenommen .
+Im Fall der zahlreichen Dubletten hat er möglicherweise verschiedene Texte zum selben Thema hintereinander angeordnet .
+Die heutige Anordnung der Schriften entspricht weitgehend dieser Ausgabe .
+Die zu seiner Zeit noch vorliegenden exoterischen Schriften berücksichtigte Andronikos nicht .
+Sie gingen in der Folgezeit verloren .
+Handschriften und Druckausgaben Heutige Ausgaben beruhen auf Abschriften , die auf die Andronikos-Ausgabe zurückgehen .
+Mit über 1000 Handschriften ist Aristoteles unter den nichtchristlichen griechischsprachigen Autoren derjenige mit der weitesten Verbreitung .
+Die ältesten Handschriften stammen aus dem 9. Jahrhundert .
+Das Corpus Aristotelicum ist wegen seines Umfangs nie vollständig in einem einzigen Kodex enthalten .
+Nach der Erfindung des Buchdrucks erschien 1495–1498 die erste Druckausgabe aus der Hand von Aldus Manutius .
+Die von Immanuel Bekker 1831 besorgte Gesamtausgabe der Berliner Akademie ist die Grundlage der modernen Aristotelesforschung .
+Sie beruht auf Kollationen der besten damals zugänglichen Handschriften .
+Nach ihrer Seiten- , Spalten- und Zeilenzählung ( Bekker-Zählung ) wird Aristoteles heute noch überall zitiert .
+Für einige wenige Werke bietet sie noch immer den maßgeblichen Text ; die meisten liegen jedoch heute in neuen Einzelausgaben vor .
+Einteilung der Wissenschaften und Grundlegendes Aristoteles ’ Werk deckt weite Teile des zu seiner Zeit vorhandenen Wissens ab .
+Er teilt es in drei Bereiche : theoretische Wissenschaft praktische Wissenschaft poietische Wissenschaft Das theoretische Wissen wird um seiner selbst willen gesucht .
+Praktisches und poietisches Wissen hat einen weiteren Zweck , die ( gute ) Handlung oder ein ( schönes oder nützliches ) Werk .
+Nach der Art der Gegenstände untergliedert er das theoretische Wissen weiter : ( i ) Die Erste Philosophie ( „ Metaphysik “ ) behandelt ( mit der Substanztheorie , der Prinzipientheorie und der Theologie ) Selbstständiges und Unveränderliches , ( ii ) die Naturwissenschaft Selbstständiges und Veränderliches und ( iii ) die Mathematik behandelt Unselbständiges und Unveränderliches ( Met. VI 1 ) .
+Eine Sonderstellung scheinen die in dieser Einteilung nicht vorkommenden Schriften zu haben , die erst nach dem Tod des Aristoteles im sogenannten Organon zusammengestellt worden sind .
+Die wichtigsten Schriften lassen sich grob folgendermaßen gliedern : Mit dieser Einteilung der Wissenschaften geht für Aristoteles die Einsicht einher , dass jede Wissenschaft aufgrund ihrer eigentümlichen Objekte auch eigene Prinzipien besitzt .
+So kann es in der praktischen Wissenschaft – dem Bereich der Handlungen – nicht dieselbe Genauigkeit geben wie im Bereich der theoretischen Wissenschaften .
+Es ist zwar eine Wissenschaft der Ethik möglich , aber ihre Sätze gelten nur in der Regel .
+Auch kann diese Wissenschaft nicht für alle möglichen Situationen die richtige Handlungsweise vorgeben .
+Vielmehr vermag die Ethik nur ein nicht-exaktes Wissen im Grundriss zu liefern , das zudem allein noch nicht zu einer erfolgreichen Lebensführung befähigt , sondern hierfür an Erfahrungen und bestehende Haltungen anschließen muss ( EN I 1 1094b12–23 ) .
+Aristoteles war davon überzeugt , dass die „ Menschen für das Wahre von Natur aus hinlänglich begabt sind “ ( Rhet . I 1 , 1355a15–17 ) .
+Daher geht er typischerweise zunächst ( allgemein oder bei Vorgängern ) anerkannte Meinungen ( endoxa ) durch und diskutiert deren wichtigsten Probleme ( aporiai ) , um einen möglichen wahren Kern dieser Meinungen zu analysieren ( EN VII 2 ) .
+Auffällig ist seine Vorliebe , in einer Allaussage zu Beginn einer Schrift die Grundlage für die Argumentation zu legen und den spezifischen Gegenstand abzustecken .
+Sprache , Logik und Wissen Das Organon
+Der Themenbereich Sprache , Logik und Wissen ist vor allem in den Schriften behandelt , die traditionell unter dem Titel Organon ( griech. Werkzeug , Methode ) zusammengestellt sind .
+Diese Zusammenstellung und ihr Titel stammen nicht von Aristoteles , und die Reihenfolge ist nicht chronologisch .
+Die Schrift Rhetorik gehört dem Organon nicht an , steht ihm aber inhaltlich wegen ihrer Art der Behandlung des Gegenstands sehr nahe .
+Eine Berechtigung für die Zusammenstellung besteht in dem gemeinsamen methodologisch-propädeutischen Charakter .
+Bedeutungstheorie Im folgenden Abschnitt – der als der einflussreichste Text in der Geschichte der Semantik gilt – unterscheidet Aristoteles vier Elemente , die in zwei verschiedenen Beziehungen zueinander stehen , einer Abbildungsbeziehung und einer Symbolbeziehung : Gesprochene und geschriebene Worte sind demnach bei den Menschen verschieden ; geschriebene Worte symbolisieren gesprochene Worte .
+Seelische Widerfahrnisse und die Dinge sind bei allen Menschen gleich ; seelische Widerfahrnisse bilden die Dinge ab .
+Demnach ist die Beziehung von Rede und Schrift zu den Dingen durch Übereinkunft festgelegt , die Beziehung der mentalen Eindrücke zu den Dingen hingegen naturgegeben .
+Wahrheit und Falschheit kommt erst der Verbindung und Trennung von mehreren Vorstellungen zu .
+Auch die einzelnen Wörter stellen noch keine Verbindung her und können daher je allein nicht wahr oder falsch sein .
+Wahr oder falsch kann daher erst der ganze Aussagesatz ( logos apophantikos ) sein .
+Prädikate und Eigenschaften Einige sprachlich-logische Feststellungen sind für Aristoteles ’ Philosophie fundamental und spielen auch außerhalb der ( im weiteren Sinne ) logischen Schriften eine bedeutende Rolle .
+Hierbei geht es insbesondere um das Verhältnis von Prädikaten und ( wesentlichen ) Eigenschaften .
+Definitionen Unter einer Definition versteht Aristoteles primär keine Nominaldefinition ( die er auch kennt ; siehe An .
+Post .
+II , 8–10 ) , sondern eine Realdefinition .
+Eine Nominaldefinition gibt nur Meinungen an , welche sich mit einem Namen verbinden .
+Was diesen Meinungen in der Welt zugrunde liegt , gibt die Realdefinition an : eine Definition von X gibt notwendige Eigenschaften von X an und was es heißt , ein X zu sein : das Wesen .
+Möglicher Gegenstand einer Definition ist damit ( nur ) das , was ein ( universales ) Wesen aufweist , insbesondere Arten wie Mensch . Eine Art wird definiert durch die Angabe einer ( logischen ) Gattung und der artbildenden Differenz .
+So lässt sich Mensch definieren als vernunftbegabtes ( Differenz ) Lebewesen ( Gattung ) .
+Individuen lassen sich mithin nicht durch Definition erfassen , sondern nur ihrer jeweiligen Art zuweisen .
+Kategorien als Aussageklassen Aristoteles lehrt , dass es zehn nicht aufeinander zurückführbare Aussageweisen gibt , die auf die Fragen Was ist X ? , Wie beschaffen ist X ? , Wo ist X ? etc. antworten ( → die vollständige Liste ) .
+Die Kategorien haben sowohl eine sprachlich-logische als auch eine ontologische Funktion , denn von einem zugrunde liegenden Subjekt ( hypokeimenon ) ( z. B.
+Sokrates ) werden einerseits Prädikate ausgesagt , und ihm kommen andererseits Eigenschaften zu ( z. B. : weiß , Mensch ) .
+Entsprechend stellen die Kategorien die allgemeinsten Klassen sowohl von Prädikaten als auch des Seienden dar .
+Dabei hebt Aristoteles die Kategorie der Substanz , die notwendig zukommende , wesentliche Prädikate enthält , von den anderen ab , die akzidentelle Prädikate enthalten .
+Wenn man von Sokrates Mensch prädiziert ( aussagt ) , so handelt es sich um eine wesentliche Aussage , die vom Subjekt ( Sokrates ) angibt , was er ist , also die Substanz benennt .
+Dies unterscheidet sich offensichtlich von einer Aussage wie Sokrates ist auf dem Marktplatz , mit der man etwas Akzidentelles angibt , nämlich wo Sokrates ist ( also den Ort benennt ) .
+Deduktion und Induktion : Argumenttypen und Erkenntnismittel Aristoteles unterscheidet zwei Typen von Argumenten oder Erkenntnismitteln : Deduktion ( syllogismos ) und Induktion ( epagôgê ) . Die Übereinstimmung mit den modernen Begriffen Deduktion und Induktion ist dabei weitgehend , aber nicht vollständig .
+Deduktionen und Induktionen spielen in den verschiedenen Bereichen der aristotelischen Argumentationstheorie und Logik zentrale Rollen .
+Beide stammen ursprünglich aus der Dialektik .
+Deduktion Nach Aristoteles besteht eine Deduktion aus Prämissen ( Annahmen ) und einer von diesen verschiedenen Konklusion .
+Die Konklusion folgt mit Notwendigkeit aus den Prämissen .
+Sie kann nicht falsch sein , wenn die Prämissen wahr sind .
+Die Definition der Deduktion ( syllogismos ) ist also weiter als die der ( unten behandelten ) – traditionell Syllogismus genannten – Deduktion , die aus zwei Prämissen und drei Termen besteht .
+Aristoteles unterscheidet dialektische , eristische , rhetorische und demonstrative Deduktionen .
+Diese Formen unterscheiden sich vor allem nach der Art ihrer Prämissen .
+Induktion Der Deduktion stellt Aristoteles explizit die Induktion gegenüber ; deren Bestimmung und Funktion ist allerdings nicht so klar wie die der Deduktion .
+Er nennt sie Aristoteles ist klar , dass ein derartiges Übergehen von singulären zu allgemeinen Sätzen ohne weitere Bedingungen nicht logisch gültig ist ( An .
+Post .
+II 5 , 91b34 f. ) . Entsprechende Bedingungen werden beispielsweise in dem ursprünglichen , argumentationslogischen Kontext der Dialektik erfüllt , da der Kontrahent einen durch Induktion eingeführten Allgemeinsatz akzeptieren muss , wenn er kein Gegenbeispiel nennen kann .
+Vor allem aber hat die Induktion die Funktion , in anderen , nicht folgernden Kontexten durch das Anführen von Einzelfällen das Allgemeine deutlich zu machen – sei es als didaktisches , sei es als heuristisches Verfahren .
+Eine derartige Induktion stellt plausible Gründe dafür bereit , einen allgemeinen Satz für wahr zu halten .
+Aristoteles rechtfertigt aber nirgends ohne weitere Bedingungen induktiv die Wahrheit eines solchen Satzes .
+Dialektik : Theorie der Argumentation Die in der Topik behandelte Dialektik ist eine Form der Argumentation , die ( ihrer genuinen Grundform nach ) in einer dialogischen Disputation stattfindet .
+Sie geht vermutlich auf Praktiken in Platons Akademie zurück .
+Die Zielsetzung der Dialektik lautet : Die Dialektik hat demnach keinen bestimmten Gegenstandsbereich , sondern kann universal angewendet werden .
+Aristoteles bestimmt die Dialektik durch die Art der Prämissen dieser Deduktion .
+Ihre Prämissen sind anerkannte Meinungen ( endoxa ) , das heißt Für dialektische Prämissen ist es unerheblich , ob sie wahr sind oder nicht .
+Weshalb aber anerkannte Meinungen ?
+In ihrer Grundform findet Dialektik in einem argumentativen Wettstreit zwischen zwei Gegnern statt mit genau zugewiesenen Rollen .
+Auf ein vorgelegtes Problem der Form ‚ Ist S P oder nicht ? ‘ muss der Antwortende sich auf eine der beiden Möglichkeiten als These festlegen . Das dialektische Gespräch besteht nun darin , dass ein Fragender dem Antwortenden Aussagen vorlegt , die dieser entweder bejahen oder verneinen muss . Die beantworteten Fragen gelten als Prämissen .
+Das Ziel des Fragenden besteht nun darin , mithilfe der bejahten oder verneinten Aussagen eine Deduktion zu bilden , so dass die Konklusion die Ausgangsthese widerlegt oder aus den Prämissen etwas Absurdes oder ein Widerspruch folgt .
+Die Methode der Dialektik weist zwei Bestandteile auf : herausfinden , welche Prämissen ein Argument für die gesuchte Konklusion ergeben .
+herausfinden , welche Prämissen der Antwortende akzeptiert .
+Für 2. bieten die verschiedenen Typen ( a ) – ( ciii ) anerkannter Meinungen dem Fragenden Anhaltspunkte dafür , welche Fragen der jeweilige Antwortende bejahen wird , das heißt , welche Prämissen er verwenden kann .
+Aristoteles fordert dazu auf , Listen solcher anerkannter Meinungen anzulegen ( Top. I 14 ) .
+Vermutlich meint er nach den Gruppen ( a ) – ( ciii ) getrennte Listen ; diese werden wiederum nach Gesichtspunkten geordnet .
+Für 1. hilft dem Dialektiker in seinem Argumentationsaufbau das Instrument der Topen .
+Ein Topos ist eine Konstruktionsanleitung für dialektische Argumente , das heißt zur Auffindung geeigneter Prämissen für eine gegebene Konklusion .
+Aristoteles listet in der Topik etwa 300 dieser Topen auf .
+Der Dialektiker kennt diese Topen auswendig , die sich aufgrund ihrer Eigenschaften ordnen lassen .
+Die Basis dieser Ordnung stellt das System der Prädikabilien dar .
+Nach Aristoteles ist die Dialektik für dreierlei nützlich : ( 1 ) als Übung , ( 2 ) für die Begegnung mit der Menge und ( 3 ) für die Philosophie .
+Neben ( 1 ) der Grundform des argumentativen Wettstreits ( bei der es eine Jury und Regeln gibt und die wahrscheinlich auf Praktiken in der Akademie zurückgeht ) gibt es mit ( 2 ) auch Anwendungsweisen , die zwar dialogisch , aber nicht als regelbasierter Wettstreit angelegt sind , sowie mit ( 3 ) solche , die nicht dialogisch sind , sondern in denen der Dialektiker im Gedankenexperiment ( a ) Schwierigkeiten nach beiden Seiten hin durchgeht ( diaporêsai ) oder auch ( b ) Prinzipien untersucht ( Top. I 4 ) .
+Für ihn ist die Dialektik aber nicht wie bei Platon die Methode der Philosophie oder eine Fundamentalwissenschaft .
+Rhetorik : Theorie der Überzeugung Aristoteles definiert Rhetorik als „ Fähigkeit , bei jeder Sache das möglicherweise Überzeugende ( pithanon ) zu betrachten “ ( Rhetorik I 2 , 1355b26 f. ) . Er nennt sie ein Gegenstück ( antistrophos ) zur Dialektik .
+Denn ebenso wie die Dialektik ist die Rhetorik ohne abgegrenzten Gegenstandsbereich , und sie verwendet dieselben Elemente ( wie Topen , anerkannte Meinungen und insbesondere Deduktionen ) , und dem dialektischen Schließen entspricht das auf rhetorischen Deduktionen basierende Überzeugen .
+Der Rhetorik kam im demokratischen Athen des vierten Jahrhunderts eine herausragende Bedeutung zu , insbesondere in der Volksversammlung und den Gerichten , die mit durch Los bestimmten Laienrichtern besetzt waren .
+Es gab zahlreiche Rhetoriklehrer , und Rhetorikhandbücher kamen auf .
+Aristoteles ’ dialektische Rhetorik ist eine Reaktion auf die Rhetoriktheorie seiner Zeit , die – wie er kritisiert – bloße Versatzstücke für Redesituationen bereitstellt und Anweisungen , wie man durch Verleumdung und die Erregung von Emotionen das Urteil der Richter trüben kann .
+Im Gegensatz dazu beruht seine dialektische Rhetorik auf der Auffassung , dass wir dann am meisten überzeugt sind , wenn wir meinen , dass etwas bewiesen worden ist ( Rhet .
+I 1 , 1355a5 f. ) . Dass die Rhetorik sachorientiert sei und das jeweils in der Sache liegende Überzeugungspotential entdecken und ausschöpfen müsse , drückt er ebenfalls in der Gewichtung der drei Überzeugungsmittel aus .
+Diese sind : der Charakter des Redners ( Ethos ) der emotionale Zustand des Hörers ( Pathos ) das Argument ( Logos ) Das Argument hält er für das wichtigste Mittel .
+Unter den Argumenten unterscheidet Aristoteles das Beispiel – eine Form der Induktion – und das Enthymem – eine rhetorische Deduktion ( wobei wiederum das Enthymem wichtiger als das Beispiel ist ) . Das Entyhmem ist eine Art der dialektischen Deduktion .
+Sein besonderes Merkmal aufgrund der rhetorischen Situation ist , dass seine Prämissen nur die anerkannten Meinungen sind , die von allen oder den meisten für wahr gehalten werden .
+( Die verbreitete , kuriose Ansicht , das Enthymem sei ein Syllogismus , in dem eine der zwei Prämissen fehle , vertritt Aristoteles nicht ; sie basiert auf einem schon in der antiken Kommentierung belegten Missverständnis von 1357a7 ff. ) Der Redner überzeugt demnach die Zuhörer , indem er eine Behauptung ( als Konklusion ) aus den Überzeugungen ( als Prämissen ) der Zuhörer herleitet .
+Die Konstruktionsanleitungen dieser Enthymeme liefern rhetorische Topen , z. B. : An den zeitgenössischen Rhetoriklehrern kritisiert Aristoteles , dass sie die Argumentation vernachlässigten und ausschließlich auf Emotionserregung abzielten , etwa durch Verhaltensweisen wie Jammern oder Mitbringen der Familie zur Gerichtsverhandlung , wodurch ein sachbezogenes Urteil der Richter verhindert werde .
+Aristoteles ’ Theorie zufolge können alle Emotionen definiert werden , indem drei Faktoren berücksichtigt werden .
+Man fragt : ( 1 ) Worüber , ( 2 ) wem gegenüber und ( 3 ) in welchem Zustand empfindet jemand die jeweilige Emotion ?
+So lautet die Definition von Zorn : Wenn der Redner mit diesem Definitionswissen den Zuhörern deutlich machen kann , dass der entsprechende Sachverhalt vorliegt und sie sich im entsprechenden Zustand befinden , empfinden sie die entsprechende Emotion .
+Sofern der Redner mit dieser Methode bestehende Sachverhalte eines Falles hervorhebt , lenkt er damit nicht – wie bei den kritisierten Vorgängern – von der Sache ab , sondern fördert nur dem Fall angemessene Emotionen und verhindert somit unangemessene .
+Schließlich soll der Charakter des Redners aufgrund seiner Rede für die Zuhörer glaubwürdig , das heißt tugendhaft , klug und wohlwollend erscheinen ( Rhet .
+I 2 , 1356a5–11 ; II 1 , 1378a6–16 ) Die sprachliche Form dient ebenfalls einer argumentativ-sachorientierten Rhetorik .
+Aristoteles definiert nämlich die optimale Form ( aretê ) dadurch , dass sie primär klar , dabei aber weder banal noch zu erhaben ist ( Rhet .
+III 2 , 1404b1–4 ) .
+Durch solche Ausgewogenheit fördert sie das Interesse , die Aufmerksamkeit und das Verständnis und wirkt angenehm .
+Unter den Stilmitteln erfüllt insbesondere die Metapher diese Bedingungen .
+Syllogistische Logik Besteht Aristoteles ’ dialektische Logik in einer Methode des konsistenten Argumentierens , so besteht seine syllogistische in einer Theorie des Beweisens selbst .
+In der von ihm begründeten Syllogistik zeigt Aristoteles , welche Schlüsse gültig sind .
+Hierfür verwendet er eine Form , die in der Tradition wegen der Bedeutung dieser Logik schlicht Syllogismus ( die lateinische Übersetzung von syllogismos ) genannt wird .
+Jeder Syllogismus ist eine ( besondere Form der ) Deduktion ( syllogismos ) , aber nicht jede Deduktion ist ein Syllogismus ( und zwar weil Aristoteles ’ sehr allgemeine Definition der Deduktion viele mögliche Argumenttypen beschreibt ) .
+Aristoteles verwendet selbst auch keinen eigenen Begriff , um den Syllogismus von anderen Deduktionen abzugrenzen .
+Ein Syllogismus ist eine spezielle Deduktion , die aus genau zwei Prämissen und einer Konklusion besteht .
+Prämissen und Konklusion weisen zusammen genau drei verschiedene Begriffe , Terme ( in der Tabelle dargestellt durch A , B , C ) auf .
+Die Prämissen haben genau einen Term gemeinsam ( in der Tabelle B) , der in der Konklusion nicht vorkommt .
+Durch die Stellung des gemeinsamen Terms , des Mittelterms ( hier immer B) unterscheidet Aristoteles folgende syllogistische Figuren : Ein Prädikat ( P ) ( z. B. ' sterblich ' ) kann einem Subjekt ( S ) ( z. B. ' Grieche ' ) entweder zu- oder abgesprochen werden .
+Dies kann in partikulärer oder in allgemeiner Form geschehen .
+Somit gibt es vier Formen , in denen S und P miteinander verbunden werden können , wie die folgende Tabelle zeigt ( nach De interpretatione 7 ; die Vokale werden seit dem Mittelalter für den jeweiligen Aussagetypus und auch in der Syllogistik verwendet ) .
+Der Syllogismus verwendet genau diese vier Aussagetypen in folgender Form : Aristoteles untersucht folgende Frage : Welche der 192 möglichen Kombinationen sind logisch gültige Deduktionen ?
+Bei welchen Syllogismen ist es nicht möglich , dass , wenn die Prämissen wahr sind , die Konklusion falsch ist ?
+Er unterscheidet vollkommene Syllogismen , die unmittelbar einsichtig sind , von unvollkommenen .
+Die unvollkommenen Syllogismen führt er mittels Konversionsregeln auf die vollkommenen zurück ( dieses Verfahren nennt er analysis ) oder beweist sie indirekt . Ein vollkommener Syllogismus ist der – seit dem Mittelalter so genannte – Barbara :
+Weitere gültige Syllogismen und deren Beweise finden sich im Artikel Syllogismus .
+Die in den Analytica Priora ausgearbeitete Syllogistik wendet Aristoteles in seiner Wissenschaftstheorie , den Analytica Posteriora an .
+Aristoteles entwickelt zudem eine modale Syllogistik , die die Begriffe möglich und notwendig einschließt .
+Diese Modalsyllogistik ist sehr viel schwieriger zu interpretieren als die einfache Syllogistik .
+Ob eine konsistente Interpretation dieser modalen Syllogistik überhaupt möglich ist , ist noch heute umstritten .
+Interpretatorisch problematisch , aber auch bedeutend ist Aristoteles ’ Definition von möglich . Er unterscheidet hierbei die sogenannte einseitige und die zweiseitige Möglichkeit : Einseitig : p ist möglich , insofern nicht-p nicht notwendig ist .
+Zweiseitig : p ist möglich , wenn p nicht notwendig und nicht-p nicht notwendig ist , das heißt p ist kontingent .
+Damit lässt sich der Indeterminismus , den Aristoteles vertritt , als der Zustand charakterisieren , der kontingent ist .
+Kanonische Sätze In der aristotelischen Logik wird zwischen folgenden konträren und kontradiktorischen Satzarten unterschieden : Diese „ kanonischen Sätze “ gehören zum Fundament der traditionellen Logik und werden unter anderem bei einfacher bzw. eingeschränkter Konversion angewandt .
+Wissen und Wissenschaft Stufen des Wissens Aristoteles unterscheidet verschiedene Stufen des Wissens , die sich folgendermaßen darstellen lassen ( Met. I 1 ; An .
+post.
+II 19 ) : Mit dieser Stufung beschreibt Aristoteles auch , wie Wissen entsteht : Aus Wahrnehmung entsteht Erinnerung und aus Erinnerung durch Bündelung von Erinnerungsinhalten Erfahrung .
+Erfahrung besteht in einer Kenntnis einer Mehrzahl konkreter Einzelfälle und gibt nur das Dass an , ist bloße Faktenkenntnis .
+Wissen hingegen ( oder Wissenschaft ; epistêmê umfasst beides ) unterscheidet sich von Erfahrung dadurch , dass es
+allgemein ist ; nicht nur das Dass eines Sachverhalts , sondern auch das Warum , den Grund oder die erklärende Ursache angibt .
+In diesem Erkenntnisprozess schreiten wir nach Aristoteles von dem , was für uns bekannter und näher an der sinnlichen Wahrnehmung ist , zu dem vor , was an sich oder von Natur aus bekannter ist , zu den Prinzipien und Ursachen der Dinge .
+Dass Wissen an oberster Stelle steht und überlegen ist , bedeutet aber nicht , dass es im konkreten Fall die anderen Stufen in dem Sinne enthält , dass es sie ersetzte .
+Im Handeln ist zudem die Erfahrung als Wissen vom Einzelnen den Wissensformen , die aufs Allgemeine gehen , mitunter überlegen ( Met. 981a12–25 ) .
+Ursachen und Demonstrationen Unter einer Ursache ( aitia ) versteht Aristoteles in der Regel nicht ein von einem verursachten Ereignis B verschiedenes Ereignis A. Die Untersuchung von Ursachen dient nicht dazu , Wirkungen vorherzusagen , sondern Sachverhalte zu erklären .
+Eine aristotelische Ursache gibt einen Grund als Antwort auf bestimmte Warum-Fragen an .
+( Aristoteles unterscheidet vier Ursachentypen , die genauer hier im Abschnitt Naturphilosophie behandelt werden . ) Nach Aristoteles hat Ursachenwissen die Form einer bestimmten Deduktion : der Demonstration ( apodeixis ) eines Syllogismus mit wahren Prämissen , die Ursachen für den in der Konklusion ausgedrückten Sachverhalt angeben .
+Ein Beispiel : Aristoteles spricht davon , dass die Prämissen einiger Demonstrationen Prinzipien ( archē ; wörtl .
+Anfang , Ursprung ) sind , erste wahre Sätze , die selbst nicht demonstrativ bewiesen werden können .
+Nicht-Beweisbare Sätze Neben den Prinzipien können auch die Existenz und die Eigenschaften der behandelten Gegenstände einer Wissenschaft sowie bestimmte , allen Wissenschaften gemeinsame Axiome nach Aristoteles nicht durch Demonstrationen bewiesen werden , wie beispielsweise der Satz vom Widerspruch . Vom Satz des Widerspruchs zeigt Aristoteles , dass er nicht geleugnet werden kann .
+Er lautet : X kann Y nicht zugleich in derselben Hinsicht zukommen und nicht zukommen ( Met. IV 3 , 1005b19 f. ) . Aristoteles argumentiert , dass , wer dies leugnet , etwas und somit etwas Bestimmtes sagen muss .
+Wenn er z. B.
+‚ Mensch ‘ sagt , bezeichnet er damit Menschen und nicht Nicht-Menschen .
+Mit dieser Festlegung auf etwas Bestimmtes setze er aber den Satz vom Widerspruch voraus .
+Dies gelte sogar für Handlungen , insofern eine Person etwa um einen Brunnen herumgeht und nicht in ihn hinein fällt .
+Dass diese Sätze und auch Prinzipien nicht demonstriert werden können , liegt an Aristoteles ’ Lösung eines Begründungsproblems : Wenn Wissen Rechtfertigung enthält , dann führt dies in einem konkreten Fall von Wissen entweder ( a ) zu einem Regress , ( b ) einem Zirkel oder ( c ) zu fundamentalen Sätzen , die nicht begründet werden können .
+Prinzipien in einer aristotelischen demonstrativen Wissenschaft sind solche Sätze , die nicht demonstriert , sondern auf andere Weise gewusst werden ( An .
+Post .
+I 3 ) .
+Das Verhältnis von Definition , Ursache und Demonstration Aristoteles spricht zudem davon , dass , sofern die Prämissen Prinzipien sind , sie auch Definitionen darstellen können .
+Wie sich Demonstration , Ursache und Definition zueinander verhalten , illustriert folgendes Beispiel : Der Mond weist zum Zeitpunkt t eine Finsternis auf , weil ( i ) immer , wenn etwas im Sonnenschatten der Erde ist , es eine Finsternis aufweist und ( ii ) der Mond zum Zeitpunkt t im Sonnenschatten der Erde liegt . Demonstration :
+Mittelterm : Verdecken der Sonne durch die Erde . Ursache : Verdecken der Sonne durch die Erde kommt dem Mond zum Zeitpunkt t zu .
+Die Definition wäre hier etwa : Mondfinsternis ist der Fall , in dem die Erde die Sonne verdeckt . Sie erklärt nicht das Wort ‚ Mondfinsternis ‘ . Vielmehr gibt sie an , was eine Mondfinsternis ist .
+Indem man die Ursache angibt , schreitet man von einem Faktum zu seinem Grund fort .
+Das Verfahren der Analyse besteht darin , bottom-up zu einem bekannten Sachverhalt die nächste Ursache zu suchen , bis eine letzte Ursache erreicht ist .
+Status der Prinzipien und Funktion der Demonstration Das aristotelische Wissenschaftsmodell wurde in der Neuzeit und bis ins 20. Jahrhundert als ein Top-down-Beweisverfahren verstanden .
+Die unbeweisbaren Prinzipien seien notwendig wahr und würden durch Induktion und Intuition ( nous ) erlangt .
+Alle Sätze einer Wissenschaft würden – in einer axiomatischen Struktur – aus ihren Prinzipien folgen .
+Wissenschaft beruht demnach auf zwei Schritten : Zunächst würden die Prinzipien intuitiv erfasst , dann würde top-down aus ihnen Wissen demonstriert .
+Gegner dieser Top-down-Interpretation stellen vor allem infrage , dass für Aristoteles die Prinzipien immer wahr sind ; die Prinzipien durch Intuition gewonnen werden ; die Funktion der Demonstration darin besteht , dass aus obersten Prinzipien Wissen erschlossen wird .
+Eine Interpretationsrichtung behauptet , die Demonstration habe didaktische Funktion .
+Da Aristoteles in den naturwissenschaftlichen Schriften seine Wissenschaftstheorie nicht befolge , lege diese nicht dar , wie Forschung durchgeführt , sondern wie sie didaktisch präsentiert werden soll .
+Eine andere Auslegung weist auch die didaktische Interpretation zurück , da sich sehr wohl Anwendungen des wissenschaftstheoretischen Modells in den naturwissenschaftlichen Schriften finden ließen .
+Vor allem aber kritisiert sie die erste Lesart dahingehend , dass sie nicht zwischen Wissensideal und Wissenskultur unterscheide ; denn Aristoteles halte Prinzipien für fallibel und die Funktion der Demonstration für heuristisch .
+Sie liest die Demonstration bottom-up : Zu bekannten Sachverhalten würden mithilfe der Demonstration deren Ursachen gesucht .
+Die wissenschaftliche Forschung gehe von den für uns bekannteren empirischen ( meist universalen ) Sätzen aus .
+Zu einer solchen Konklusion werden Prämissen gesucht , die für den entsprechenden Sachverhalt Ursachen angeben .
+Der wissenschaftliche Forschungsprozess besteht nun darin , beispielsweise die Verknüpfung von Schwere und Statue oder Mond und Finsternis in der Weise genauer zu analysieren , dass man Mittelterme sucht , die sie als Ursachen miteinander verknüpfen .
+Im einfachsten Fall gibt es dabei nur einen Mittelterm , in anderen mehrere .
+Top-down wird dann das Wissen von den erklärenden Prämissen zu den erklärten universalen empirischen Sätzen präsentiert .
+Dabei geben die Prämissen den Grund für den in der Konklusion beschriebenen Sachverhalt an .
+Das Ziel jeder Disziplin besteht in einer derartigen demonstrativen Darstellung des Wissens , in der die nicht demonstrierbaren Prinzipien dieser Wissenschaft Prämissen sind .
+Erfassen der Prinzipien Wie die Prinzipien nach Aristoteles erfasst werden , bleibt undeutlich und ist umstritten .
+Vermutlich werden sie durch Allgemeinbegriffe gebildet , die durch einen induktiven Vorgang entstehen , einen Aufstieg innerhalb der oben beschriebenen Wissensstufen : Wahrnehmung wird Erinnerung , wiederholte Wahrnehmung verdichtet sich zu Erfahrung , und aus Erfahrung bilden wir Allgemeinbegriffe .
+Mit dieser auf der Wahrnehmung basierenden Konzeption der Bildung von Allgemeinbegriffen weist Aristoteles sowohl Konzeptionen zurück , die die Allgemeinbegriffe aus einem höheren Wissen ableiten , als auch diejenigen , die behaupten , Allgemeinbegriffe seien angeboren .
+Vermutlich auf Grundlage dieser Allgemeinbegriffe werden die Prinzipien , Definitionen gebildet .
+Die Dialektik , die Fragen in der Form ‚ Trifft P auf S zu oder nicht ? ‘ behandelt , ist vermutlich ein Mittel , Prinzipien zu prüfen .
+Das Vermögen , das diese grundlegenden Allgemeinbegriffe und Definitionen erfasst , ist der Geist , die Einsicht ( nous ) .
+Naturphilosophie Datei : Four elements representation.svg
+Natur In Aristoteles ’ Naturphilosophie bedeutet Natur ( physis ) zweierlei : Zum einen besteht der primäre Gegenstandsbereich aus den von Natur aus bestehenden Dingen ( Menschen , Tiere , Pflanzen , die Elemente ) , die sich von Artefakten unterscheiden .
+Zum anderen bilden die Bewegung ( kínēsis ) und Ruhe ( stasis ) den Ursprung , beziehungsweise das Grundprinzip ( archē ) aller Natur ( Phys. II 1 , 192b14 ) .
+Bewegung bedeutet wiederum Veränderung ( metabolē ) ( Phys. II 1,193a30 ) .
+So ist beispielsweise die Ortsbewegung eine Form der Veränderung .
+Ebenso stellen die „ Eigenbewegungen “ des Körpers , wenn dieser ( zum Beispiel durch Nahrungsaufnahme ) wächst oder abnimmt , eine Veränderung dar .
+Beide Begriffe , kínēsis und metabolē , sind für Aristoteles folglich nicht trennbar .
+Gemeinsam bilden sie das Grundprinzip und den Anfang aller Naturdinge .
+Bei Artefakten kommt das Prinzip jeder Veränderung von außen ( Phys. II 1 , 192b8–22 ) .
+Die Wissenschaft der Natur hängt in der Folge von den Arten der Veränderung ab .
+Definition , Prinzipien und Arten der Veränderung Ein Veränderungsprozess von X ist gegeben , wenn X , das ( i ) der Wirklichkeit nach die Eigenschaft F und ( ii ) der Möglichkeit nach G aufweist , die Eigenschaft G verwirklicht .
+Bei Bronze ( X) , die der Wirklichkeit nach ein Klumpen ist ( F ) und der Möglichkeit nach eine Statue ( G ) , liegt Veränderung dann vor , wenn die Bronze der Wirklichkeit nach die Form einer Statue ( G ) wird ; der Prozess ist abgeschlossen , wenn die Bronze diese Form besitzt . Oder wenn der ungebildete Sokrates gebildet wird , so verwirklicht sich ein Zustand , welcher der Möglichkeit nach schon vorlag .
+Der Veränderungsprozess ist also durch seinen Übergangsstatus gekennzeichnet und setzt voraus , dass etwas , das der Möglichkeit nach vorliegt , verwirklicht werden kann ( Phys. III 1 , 201a10–201b5 ) .
+Für alle Veränderungsprozesse hält Aristoteles ( in Übereinstimmung mit seinen naturphilosophischen Vorgängern ) Gegensätze für grundlegend .
+Er vertritt darüber hinaus die These , dass in einem Veränderungsprozess diese Gegensätze ( wie gebildet-ungebildet ) immer an einem Substrat oder Zugrundeliegenden ( hypokeimenon ) auftreten , so dass sein Modell folgende drei Prinzipien aufweist : Substrat der Veränderung ( X) ; Ausgangszustand der Veränderung ( F ) ; Zielzustand der Veränderung ( G ) .
+Wird der ungebildete Sokrates gebildet , so ist er dabei an jedem Punkt der Veränderung Sokrates .
+Entsprechend bleibt die Bronze Bronze .
+Das Substrat der Veränderung , an dem diese sich vollzieht , bleibt dabei mit sich selbst identisch .
+Den Ausgangszustand der Veränderung fasst Aristoteles dabei als einen Zustand , dem die entsprechende Eigenschaft des Zielzustands ermangelt ( Privation ; Phys. I 7 ) .
+Aristoteles unterscheidet vier Arten der Veränderung : Qualitative Veränderung Quantitative Veränderung Ortsbewegung Entstehen / Vergehen .
+Bei jeder Veränderung – so Aristoteles – gibt es ein zugrunde liegendes , numerisch identisches Substrat ( Physik I 7 , 191a13–15 ) .
+Im Falle qualitativer , quantitativer und örtlicher Veränderung ist dies ein konkretes Einzelding , das seine Eigenschaften , seine Größe oder seine Position verändert .
+Wie verhält sich dies aber beim Entstehen / Vergehen konkreter Einzeldinge ?
+Die Eleaten hatten die einflussreiche These vertreten , Entstehen sei nicht möglich , da sie es für widersprüchlich hielten , wenn Seiendes aus Nicht-Seiendem hervorginge ( bei Entstehen aus Seiendem sahen sie ein ähnliches Problem ) .
+Die Lösung der Atomisten , Entstehen sei ein Prozess , in dem durch Mischung und Trennung unvergänglicher und unveränderlicher Atome aus alten neue Einzeldinge hervorgehen , führt nach Aristoteles ’ Ansicht Entstehen illegitimerweise auf qualitative Veränderung zurück ( Gen.
+Corr.
+317a20 ff. ) .
+Form und Materie bei Entstehen / Vergehen Aristoteles ’ Analyse von Entstehen / Vergehen basiert auf der innovativen Unterscheidung von Form und Materie ( Hylemorphismus ) .
+Er akzeptiert , dass kein konkretes Einzelding aus Nichtseiendem entstehe , analysiert den Fall Entstehen jedoch folgendermaßen .
+Ein konkretes Einzelding des Typs F entsteht nicht aus einem nicht-seienden F , sondern aus einem zugrunde liegenden Substrat , das nicht die Form F aufweist : der Materie .
+Ein Ding entsteht , indem Materie eine neu hinzukommende Form annimmt .
+So entsteht eine Bronzestatue , indem eine Bronzemasse eine entsprechende Form annimmt .
+Die fertige Statue besteht aus Bronze , die Bronze liegt der Statue als Materie zugrunde .
+Die Antwort auf die Eleaten lautet , dass einer nicht-seienden Statue die Bronze als Materie entspricht , die durch Hinzukommen einer Form zur Statue wird .
+Der Entstehungsprozess ist dabei von verschiedenen Seinsgraden gekennzeichnet .
+Die tatsächliche , aktuale , geformte Statue entsteht aus etwas , das potentiell eine Statue ist , nämlich Bronze als Materie ( Phys. I 8 , 191b10–34 ) .
+Materie und Form sind Aspekte eines konkreten Einzeldings und treten nicht selbständig auf . Materie ist immer Stoff eines bestimmten Dings , das schon eine Form aufweist .
+Sie ist ein relativer Abstraktionsbegriff zu Form. Indem eine derartige Materie in einer neuen Weise strukturiert wird , entsteht ein neues Einzelding .
+Ein Haus setzt sich aus Form ( dem Bauplan ) und Materie ( Holz und Ziegel ) zusammen .
+Die Ziegel als Materie des Hauses sind durch einen bestimmten Prozess auf eine bestimmte Weise geformter , konfigurierter Lehm . Unter Form versteht Aristoteles seltener die äußere Gestalt ( dies nur bei Artefakten ) , in der Regel die innere Struktur oder Natur , dasjenige , was durch eine Definition erfasst wird .
+Die Form eines Gegenstandes eines bestimmten Typs beschreibt dabei Voraussetzungen , welche Materie für diesen geeignet ist und welche nicht .
+Ortsbewegung Bewegungen erfolgen nach Aristoteles entweder naturgemäß oder naturwidrig ( gewaltsam ) .
+Nur Lebewesen bewegen sich aus eigenem Antrieb , alles andere wird entweder von etwas bewegt oder es strebt möglichst geradlinig seinem natürlichen Ort entgegen und kommt dort zum Stillstand .
+Der natürliche Ort eines Körpers hängt von der in ihm vorherrschenden Materieart ab .
+Wenn Wasser oder Erde vorherrscht , bewegt sich der Körper zum Mittelpunkt der Erde , dem Zentrum der Welt , wenn Feuer oder Luft dominiert , strebt er nach oben .
+Erde ist ausschließlich schwer , Feuer absolut leicht , Wasser relativ schwer , Luft relativ leicht .
+Der natürliche Ort des Feuers ist oberhalb der Luft und unterhalb der Mondsphäre .
+Leichtigkeit und Schwere sind Eigenschaften von Körpern , die mit deren Dichte nichts zu tun haben .
+Mit der Einführung der Vorstellung einer absoluten Schwere und absoluten Leichtigkeit ( Schwerelosigkeit des Feuers ) verwirft Aristoteles die Auffassung Platons und der Atomisten , die alle Objekte für schwer hielten und das Gewicht als relative Größe auffassten .
+Das fünfte Element , der Äther des Himmels , ist masselos und bewegt sich ewig in gleichförmiger Kreisbewegung um das Zentrum der Welt .
+Der Äther füllt den Raum oberhalb der Mondsphäre ; er ist keinerlei Veränderung außer der Ortsbewegung unterworfen .
+Die Annahme , auf der Erde und am Himmel gälten verschiedene Gesetze , ist für Aristoteles nötig , weil die Bewegung der Planeten und Fixsterne nicht zur Ruhe kommt .
+Aristoteles nimmt an , dass für jede Ortsbewegung ein Medium , das entweder als bewegende Kraft wirkt oder der Bewegung Widerstand leistet , erforderlich ist ; eine kontinuierliche Bewegung im Vakuum ist prinzipiell unmöglich .
+Aristoteles schließt sogar die Existenz eines Vakuums aus .
+Die Bewegungslehre des Aristoteles war bis zur Entwicklung eines neuen Trägheitsbegriffs durch Galilei und Newton einflussreich .
+Ursachen Um Wissen von Veränderungsprozessen und somit von der Natur zu besitzen , muss man – so Aristoteles – die entsprechenden Ursachen ( aitiai ) kennen ( Phys. I 1 , 184a10–14 ) .
+Aristoteles behauptet , es gebe genau vier Ursachentypen , die jeweils auf verschiedene Weise auf die Frage Warum antworten und die in der Regel bei einer vollständigen Erklärung alle angegeben werden müssen ( Phys. II 3 , 194b23–35 ) : Der aristotelische Ursachenbegriff unterscheidet sich weitgehend vom modernen .
+In der Regel treffen zur Erklärung desselben Sachverhaltes oder Gegenstandes verschiedene Ursachen zugleich zu .
+Die Formursache fällt oft mit der Bewegungsursache und der Finalursache zusammen .
+Die Ursache eines Hauses sind so Ziegel und Holz , der Bauplan , der Architekt und der Schutz vor Unwetter .
+Letztere drei fallen oft zusammen , insofern beispielsweise der Zweck Schutz vor Unwetter den Bauplan ( im Geist ) des Architekten bestimmt .
+Die Finalursache ist vom Standpunkt der neuzeitlichen mechanistischen Physik aus kritisiert worden .
+Von einer insgesamt teleologisch ausgerichteten Natur wie bei Platon setzt sich Aristoteles jedoch weitgehend ab .
+Finale Ursachen treten für ihn in der Natur vor allem in der Biologie auf , und zwar beim funktionellen Aufbau von Lebewesen und der Artenreproduktion .
+Metaphysik Metaphysik als Erste Philosophie
+Aristoteles gebraucht den Ausdruck „ Metaphysik “ nicht .
+Gleichwohl trägt eines seiner wichtigsten Werke traditionell diesen Titel .
+Die Metaphysik ist eine von einem späteren Herausgeber zusammengestellte Sammlung von Einzeluntersuchungen , die ein mehr oder weniger zusammenhängendes Themenspektrum abdecken , indem sie nach den Prinzipien und Ursachen des Seienden und nach der dafür zuständigen Wissenschaft fragen .
+Ob der Titel ( ta meta ta physika : die nach der Physik ) einen bloß bibliografischen oder einen sachbezogenen Hintergrund hat , ist unklar .
+Aristoteles spricht in der Metaphysik von einer allen anderen Wissenschaften vorgeordneten Wissenschaft , die er Erste Philosophie , Weisheit ( sophia ) oder auch Theologie nennt .
+Diese Erste Philosophie wird in dieser Sammlung aus Einzeluntersuchungen auf drei Weisen charakterisiert : als Wissenschaft der allgemeinsten Prinzipien , die für Aristoteles ’ Wissenschaftstheorie zentral sind ( → Satz vom Widerspruch ) als Wissenschaft vom Seienden als Seienden , die aristotelische Ontologie
+als Wissenschaft vom Göttlichen , die aristotelische Theologie ( → Theologie ) Ob oder inwieweit diese drei Projekte zusammenhängende Aspekte derselben Wissenschaft oder voneinander unabhängige Einzelprojekte sind , ist kontrovers .
+Aristoteles behandelt später metaphysisch genannte Themen auch in anderen Schriften .
+Ontologie Im Corpus Aristotelicum finden sich in zwei Werken , den frühen Kategorien und der späten Metaphysik , unterschiedliche Theorien des Seienden .
+Substanzen in den Kategorien
+Die Kategorien , die die erste Schrift im Organon bilden , sind vermutlich das einflussreichste Werk des Aristoteles und der Philosophiegeschichte überhaupt .
+Die frühe Ontologie der Kategorien befasst sich mit den Fragen ‚ Was ist das eigentlich Seiende ? ‘ und ‚ Wie ist das Seiende geordnet ? ‘ und ist als Kritik an der Position Platons zu verstehen .
+Der mutmaßliche Gedankengang lässt sich folgendermaßen skizzieren .
+Unterschieden werden Eigenschaften , die Einzeldingen zukommen ( P kommt S zu ) .
+Dafür liegen zwei Deutungsmöglichkeiten nahe : Das eigentlich Seiende , die Substanz ( ousia ) sind abstrakte , unabhängig existierende Urbilder als Ursache und Erkenntnisgegenstand von Eigenschaften .
+konkrete Einzeldinge als Träger von Eigenschaften .
+Aristoteles selbst berichtet ( Met. I 6 ) , Platon habe gelehrt , man müsse von den wahrnehmbaren Einzeldingen getrennte , nicht sinnlich wahrnehmbare , unveränderliche , ewige Urbilder unterscheiden .
+Platon nahm an , dass es Definitionen ( und damit aus seiner Sicht auch Wissen ) von den Einzeldingen , die sich beständig ändern , nicht geben kann .
+Gegenstand der Definition und des Wissens sind für ihn die Urbilder ( Ideen ) als das für die Ordnungsstruktur des Seienden Ursächliche .
+Verdeutlichen lässt sich dies an einer von allen Menschen getrennten , einzelnen und numerisch identischen Idee des Menschen , die für das jeweilige Menschsein ursächlich ist und die Erkenntnisgegenstand ist für die Frage ‚ Was ist ein Mensch ? ‘ .
+Aristoteles ’ Einteilung des Seienden in den Kategorien scheint sich von der skizzierten Position Platons abzugrenzen .
+Er orientiert sich dabei an der sprachlichen Struktur einfacher Sätze der Form ‚ S ist P ‘ und der sprachlichen Praxis , wobei er die sprachliche und die ontologische Ebene nicht explizit voneinander scheidet .
+Einige Ausdrücke – wie ‚ Sokrates ‘ – können nur die Subjektposition S in dieser sprachlichen Struktur einnehmen , alles andere wird von ihnen prädiziert .
+Die Dinge , die in diese Kategorie der Substanz fallen und die er Erste Substanz nennt , sind ontologisch selbständig ; sie bedürfen keines anderen Dinges , um zu existieren .
+Daher sind sie ontologisch primär , denn alles andere ist von ihnen abhängig und nichts würde ohne sie existieren .
+Diese abhängigen Eigenschaften bedürfen eines Einzeldings , einer ersten Substanz als eines Trägers , an der sie vorkommen .
+Derartige Eigenschaften ( z. B.
+weiß , sitzend ) können einem Einzelding ( etwa Sokrates ) jeweils zukommen oder auch nicht zukommen und sind daher akzidentelle Eigenschaften .
+Dies betrifft alles außerhalb der Kategorie der Substanz .
+Für einige Eigenschaften ( z. B.
+‚ Mensch ‘ ) gilt nun , dass sie in der Weise von einem Einzelding ( z. B.
+Sokrates ) ausgesagt werden können , dass ihre Definition ( vernünftiges Lebewesen ) auch von diesem Einzelding gilt .
+Sie kommen ihm daher notwendig zu .
+Dies sind die Art und die Gattung .
+Aufgrund dieses engen Bezugs , in dem die Art und die Gattung angeben , was eine erste Substanz jeweils ist ( etwa in der Antwort auf die Frage ‚ Was ist Sokrates ? ‘ : ‚ ein Mensch ‘ ) , nennt Aristoteles sie zweite Substanz .
+Dabei hängt auch eine zweite Substanz von einer ersten Substanz ontologisch ab .
+A ) Kategorie der Substanz : 1. Substanz : Merkmal der Selbständigkeit .
+2. Substanz : Merkmal der Erkennbarkeit .
+B) Nichtsubstanziale Kategorien : Akzidenzien .
+Aristoteles vertritt also folgende Thesen : Nur Einzeldinge ( erste Substanzen ) sind selbständig und daher ontologisch primär .
+Alle Eigenschaften hängen von den Einzeldingen ab .
+Es existieren keine unabhängigen , nicht-exemplifizierten Urbilder .
+Neben kontingenten , akzidentellen Eigenschaften ( wie ‚ weiß ‘ ) gibt es notwendige , essentielle Eigenschaften ( wie ‚ Mensch ‘ ) , die angeben , was ein Einzelding jeweils ist .
+Die Substanztheorie der Metaphysik
+Für Platon ergibt sich als Konsequenz aus seiner Auffassung von den Ideen die Annahme , dass im eigentlichen , unabhängigen Sinne allein die unveränderlichen Ideen existieren ; die Einzeldinge existieren nur in Abhängigkeit von den Ideen .
+Diese ontologische Konsequenz kritisiert Aristoteles eingehend in der Metaphysik . Er hält es für widersprüchlich , dass die Anhänger der Ideenlehre einerseits die Ideen dadurch von den Sinnesobjekten abgrenzen , dass sie ihnen das Merkmal der Allgemeinheit und damit Undifferenziertheit zuweisen , und andererseits zugleich für jede einzelne Idee eine separate Existenz annehmen ; dadurch würden die Ideen selbst Einzeldinge , was mit ihrem Definitionsmerkmal Allgemeinheit unvereinbar sei ( Met. XIII 9 , 1086a32–34 ) .
+In der Metaphysik vertritt Aristoteles im Rahmen seines Vorhabens , das Seiende als Seiendes zu untersuchen , die Auffassung , dass alles Seiende entweder eine Substanz ist oder auf eine bezogen ist ( Metaphysik IV 2 ) .
+In den Kategorien hatte er ein Kriterium für Substanzen formuliert und Beispiele ( Sokrates ) für diese gegeben .
+In der Metaphysik thematisiert er nun abermals die Substanz , um nach den Prinzipien und Ursachen einer Substanz , eines konkreten Einzeldings zu suchen .
+Hier fragt er nun : Was macht etwa Sokrates zu einer Substanz ?
+Substanz ist hier also ein zweistelliges Prädikat ( Substanz von X) , so dass man die Frage so formulieren kann : Was ist die Substanz-X einer Substanz ? Dabei spielt die Form-Materie-Unterscheidung , die in den Kategorien nicht präsent ist , eine entscheidende Rolle .
+Aristoteles scheint die Substanz-X vor allem mit Hilfe zweier Kriterien zu suchen , die in der Theorie der Kategorien auf die erste und die zweite Substanz verteilt sind : ( i ) selbständige Existenz oder Subjekt für alles andere , aber nicht selbst Prädikat zu sein ( individuelles Wesen = erste Substanz ) ; ( ii ) Definitionsgegenstand zu sein , Erkennbarkeit zu garantieren , das heißt auf die Frage ‚ Was ist X ? ‘ zu antworten ( allgemeines Wesen = zweite Substanz ) .
+Das Kriterium ( ii ) wird genauer erfüllt , indem Aristoteles das Wesen als Substanz-X bestimmt .
+Mit Wesen meint er dabei , was ontologisch einer Definition entspricht ( Met. VII 4 ; 5 , 1031a12 ; VIII 1 , 1042a17 ) .
+Das Wesen beschreibt die notwendigen Eigenschaften , ohne die ein Einzelding aufhören würde , ein und dieselbe Sache zu sein .
+Fragt man : Was ist die Ursache dafür , dass diese Materieportion Sokrates ist ? , so ist Aristoteles ’ Antwort : Das Wesen von Sokrates , welches weder ein weiterer Bestandteil neben den materiellen Bestandteilen ist ( dann bedürfte es eines weiteren Strukturprinzips , um zu erklären , wie es mit den materiellen Bestandteilen vereint ist ) noch etwas aus materiellen Bestandteilen ( dann müsste man erklären , wie das Wesen selbst zusammengesetzt ist ) .
+Aristoteles ermittelt die Form ( eidos ) eines Einzeldings als sein Wesen und somit als Substanz-X .
+Mit Form meint er weniger die äußere Gestalt als vielmehr die Struktur : Die Form wohnt dem Einzelding inne , bewirkt bei Lebewesen die Entstehung eines Exemplars derselben Art ( Met. VII 8 , 1033b30–2 ) bei Artefakten ( z. B.
+Haus ) als formale Ursache ( Bauplan ) ( Met. VII 9 , 1034a24 ) im Geist des Produzenten ( Met. VII 7 , 1032b23 ) ( Architekt ) die Entstehung des Einzeldings .
+geht der Entstehung eines aus Form und Materie zusammengesetzten Einzeldings voraus und entsteht und verändert sich nicht und bewirkt so ( bei natürlichen Arten ) eine Kontinuität der Formen , die für Aristoteles ewig ist ( Met. VII 8 , 1033b18 ) ist Ursache , Erklärung der wesentlichen Eigenschaften und Fähigkeiten eines Einzeldings ( Beispielsweise ist die Form eines Menschen die Seele ( Met. VII 10 , 1035b15 ) , welche sich aus Fähigkeiten wie Nährvermögen , Wahrnehmungsvermögen , Denkvermögen unter anderem konstituiert ( An . II 2 , 413b11–13 ) ) . Dass die Form als Substanz-X auch das genannte Kriterium ( ii ) , selbständig zu sein , erfüllen muss , und dies teilweise als Kriterium für etwas Individuelles aufgefasst wird , ist einer von vielen Aspekten in folgender zentralen interpretatorischen Kontroverse : Fasst Aristoteles die Form ( A ) als etwas Allgemeines oder ( B) als etwas ( dem jeweiligen Einzelding ) Individuelles auf ?
+Als Problem formuliert : Wie kann die Form , das eidos , zugleich Form eines Einzeldings und Gegenstand des Wissens sein ? Für ( A ) spricht insbesondere , dass Aristoteles an mehreren Stellen davon ausgeht , dass die Substanz-X und somit die Form definierbar ist ( Met. VII 13 ) und dies für ihn ( wie für Platon ) nur auf Allgemeines zutrifft ( VII 11 , 1036a ; VII 15 , 1039b31–1040a2 ) .
+Für ( B) hingegen spricht vor allem , dass Aristoteles kategorisch die unplatonische Position zu vertreten scheint : Kein Allgemeines kann Substanz-X sein ( Met. VII 13 ) .
+Nach ( B) besitzen Sokrates und Kallias zwei auch qualitativ verschiedene Formen .
+Definierbar müssten dann zu separierende , überindividuelle Aspekte dieser beiden Formen sein .
+Die Interpretation ( A ) hingegen löst das Dilemma etwa , indem sie die Aussage Kein Allgemeines ist Substanz-X als Nichts allgemein Prädizierbares ist Substanz-X interpretiert und so entschärft .
+Die Form werde nicht auf herkömmliche Weise ( wie die Art ‚ Mensch ‘ von ‚ Sokrates ‘ in den Kategorien ) prädiziert und sei daher nicht im problematischen Sinne allgemein .
+Vielmehr werde die Form von der unbestimmten Materie in einer Weise ‚ prädiziert ‘ , die einen Einzelgegenstand erst konstituiere .
+Akt und Potenz Die für die Ontologie wichtige Beziehung zwischen Form und Materie wird durch ein weiteres Begriffspaar genauer erläutert : Akt und Potenz Für die Form-Materie-Unterscheidung ist die später ontologisch genannte Bedeutung von Potenz oder Vermögen wichtig . Potentialität ist hier ein Zustand , dem ein anderer Zustand – Aktualität – gegenübersteht , indem ein Gegenstand der Wirklichkeit nach F oder dem Vermögen , der Möglichkeit nach F ist .
+So ist ein Junge der Möglichkeit nach ein Mann , ein ungebildeter Mensch der Möglichkeit nach ein gebildeter ( Met. IX 6 ) .
+Dieses ( hier diachron beschriebene ) Verhältnis von Aktualität und Potentialität bildet die Grundlage für das ( auch synchron zu verstehende ) Verhältnis von Form und Materie , denn Form und Materie sind Aspekte eines Einzeldings , nicht dessen Teile .
+Sie sind im Verhältnis von Aktualität und Potentialität miteinander verbunden und konstituieren so ( erst ) das Einzelding .
+Die Materie eines Einzeldings ist demnach genau das potentiell , was die Form des Einzeldings und das Einzelding selbst aktual sind ( Met. VIII 1 , 1042a27 f. ; VIII 6 , 1045a23–33 ; b17–19 ) .
+Zum einen ist zwar ( diachron betrachtet ) eine bestimmte Portion Bronze potentiell eine Kugel wie auch eine Statue .
+Zum anderen aber ist ( synchron als konstituierender Aspekt ) die Bronze an einer Statue potentiell genau das , was die Statue und deren Form aktual sind .
+Die Bronze der Statue ist ein Konstituens der Statue , ist aber nicht mit ihr identisch .
+Und so sind auch Fleisch und Knochen potentiell das , was Sokrates oder seine Form ( die für einen Menschen typische Konfiguration und Fähigkeiten seiner materiellen Bestandteile , → Psychologie ) aktual sind .
+So wie die Form gegenüber der Materie ist für Aristoteles auch die Aktualität gegenüber der Potentialität primär ( Met. IX 8 , 1049b4–5 ) .
+Unter anderem ist sie der Erkenntnis nach primär .
+Man kann nur dann ein Vermögen angeben , wenn man Bezug auf die Wirklichkeit nimmt , zu der es ein Vermögen ist .
+Das Sehvermögen etwa lässt sich nur bestimmen , indem man auf die Tätigkeit ‚ Sehen ‘ Bezug nimmt ( Met. IX 8 , 1049b12–17 ) .
+Des Weiteren ist die Aktualität im entscheidenden Sinne auch zeitlich früher als die Potentialität , denn ein Mensch entsteht durch einen Menschen , der aktual Mensch ist ( Met. IX 8 , 1049b17–27 ) .
+Theologie Aristoteles unterscheidet im Vorfeld seiner Theologie drei mögliche Substanzen : ( i ) sinnlich wahrnehmbare vergängliche , ( ii ) sinnlich wahrnehmbare ewige und ( iii ) nicht sinnlich wahrnehmbare ewige und unveränderliche ( Met. XII 1 , 1069a30-1069b2 ) .
+( i ) sind die konkreten Einzeldinge ( der sublunaren Sphäre ) , ( ii ) die ewigen , bewegten Himmelskörper , ( iii ) erweist sich als der selbst unbewegte Ursprung aller Bewegung .
+Aristoteles argumentiert für einen göttlichen Beweger , indem er feststellt , dass , wenn alle Substanzen vergänglich wären , alles vergänglich sein müsste , die Zeit und die Veränderung selbst jedoch notwendig unvergänglich sind ( Phys. VIII 1 , 251a8–252b6 ; Met. XII 6 , 1071b6–10 ) .
+Aristoteles zufolge ist die einzige Veränderung , die ewig existieren kann , die Kreisbewegung ( Phys. VIII 8–10 ; Met. XII 6,1071b11 ) .
+Die entsprechende beobachtbare kreisförmige Bewegung der Fixsterne muss daher als Ursache eine ewige und immaterielle Substanz haben ( Met. XII 8 , 1073b17–32 ) .
+Enthielte das Wesen dieser Substanz Potentialität , könnte die Bewegung unterbrochen werden .
+Daher muss sie reine Aktualität , Tätigkeit sein ( Met. XII , 1071b12–22 ) .
+Als letztes Prinzip muss dieser Beweger selbst unbewegt sein .
+Nach Aristoteles bewegt der unbewegte Beweger „ wie ein Geliebtes “ , nämlich als Ziel ( Met. XII 7 , 1072b3 ) , denn das Begehrte , das Gedachte und insbesondere das Geliebte kann bewegen , ohne bewegt zu sein ( Met. XII 7 , 1072a26 ) .
+Seine Tätigkeit ist die lustvollste und schönste .
+Da er immaterielle Vernunft ( nous ) ist und seine Tätigkeit im Denken des besten Gegenstandes besteht , denkt er sich selbst : das „ Denken des Denkens “ ( noêsis noêseôs ) ( Met. XII 9 , 1074b34 f. ) . Da nur Lebendiges denken kann , muss er zudem lebendig sein .
+Den unbewegten Beweger identifiziert Aristoteles mit Gott ( Met. XII 7 , 1072b23 ff. ) .
+Der unbewegte Beweger bewegt die gesamte Natur .
+Die Fixsternsphäre bewegt sich , da sie mit der Kreisbewegung die Vollkommenheit nachahmt .
+Die anderen Himmelskörper werden vermittelt über die Fixsternsphäre bewegt .
+Die Lebewesen haben Anteil an der Ewigkeit , indem sie mittels der Fortpflanzung ewig bestehen ( GA II 1 , 731b31–732a1 ) .
+Biologie Stellung der Biologie
+Nicht nur in der Philosophiegeschichte , sondern auch in der Geschichte der Naturwissenschaften nimmt Aristoteles einen bedeutenden Platz ein .
+Ein großer Teil seiner überlieferten Schriften ist naturwissenschaftlich , von denen die bei weitem bedeutendsten und umfangreichsten die biologischen Schriften sind , die fast ein Drittel des überlieferten Gesamtwerks umfassen .
+Vermutlich in Arbeitsteilung wurde die Botanik von seinem engsten Mitarbeiter Theophrast , die Medizin von seinem Schüler Menon bearbeitet .
+Aristoteles vergleicht das Studium unvergänglicher Substanzen ( Gott und Himmelskörper ) und vergänglicher Substanzen ( der Lebewesen ) .
+Beide Forschungsgebiete haben ihren Reiz .
+Die unvergänglichen Substanzen , die höchsten Erkenntnisgegenstände zu untersuchen , bereiten zwar die größte Freude , aber das Wissen über Lebewesen ist leichter zu erlangen , da sie uns näher stehen .
+Er betont den Wert der Erforschung auch niederer Tiere und weist darauf hin , dass auch diese etwas Natürliches und Schönes zeigen , das sich nicht in ihren zerlegten Bestandteilen erschöpft , sondern erst durch die Tätigkeiten und das Zusammenwirken der Teile hervortritt ( PA I 5 , 645a21–645b1 ) .
+Aristoteles als empirischer Forscher
+Aristoteles hat selbst empirische Forschung betrieben , jedoch vermutlich nicht Experimente im – erst in der neuzeitlichen Naturwissenschaft eingeführten – Sinne einer methodischen Versuchsanordnung angestellt .
+Sicher ist , dass er selbst Sezierungen vornahm .
+Einem Experiment am nächsten kommt die in festgelegten zeitlichen Abständen wiederholte Untersuchung von befruchteten Hühnereiern , mit dem Ziel zu beobachten , in welcher Reihenfolge die Organe entstehen ( GA VI 3 , 561a6–562a20 ) .
+Experimente sind jedoch in seiner eigentlichen Domäne – der deskriptiven Zoologie – auch nicht das wesentliche Instrument der Forschung .
+Neben eigenen Beobachtungen und einigen wenigen Textquellen stützte er sich hier auch auf Informationen von einschlägig Berufstätigen wie Fischern , Bienenzüchtern , Jägern und Hirten .
+Er ließ die Inhalte seiner Textquellen teilweise empirisch überprüfen , übernahm aber auch unkritisch fremde Irrtümer .
+Ein verlorenes Werk bestand vermutlich großenteils aus Zeichnungen und Diagrammen von Tieren .
+Methodologie der Biologie : Trennung von Fakten und Ursachen Aufgrund des lange vorherrschenden Interpretationsmodells der Wissenschaftstheorie des Aristoteles und der Vernachlässigung der biologischen Schriften , ging man früher davon aus , dass er diese Theorie nicht auf die Biologie angewendet hat .
+Demgegenüber wird heute durchaus angenommen , dass seine Vorgehensweise in der Biologie von seiner Wissenschaftstheorie beeinflusst war , wenngleich Umfang und Grad umstritten sind .
+Faktensammlungen
+Von Aristoteles ist keine Beschreibung seines naturwissenschaftlichen Vorgehens überliefert .
+Erhalten sind neben der allgemeinen Wissenschaftstheorie nur Texte , die ein Endprodukt der wissenschaftlichen Forschung darstellen .
+Die biologischen Schriften sind in einer bestimmten Reihenfolge angeordnet , die der Vorgehensweise entspricht .
+Die erste Schrift ( Historia animalium ) beschreibt die verschiedenen Tierarten und ihre spezifischen Differenzen .
+Sie bietet die Sammlung des Faktenmaterials wie z. B. , dass alle Lebewesen mit Lungen Luftröhren aufweisen .
+Dabei wird nicht erörtert , ob etwas notwendig oder unmöglich so sei .
+In der Faktensammlung ordnet Aristoteles die Lebewesen nach verschiedenen Einteilungsmerkmalen wie blutführend , lebendgebärend usw. Nach Merkmalen geordnet stellt er allgemeine Relationen zwischen verschiedenen Aspekten der Beschaffenheit fest .
+So bemerkt er beispielsweise : Alle Vierfüßler , die lebendgebärend sind , weisen Lungen und Luftröhren auf ( HA II 15 , 505b32 f. ) . Erst die an dieses Werk anschließenden und darauf aufbauenden Schriften De generatione animalium ( Über die Entstehung der Tiere ) und De partibus animalium ( Über die Teile der Tiere ) befassen sich mit den Ursachen , welche die Fakten erklären .
+Ursachenwissen
+Die Faktensammlung ist die Voraussetzung dafür , Wissen auf der Grundlage von Ursachenkenntnis zu erreichen .
+Zentral für die Biologie sind dabei finale Ursachen , die den Zweck der Bestandteile des Körpers angeben .
+Die Ursache für die Existenz einer Luftröhre bei allen Lebewesen , die eine Lunge besitzen , besteht für Aristoteles in der Funktionsweise der Lunge .
+Die Lunge kann – anders als der Magen – nicht unmittelbar an den Mund anschließen , da sie eines zweigeteilten Kanals bedarf , so dass Einatmen und Ausatmen auf optimale Weise möglich ist .
+Da dieser Kanal eine gewisse Länge aufweisen muss , haben alle Lebewesen mit Lunge einen Hals .
+Fische haben daher keinen Hals , weil sie keine Luftröhre benötigen , da sie mit Kiemen atmen ( PA III 3 , 664a14–34 ) .
+Finale Ursachen in der Biologie
+Die Verwendung finaler Erklärungen in der Biologie ( und auch anderen Forschungsgebieten des Aristoteles ) ist insbesondere in der Frühen Neuzeit und bis ins 20. Jahrhundert vielfach kritisiert worden .
+Unter finalen Erklärungen oder Ursachen versteht Aristoteles hier allerdings in der Regel keine übergreifenden Zwecke , die etwa eine bestimmte Spezies hätte .
+Ihm geht es vielmehr um eine interne Funktionsbestimmung der Organismen und ihrer Teile .
+Inhalte der Zoologie Aristoteles hat über 500 Spezies untersucht .
+Seine Schriften behandeln systematisch die inneren und äußeren Teile der einzelnen Tiere , Bestandteile wie Blut und Knochen , Arten der Fortpflanzung , die Nahrung , den Lebensraum und das Verhalten .
+Er beschreibt das Verhalten von Haustieren , exotischen Raubtieren wie dem Krokodil , Vögeln , Insekten und Meerestieren .
+Zu diesem Zweck ordnet er die Lebewesen .
+Einteilung der Arten
+Aristoteles unterscheidet zwei Hauptgruppen von Lebewesen : blutführende und blutlose Tiere .
+Dies entspricht der Einteilung in Vertebraten und Invertebraten .
+Diese ordnet er nach größten Gattungen : Blutführende Tiere : lebendgebärende Vierfüßler eierlegende Vierfüßler Vögel Fische Cetaceen ( Meeressäugetiere ) eierlegende Fußlose ( Schlangen ) lebendgebärende Fußlose ( Vipern ) Mensch ( bildet eine isolierte Gattung ) Blutlose Tiere : Weichtiere Krustentiere Schaltiere Kerbtiere
+Vermutlich war es nicht Aristoteles ’ Absicht , eine vollständige Taxonomie zu schaffen .
+Das System einer Taxonomie ist für ihn auch kein Hauptgegenstand .
+Ziel seiner Untersuchungen war eher eine Morphologie , eine Klassifikation der Lebewesen anhand charakteristischer Merkmale .
+So hat er die Gattungen zwischen den genannten sowie Untergattungen nicht terminologisch fixiert .
+Beispiel einer Beschreibung .
+Der Krake
+Aristoteles und die Erkenntnisse der modernen Biologie
+In vielen Fällen hat sich Aristoteles als Biologe geirrt .
+Einige seiner Irrtümer erscheinen reichlich kurios , wie die Beschreibung des Bisons , das sich „ durch Ausschlagen und Ausstoßen seines Kots , welchen es bis siebeneinhalb Meter weit von sich schleudern kann , verteidigt “ ( HA IX 45 , 630b8 f. ) . Offenbar war seine Informationsquelle über dieses exotische Tier nicht sehr verlässlich .
+Weitere bekannte Irrtümer sind unter anderem die Behauptung , der Mann habe mehr Zähne als die Frau ( HA II 3 , 501b19 ) , das Gehirn sei ein Kühlorgan und das Denken geschehe in der Herzgegend ( PA II 7 , 652b21–25 ; III 3 , 514a16–22 ) sowie das Konzept der Telegonie , wonach eine vorangegangene Trächtigkeit den Phänotyp von Nachkommen aus späteren Trächtigkeiten beeinflussen könne .
+Aristoteles hat aber auch auf der Grundlage seiner Beobachtungen Einsichten gewonnen , die nicht nur zutreffen , sondern die erst in der Moderne wiederentdeckt oder bestätigt worden sind .
+Beispielsweise erwähnt er bei der Beschreibung des angeführten Kraken , dass die Paarung durch einen Fangarm des Männchens geschieht , der gegabelt ist – die sogenannte Hektokotylisation – , und beschreibt diesen Fortpflanzungsvorgang ( HA V 5 , 541b9–15 ; V 12 , 544a12 ; GA V 15 , 720b33 ) .
+Dieses Phänomen war bis ins 19. Jahrhundert nur durch Aristoteles bekannt ; die genaue Art der Fortpflanzung wurde erst 1959 vollständig verifiziert .
+Bedeutender noch ist seine Hypothese , nach der die Teile eines Organismus in einer hierarchischen Ordnung ausgebildet werden und nicht – wie die ( bereits von Anaxagoras vertretene ) Präformationslehre annimmt – vorgebildet sind ( GA 734a28–35 ) .
+Diese Auffassung von der embryonalen Entwicklung ist in der Neuzeit unter der von Aristoteles noch nicht verwendeten Bezeichnung Epigenesis bekannt geworden .
+Ihre empirische Grundlage waren für Aristoteles seine Sezierungen .
+In der Neuzeit war aber die Präformationslehre vom 17. bis in das 19. Jahrhundert hinein die allgemein akzeptierte Theorie , und Vertreter der Epigenesis wie William Harvey ( 1651 ) und Caspar Friedrich Wolff ( 1759 ) fanden mit ihren embryologischen Untersuchungen , die klar zeigten , dass die Embryonen sich aus ganz undifferenzierter Materie entwickeln , wenig Beachtung .
+Diese Einsicht setzte sich erst im frühen 19. Jahrhundert durch und verdrängte schließlich die präformistischen Spekulationen .
+Endgültig wurde erst im 20. Jahrhundert in der Experimentalbiologie durch Hans Driesch und Hans Spemann bestätigt , dass die embryonale Entwicklung eine Kette von Neubildungen , ein epigenetischer Prozess ist . Ferner gibt es eine Analogie zwischen der aristotelischen zielhaften Epigenesis und der Genetik .
+Seelenlehre : Theorie des Lebendigseins Ausgangssituation
+Lebewesen unterscheiden sich von anderen natürlichen und künstlichen Objekten dadurch , dass sie lebendig sind .
+Bei Homer ist die Seele ( psychê ) das , was einen Leichnam verlässt .
+Im Laufe des 6. und 5. Jahrhundert v. Chr. findet der Begriff zunehmend eine deutliche Ausweitung : beseelt ( empsychos ) zu sein bedeutet lebendig zu sein und das Konzept Seele weist nun auch kognitive und emotionale Aspekte auf .
+Aristoteles nimmt diesen Sprachgebrauch auf .
+In seiner Seelentheorie ist er mit zwei Positionen konfrontiert : zum einen mit dem Materialismus vorsokratischer Naturphilosophen ( vor allem Demokrit und Empedokles ) , die behaupten , die Seele bestehe aus einer besonderen Art Materie , zum anderen mit der dualistischen Position Platons , für den die Seele unsterblich , immateriell und ihrer Natur nach eher etwas Intelligibles ist .
+Hinsichtlich der Streitfrage zwischen Materialismus und Dualismus , ob Körper und Seele miteinander identisch sind oder nicht , ist Aristoteles der Auffassung , dass die Frage falsch gestellt ist .
+Dies erläutert er mit einem Vergleich : Die Frage Sind Körper und Seele identisch ? ist ebenso unsinnig wie die Frage Sind Wachs und seine Form identisch ? ( An . II 1 , 412b6–9 ) .
+Zustände der Seele sind zwar immer auch Zustände des Körpers , aber eine Identität von Körper und Seele verneint Aristoteles ebenso wie die Unsterblichkeit der Seele .
+Bestimmung der Seele
+Was die Seele ist , bestimmt Aristoteles mittels seiner Unterscheidung von Form und Materie .
+Die Seele verhält sich zum Körper wie die Form zur Materie , das heißt wie eine Statuenform zur Bronze .
+Form und Materie eines Einzeldings sind aber nicht zwei verschiedene Objekte , nicht dessen Teile , sondern Aspekte ebendieses Einzeldings .
+Die Seele definiert Aristoteles als „ erste Wirklichkeit ( entelecheia ) eines natürlichen organischen Körpers “ ( An .
+II 1 , 412b5 f. ) . Eine Wirklichkeit oder Aktualität ist die Seele , weil sie als Form den Aspekt des Lebendigen an der potentiell belebten Materie ( nämlich der organischen ) darstellt .
+Eine erste Wirklichkeit ist sie , insofern das Lebewesen auch dann lebendig ist , wenn es nur schläft und keine weiteren Tätigkeiten ausübt ( die ebenfalls Aspekte des Seelischen sind ) .
+( An .
+II 1 , 412a19–27 ) .
+Fähigkeiten Datei : SeeleAristotelesNE.svg
+Die weiteren seelischen Aspekte sind die Funktionen , die für ein Lebewesen charakteristisch sind , seine spezifischen Fähigkeiten oder Vermögen ( dynamis ) . Aristoteles unterscheidet vor allem folgende Fähigkeiten : Ernährungs- und Fortpflanzungsvermögen ( threptikon )
+Wahrnehmungsvermögen ( aisthêtikon )
+Denkvermögen ( dianoêtikon )
+Ernährungs- und Fortpflanzungsvermögen kommen – als grundlegendes Vermögen alles Lebendigen – auch den Pflanzen zu , Wahrnehmungsvermögen ( und Fortbewegungsfähigkeit ) weisen nur die Tiere ( einschließlich des Menschen ) auf .
+Das Denken besitzt allein der Mensch .
+Wahrnehmungsvermögen
+Aristoteles unterscheidet folgende fünf Sinne und behauptet , dass es nicht mehr geben kann : Tastsinn
+Geschmackssinn
+Riechen
+Hören
+Sehen
+Wahrnehmung ( aisthesis ) fasst Aristoteles allgemein als ein Erleiden oder eine qualitative Veränderung ( An .
+II 5 , 416b33 f. ) . Das , was die Sinne wahrnehmen , ist dabei jeweils durch ein kontinuierliches Gegensatzpaar bestimmt : Sehen durch hell und dunkel , Hören durch hoch und tief , Riechen und Schmecken durch bitter und süß ; Tasten weist verschiedene Gegensatzpaare auf : hart und weich , heiß und kalt , feucht und trocken .
+Aristoteles behauptet , dass beim Wahrnehmungsvorgang das jeweilige Organ wie das Wahrgenommene wird ( An .
+418a3–6 ) .
+Des Weiteren sagt er , dass das Organ die Form „ ohne die Materie “ aufnimmt , so „ wie das Wachs das Siegel des Ringes ohne Eisen und ohne Gold aufnimmt “ ( An .
+II 12 , 424a18 f. ) . Dies ist von manchen Kommentatoren , darunter Thomas von Aquin , so interpretiert worden , dass das Organ keine natürliche Veränderung ( mutatio naturalis ) , sondern eine geistige ( mutatio spiritualis ) erfahre .
+Andere Interpreten meinen , dass „ ohne Materie “ schlicht bedeutet , dass zwar keine Partikel in das Organ gelangen , dieses sich aber tatsächlich dem Wahrnehmungsobjekt entsprechend verändert .
+Den Tastsinn besitzen alle Lebewesen , welche Wahrnehmung besitzen .
+Der Tastsinn ist ein Kontaktsinn , das heißt zwischen Wahrnehmungsorgan und Wahrgenommenem befindet sich kein Medium ( An .
+II 11 , 423a13 f. ) . Der Geschmacksinn ist eine Art Tastsinn ( An .
+II 10 , 422a8 f. ) . Die drei Distanzsinne Riechen , Hören und Sehen hingegen benötigen ein Medium , das den Eindruck vom Wahrgenommenen zum Organ transportiert .
+Vernunft
+Die Vernunft oder das Denkvermögen ( nous ) ist spezifisch für den Menschen .
+Aristoteles definiert sie als „ das , womit die Seele denkt und Annahmen macht “ ( An .
+III 4 , 429a22 f. ) . Die Vernunft ist unkörperlich , da sie anderenfalls in ihren möglichen Denkgegenständen eingeschränkt wäre , was aber nicht der Fall sein darf ( An .
+III 4 , 429a17–22 ) .
+Allerdings ist sie körpergebunden , da sie auf Vorstellungen ( phantasmata ) angewiesen ist .
+Vorstellungen bilden das Material der Denkakte , sie sind konservierte Sinneswahrnehmungen .
+Das entsprechende Vorstellungsvermögen ( phantasia ; weder interpretierend noch produktiv im Sinne von Phantasie ) ist auf Sinneseindrücke angewiesen , wenngleich Sinneseindruck und Vorstellung qualitativ mitunter stark voneinander abweichen können , etwa bei Halluzinationen .
+Das Vorstellungsvermögen ist den Wahrnehmungsvermögen zugeordnet ( An .
+III 8 , 428b10–18 ) .
+Insofern die Vernunft also in ihrer Tätigkeit an Vorstellungen gebunden ist , ist sie auch an einen Körper gebunden .
+Ethik Glück ( eudaimonia ) und Tugend oder Bestzustand ( aretê ) sind die in Aristoteles ’ Ethik zentralen Begriffe .
+Aristoteles vertritt die These , dass das Ziel aller absichtlichen Handlungen das im „ guten Leben “ verwirklichte Glück ist .
+Die Ausbildung von Tugenden ist nach seiner Ansicht wesentlich dafür , dieses Ziel zu erreichen ( → Tugendethik ) .
+Glück als das Ziel des guten Lebens Strebenshierarchie der Güter
+In ihren ( absichtlichen ) Handlungen streben alle Menschen nach etwas , das ihnen gut erscheint .
+Einige dieser erstrebten Güter werden nur als Mittel erstrebt , um andere Güter zu erreichen , andere sind sowohl Mittel als auch selbst ein Gut .
+Da das Streben nicht unendlich sein kann , muss es ein oberstes Gut und letztes Strebensziel geben .
+Dieses wird nur um seiner selbst willen erstrebt .
+Es wird offenbar allgemein „ Glück “ ( eudaimonia ) genannt ( EN I 1 ) .
+Definition des Glücks als des obersten Guts
+Um umrisshaft zu bestimmen , worin das Glück als oberstes Gut für den Menschen besteht , fragt Aristoteles : Worin besteht die spezifische Funktion ( telos ) oder Aufgabe ( ergon ) des Menschen ?
+Sie besteht im Vermögen der Vernunft ( logos ) , das ihn von anderen Lebewesen unterscheidet .
+Der für den Menschen spezifische Seelenteil verfügt über dieses Vermögen der Vernunft ; der andere Seelenteil , der sich aus Emotionen und Begierden zusammensetzt , ist zwar selbst nicht vernünftig , kann sich aber durch die Vernunft leiten lassen .
+Um das Glück zu erlangen , muss das Individuum das Vermögen Vernunft gebrauchen , nicht bloß besitzen , und zwar auf Dauer und in einem Bestzustand ( aretê ) . Demgemäß ist „ das Gut für den Menschen “ , das Glück , eine Tugenden Um den Zustand der Vortrefflichkeit zu erreichen , muss man den beiden Seelenteilen entsprechend ( a ) Verstandestugenden und ( b ) Charaktertugenden ausbilden .
+Tugenden sind für Aristoteles Haltungen , zu denen jeder Mensch die Anlage besitzt , die sich jedoch durch Erziehung und Gewöhnung erst ausbilden müssen .
+Verstandestugenden
+Unter den Verstandestugenden beziehen sich einige auf das Wissen von Unveränderlichem oder die Herstellung von Gegenständen .
+Allein die Klugheit ( phronêsis ) ist mit dem Handeln verknüpft , und zwar als Tugend mit dem Ziel eines guten Lebens .
+Sie ist – neben den Charaktertugenden – notwendig , um in konkreten Entscheidungssituationen im Hinblick auf das gute Leben handeln zu können .
+Im Bereich menschlicher Handlungen gibt es – anders als in den Wissenschaften – keine Beweise , und um klug zu sein , bedarf es dabei auch der Erfahrung .
+Die Funktion der Klugheit besteht darin , die Mitte ( mesotês ) zu wählen .
+Charaktertugenden
+Charaktertugenden sind Haltungen ( hexeis ) , für die kennzeichnend ist , dass man sie loben und tadeln kann .
+Sie werden durch Erziehung und Gewöhnung ausgeprägt , wobei dies nicht als eine Konditionierung zu verstehen ist .
+Zwar hängt von Kindheit an sehr viel von der Gewöhnung ab ( EN II 1 , 1103b24 ) , Charaktertugenden liegen jedoch erst vor , wenn jemand sich wissentlich für die entsprechenden Handlungen entscheidet , und zwar nicht wegen möglicher Sanktionen , sondern um der tugendhaften Handlungen selbst willen , und wenn er dabei auch nicht ins Wanken gerät ( EN II 3 , 1105a26–33 ) .
+Auch unterscheidet sich der Tugendhafte vom Selbstbeherrschten ( der dieselben Handlungen ausführen mag , sich aber dazu zwingen muss ) dadurch , dass er an der Tugend Freude empfindet ( EN II 2 , 1104b3 ff. ) .
+Durch Gewöhnung ausgeprägt werden die Charaktertugenden , indem Übermaß und Mangel vermieden werden .
+Das Instrument der Mitte bestimmt die Charaktertugenden genauer .
+So ist beispielsweise die Tugend der Tapferkeit eine Mitte zwischen den Lastern Tollkühnheit und Feigheit .
+Grundlage für die Tugenden sind dabei sowohl die Handlungen als auch die Emotionen und Begierden .
+Nicht tapfer , sondern tollkühn ist jemand , der entweder in einer bestimmten Situation völlig furchtlos ist , obwohl die Situation bedrohlich ist , oder der in einer ernsten Bedrohungssituation seine Furcht ignoriert .
+Die Mitte besteht also – hier wie bei den anderen Charaktertugenden – darin , angemessene Emotionen zu haben und demgemäß angemessen zu handeln .
+Dabei ist diese Lehre von der Mitte vermutlich nicht in konkreten Situationen als normativ handlungsleitend , sondern nur als Beschreibungsinstrument der Charaktertugenden aufzufassen . Sie ist auch keine arithmetische Mitte , sondern eine Mitte für uns ( pros hêmas ) , die die jeweilige Emotion , die Person sowie die Situation berücksichtigt .
+Diese Tabelle zeigt einige wichtige Charaktertugenden ( EN II 7 ) :
+Aristoteles definiert die Charaktertugend dementsprechend als Lebensformen und Lust Im Kontext der Analyse des guten Lebens unterscheidet Aristoteles drei Lebensformen , die verschiedene Ziele verfolgen : das Genussleben – mit dem Ziel Lust ; das politische Leben – mit dem Ziel Ehre ; das theoretische Leben – mit dem Ziel Erkenntnis ( EN I 3 ) .
+Das Genussleben im Sinne einer bloßen Befriedigung der Begierden hält Aristoteles für sklavisch und verwirft es .
+Gelderwerb und Reichtum als Ziel hält er nicht für eine Lebensform , da Geld immer nur Mittel zu einem Zweck , aber nie selbst Ziel ist .
+Er plädiert für das theoretische Leben als beste Lebensform .
+Die beste Tätigkeit , die in der Glücksdefinition gesucht wird , ist diejenige des Theoretikers , der Erste Philosophie , Mathematik usw. betrachtet , denn sie bedeutet Muße , dient keinem anderen Zweck , betätigt mit den Verstandestugenden das Beste im Menschen und weist die besten Erkenntnisgegenstände auf ( EN X 7 , 1177a18–35 ) .
+Obwohl er das theoretische Leben für das bestmögliche hält , weist er darauf hin , dass die Betrachtung als Lebensform den Menschen als Menschen übersteigt und eher etwas Göttliches ist ( EN X 7 , 1177b26–31 ) .
+Das zweitbeste Leben ist das politische .
+Es besteht in der Betätigung der Charaktertugenden , die den Umgang mit anderen Menschen sowie mit unseren Emotionen bestimmen .
+Da Charaktertugenden und Verstandestugenden einander nicht ausschließen , meint Aristoteles möglicherweise , dass selbst der Theoretiker , insofern er ein soziales und mit Emotionen ausgestattetes Wesen ist , sich im Sinne des zweitbesten Lebens betätigen muss .
+Aristoteles fasst die Betätigung der Verstandestugenden ( zumindest der Klugheit ) und der Charaktertugenden als wesentliche Elemente des Glücks auf .
+Aber auch äußere oder körperliche Güter und auch die Lust hält er für Bedingungen , die hilfreich oder sogar notwendig sind , um glücklich zu werden .
+Güter wie Reichtum , Freunde und Macht verwenden wir als Mittel .
+Fehlen einige Güter , wird das Glück getrübt , wie bei körperlicher Verunstaltung , Einsamkeit oder missratenen Kindern ( EN I 9 , 1099a31–1099b6 ) .
+Aristoteles meint , das Genussleben führe nicht zum Glück .
+Er hält die Lust nicht für das oberste Gut .
+Gegenüber lustfeindlichen Positionen macht er jedoch geltend , dass das gute Leben Lust einschließen müsse und bezeichnet die Lust als ein Gut ( EN VII 14 ) .
+Auch meint er , man könne einen Tugendhaften , der „ auf das Rad geflochten “ sei , nicht als glücklich bezeichnen ( EN VII 14 , 1153b18–20 ) .
+Gegen Platons Auffassung , Lüste seien Prozesse ( kinêsis ) , die einen Mangel beseitigen ( wie Lust beim Durstlöschen ) , und somit sei das Vollenden des Prozesses besser als dieser selbst , argumentiert Aristoteles dafür , dass Lüste Tätigkeiten ( energeia ) sind , die kein Ziel außer sich aufweisen .
+Paradigmatische Fälle sind Wahrnehmen und Denken .
+Mit diesem Lustkonzept , das Lust als „ unbehinderte Tätigkeit “ oder „ Vervollkommnung der Tätigkeit “ definiert ( EN VII 13 , 1153a14 f. ; X 4 , 1174b33 ) , macht er geltend , dass die Betätigung der Verstandestugenden und der Charaktertugenden lustvoll sein kann .
+Ob Lüste gut oder schlecht sind , hängt davon ab , ob die entsprechenden Tätigkeiten gut oder schlecht sind .
+Bei körperlichen Lüsten ist Letzteres etwa der Fall , wenn sie im Übermaß auftreten oder wenn sie gute Handlungen verhindern und so dem Glück abträglich sind .
+Politische Philosophie Die politische Philosophie des Aristoteles schließt an seine Ethik an .
+Als umfassende Form aller Gemeinschaften besteht der Staat ( polis ) um des höchsten Gutes willen , des Glücks ( EN I 1 , 1094a26–b11 ; Pol. I 1 , 1252a1–7 ) .
+Die politische Philosophie fragt also nach den Bedingungen des Glücks hinsichtlich des Lebens im Staat .
+Hierfür analysiert er die Bestandteile jeder menschlichen Gemeinschaft und jedes Staates und untersucht , welche Verfassung ( politeia ) die beste ist und für welche besonderen Bedingungen welche Verfassung die richtige ist .
+Entstehung , Bestandteile und Zweck des Staates Aus der Sicht von Aristoteles besteht der Staat von Natur aus ( Pol. I 2 , 1253a1 ) .
+Betrachtet man die Teile des Staates , so liegen zunächst zwei grundlegende Beziehungen vor : die zwischen Mann und Frau , deren Zweck die Fortpflanzung ist , und die von Herr und Sklave mit dem Zweck , den Lebensunterhalt zu sichern .
+Beide gemeinsam ergeben die kleinste Gemeinschaft : den Haushalt .
+Aristoteles rechtfertigt die Sklaverei . Er vertritt die These , dass es Sklaven gibt , die von Natur aus zu nichts anderem bestimmt sind als zur Sklaverei .
+Das begründet er damit , dass solche „ Sklaven von Natur “ nur in geringem Maße Anteil an der Vernunft hätten ; daher sei es nicht nur gerechtfertigt , sondern sogar für sie selbst vorteilhaft , dass sie ihr Leben als Sklaven verbringen müssen ( Pol. I 5 , 1254b20–23 ; 1255a1 f. ) . Allerdings ist sein Konzept unklar und widersprüchlich , da er die Freilassung von Sklaven grundsätzlich billigt und für die Unterscheidung zwischen akzidentellen Sklaven ( etwa durch Kriegsgefangenschaft ) und Sklaven von Natur keine klaren Kriterien nennt .
+Sein Rat , Sklaven als Lohn die Freiheit zu versprechen ( Pol. VII 10 , 1330a20 f. ) , widerspricht der Vorstellung eines „ Sklaven von Natur “ .
+Entsprechend argumentiert er auch für eine Unterordnung der Frau ( Pol. VII 10 , 1330a20 f. ) . Es sei für sie besser , vom Mann beherrscht zu werden , da ihre Urteilskraft schwächer sei als die männliche ( Pol. I 5 , 1254b10–15 ; I 13 , 1259a12 ) .
+Mehrere Haushalte ergeben ein Dorf , in dem Arbeitsteilung bessere Versorgung ermöglicht , und mehrere Dörfer einen Staat .
+Dieser ist autark in dem Sinne , dass er die Bedingungen für ein gutes Leben bereitstellen kann .
+Aristoteles unterscheidet den Grund der Entstehung des Staates von seinem Zweck .
+Der Staat entsteht zum Zweck des Überlebens , des Lebens an sich , sein Zweck aber ist das gute Leben : εὖ ζῆν = eu zēn = gut leben ( Pol. I 2 , 1252a25–1253a1 ) .
+Nach Aristoteles gehört es zur Natur des Menschen , in Gemeinschaft zu leben , denn er ist ein „ zôon politikon “ , ein Lebewesen in der Polisgemeinschaft ( Pol. I 2 , 1253a3 ) .
+Nur im Staat kann der Mensch das gute Leben verwirklichen .
+Wer des Staates nicht bedürfe , sei „ entweder ein Tier oder ein Gott “ ( Pol. I 2 , 1253a29 ) .
+Bürger und Verfassung eines Staates Eine Polis ( ein Staat ) besteht aus den freien Bürgern .
+Der Zweck des Staates ist immer das gute Leben .
+Militär- oder Handelsbündnisse , also Verträge , machen noch keinen Staat aus .
+Kennzeichnendes Merkmal eines bestimmten Staates ist seine Verfassung .
+Der Bürger
+Bürger sind die mit dem Bürgerrecht ausgestatteten Einwohner , die sich aktiv am politischen Geschehen ( am Richten und Regieren ) beteiligen ( Pol. III 1 , 1275a22 ) .
+Den Bürger bestimmt Aristoteles also primär nicht über die Herkunft oder den Wohnort , sondern über die Partizipation an den politischen Institutionen des Staates .
+Entsprechend den damaligen Verhältnissen in Athen betrachtet Aristoteles Frauen , Kinder , Sklaven und Fremde nicht als Bürger .
+Ein Bürger darf auch nicht für seinen Lebensunterhalt arbeiten müssen .
+Lohnarbeiter und Handwerker können somit keine Bürger sein ( Pol. III 5 , 1278a11 ) .
+Die jeweilige Verfassung eines Staates bestimmt genauer , wer Bürger ist und wer nicht .
+Theorie der Verfassungen
+In seiner Unterscheidung der verschiedenen Verfassungen stellt Aristoteles zwei Fragen : Wer herrscht ?
+Zu wessen Nutzen wird geherrscht ?
+Bei der ersten Frage unterscheidet er drei mögliche Antworten : einer , wenige , viele .
+Bei der zweiten Frage unterscheidet er zwei mögliche Zustände und Nutznießer : die Verfassung ist gerecht , wenn zum Nutzen aller regiert wird ; sie ist ungerecht oder verfehlt , wenn allein zum Nutzen der Herrschenden regiert wird ( Pol. III 6 , 1279a17–21 ) .
+Auf dieser Grundlage entwirft er eine erste Staatsformenlehre mit sechs Verfassungen ( Pol , III 6–8 ) : Die verschiedenen Verfassungen wenden auf unterschiedliche Weise die distributive Gerechtigkeit an ( Pol. III 9 , 1280a7–22 ) .
+Distributive Gerechtigkeit bestimmt er als die Verteilung proportional zur Leistung oder Würde ( EN V 6 ) .
+Datei : Aristotle-constitutions-2.png
+Kritik an schlechten Verfassungen
+Unter den schlechten , nicht am Gemeinwohl orientierten Verfassungen hält er die Tyrannis für die schlechteste , denn in ihr herrscht der Tyrann über den Staat im Sinne einer despotischen Alleinherrschaft wie der Herr über den Sklaven ( Pol. III 8 , 1279b16 ) .
+Für etwas weniger schlecht erachtet er die durch die Herrschaft der Reichen gekennzeichnete Oligarchie , die ebenso wie die Tyrannis sehr instabil ist ( Pol. V 12 ) .
+Für den Grundirrtum der Oligarchie hält Aristoteles die Auffassung , dass die , die in einer Hinsicht ( Besitz ) ungleich sind , in allen Hinsichten ungleich seien .
+Entsprechend besteht der Grundirrtum der Demokratie in der Ansicht , dass die , die in einigen Hinsichten gleich sind , dies in allen seien ( Pol. V 1 , 1301a25–36 ) .
+Die Demokratie hält Aristoteles für weniger schlecht als die Tyrannis und Oligarchie .
+Sie ist neben Gleichheit durch Freiheit gekennzeichnet .
+Freiheit bedeutet dabei , so zu leben wie man will , Gleichheit , dass das Regieren und Regiertwerden reihum geht ( 1317b2–12 ) .
+Die absolute Freiheit , so zu leben wie man will , hält Aristoteles insofern für problematisch , als sie mit der Herrschaft der Verfassung in Konflikt steht ( Pol. V 9 , 1310a30–35 ) .
+Gleichheit kritisiert er , wenn sie als totale arithmetische interpretiert wird , die dazu führe , dass die Herrschaft der Unvermögenden die Besitzenden enteignet .
+Dafür , dass Aristoteles die Beteiligung des „ einfachen Volkes “ an der Herrschaft durchaus nicht rundweg abgelehnt hat , spricht ferner seine so genannte „ Summierungsthese “ ( Pol. III 11 , 1281 a38–b9 ) und eine differenzierte Untersuchung der Formen der Volksherrschaft im Rahmen seiner zweiten Staatsformenlehre .
+Gute Verfassungen
+Unter den guten Verfassungen ist die Monarchie ( unter der Aristoteles nicht zwingend ein Königtum , sondern nur eine dem Gemeinwohl dienende Alleinherrschaft versteht ) am wenigsten gut .
+Insofern sie nicht gesetzgebunden ist , ist sie eine bloße Herrschaftsform , teilweise kaum eine Verfassung , und insofern problematisch , als nur das Gesetz unbeeinflusst von Emotionen herrschen kann .
+Unter einer Aristokratie versteht er eine Herrschaft der Guten , das heißt derjenigen , die am meisten Anteil an der Tugend ( aretê ) haben , was nicht unbedingt Herrschaft eines Geburtsadels bedeuten muss .
+Da das Ziel des Staates , das gute Leben , in einer Aristokratie im höchsten Maße verwirklicht wird , hält Aristoteles sie ( neben einer bestimmten Form der Monarchie , nämlich der Königsherrschaft ) für die beste Verfassung ( Pol. IV 2 , 1289a30–32 ) .
+Aristoteles diskutiert Verfassungstheorie allerdings nicht ohne Realitätsbezug .
+Oft ist aus seiner Sicht eine absolut beste Verfassung in einem bestimmten Staat nicht möglich .
+Was am besten für einen konkreten Staat ist , muss immer relativ zu den Umständen bestimmt werden ( Pol. IV 1 , 1288b21–33 ) .
+Solche Überlegungen durchziehen die ganze Verfassungstheorie .
+Sie zeigen sich insbesondere im Modell der Politie , die Aristoteles als die bestmögliche für die meisten zeitgenössischen Staaten ansieht ( Pol. IV 11 , 1295a25 ) .
+Sie ist eine Mischverfassung , die Elemente der Demokratie und der Oligarchie enthält .
+Dabei wird für die Bestrebungen nach Gleichheit auf der einen und nach Reichtum auf der anderen Seite ein Ausgleich geschaffen .
+Dieser Ausgleich wird unter anderem durch Ämterzuteilung nach Klassenzugehörigkeit erreicht ( Pol. V 8 , 1308b26 ) .
+Auf diese Weise wird nach seiner Auffassung die Stabilität erhöht und sozialen Unruhen vorgebeugt ( die in griechischen Staaten häufig waren ) .
+Besondere Stabilität verleiht dem Staat ein breiter Mittelstand ( Pol. IV 11 , 1295b25–38 ) .
+Poetik Theorie der Dichtung Mimêsis
+Der zentrale Begriff der aristotelischen Theorie der Dichtung , die er in seiner zu Lebzeiten nicht veröffentlichten Poetik ( poiêtikê ) ausarbeitet , ist die mimêsis , das heißt die „ Nachahmung “ oder „ Darstellung “ . Neben der Dichtung im engeren Sinne ( Epik , Tragödie , Komödie und Dithyrambendichtung ) zählen auch Teile der Musik und der Tanz für Aristoteles zu den mimetischen Künsten ( Poet . 1 , 1447a ) .
+Abbildende Künste wie Malerei und Plastik behandelt Aristoteles nicht weiter , sondern erwähnt nur , dass sie ebenfalls nach dem Prinzip der Nachahmung arbeiten ( Poet .
+1 , 1447a19 f. ) . Gemeinsam ist allen mimetischen Künsten die zeitliche Sukzession .
+Insofern lässt sich mimêsis als ästhetisches Handeln auffassen .
+In der Lust an der mimêsis sieht Aristoteles eine anthropologische , allen Menschen gemeinsame Grundgegebenheit .
+Denn die Freude an ihr sowie an ihren Produkten ist den Menschen angeboren , da sie gerne lernen ( Poet .
+4 , 1448b5-15 ) .
+Im Gegensatz zu den anderen mimetischen Künsten ist für die Dichtung die Verwendung von Sprache spezifisch .
+Alle Dichtung ist zudem Darstellung von Handlungen ; allerdings nicht von tatsächlich Geschehenem , sondern von dem , „ was geschehen könnte , das heißt das nach den Regeln der Wahrscheinlichkeit oder Notwendigkeit Mögliche “ ( Poet .
+9 , 1451a37 f. ) . Dargestellt werden Handlungen , die etwas über den Menschen im Allgemeinen aussagen , nicht über zufällige und beliebige Verhältnisse .
+Ziel ist nicht die Nachahmung von Menschen ; nicht auf Figuren oder Charaktere , sondern auf Handlungen kommt es an ; Erstere sind nur Mittel ( Poet .
+6 , 1450a26–23 ) .
+Arten der Dichtung
+Aristoteles klassifiziert vier Formen der existierenden Dichtung nach zwei Kriterien : ( i ) der Art der Darstellung von Handlung und ( ii ) der Art der dargestellten Figuren .
+Dramatische Darstellung ist dadurch gekennzeichnet , dass die jeweilige Figur selbst die Handlung darstellt , berichtende dadurch , dass über die Handlung berichtet wird .
+Mit „ besser “ und „ schlechter “ sind die Figuren und ihre Handlungen gemeint .
+Bessere Figuren oder Charaktere sind etwas besser als wir selbst , schlechtere schlechter ; beides aber nie so weit , dass wir uns nicht mehr mit ihnen identifizieren können ( Poet .
+5 , 1449a31–1449b13 ) .
+Aristoteles vertritt dabei die Hypothese , dass die Tragödie aus dem Epos und die Komödie aus dem Spottlied entstanden ist ( Poet .
+4 , 1449a2–7 ) .
+Eine Untersuchung der Komödie kündigt Aristoteles an .
+Sie ist aber – wie auch eine des Spottliedes – nicht überliefert .
+Das Epos behandelt er recht kurz .
+Seine überlieferte Dichtungstheorie ist daher primär eine Tragödientheorie .
+Tragödie
+Aristoteles definiert die Tragödie als eine Dieser kurze Satz ist eine der meistdiskutierten Passagen im gesamten Werk des Aristoteles .
+( 3 ) nennt das dramatisch-darstellende Element .
+( 1 ) nennt ( neben oben schon genannten Aspekten ) die ( später sogenannte ) Einheit der Handlung .
+Die Einheit des Ortes und der Zeit wurde in der Renaissance der aristotelischen Tragödientheorie zugeschrieben , er vertrat sie aber selbst so nicht .
+( 2 ) bezieht sich darauf , dass die Sprache der Tragödie Melodie und Rhythmus aufweist .
+Die weitaus meiste Aufmerksamkeit hat ( 4 ) erhalten , insbesondere ( 4b ) .
+Emotionserregung und Katharsis
+In ( 4 ) beschreibt Aristoteles die Funktion der Tragödie , das was sie leisten soll .
+Weitgehend unumstritten ist nur ( 4a ) : Beim Zuschauer sollen durch die dargestellte Handlung die Emotionen Mitleid und Furcht erregt werden .
+Unklar ist allerdings , ob eleos und phobos tatsächlich mit „ Mitleid “ und „ Furcht “ oder mit „ Elementareffekten “ „ Jammer “ und „ Schauder “ wiederzugeben sind . Dass die Handlung selbst und nicht die Aufführung die entscheidende Rolle bei der Emotionserregung spielt , ist daraus ersichtlich , dass Aristoteles auch die gelesene Tragödie durch seine Theorie berücksichtigt sieht .
+Mitleid wird erregt , wenn die Protagonisten unverdient Unglück erleiden , Furcht , wenn sie dabei dem Zuschauer ( oder Leser ) ähnlich sind .
+( 4b ) ist höchst kontrovers , da die Funktionsweise nicht weiter erläutert ist .
+Das Wort Katharsis , das als Metapher ( wie „ Reinigung “ im Deutschen ) einen Sinnüberschuss aufweist , hat zu den verschiedensten Deutungen Anlass gegeben , insbesondere weil es schon vor Aristoteles verwendet wurde , nämlich unter anderem in der Medizin ( Reinigung durch Brech- und Abführmittel ) und in religiösen Kulten ( Reinigung von unreinen Personen durch religiöse Praktiken ) .
+Die grammatikalische Konstruktion Reinigung der Emotionen lässt dabei verschiedene Deutungen zu , worin die Reinigung besteht .
+Vermutlich sollen die Emotionen selbst ( durch eine Emotionserregung ) gereinigt werden ; die Aussage ist aber auch als Reinigung von den Emotionen verstanden worden .
+Der normativ-deskriptive Charakter der Tragödientheorie
+Aristoteles ’ Tragödientheorie weist zwei Typen von Aussagen auf .
+Zum einen untersucht er die Grundlagen der Dichtung , unterscheidet verschiedene Arten von ihr und nennt Teile einer Tragödie und deren Funktionsweise .
+Zum anderen spricht er aber auch davon , was eine gute Tragödie ist und was der Dichter entsprechend machen soll . So äußert er etwa , dass in einer guten Tragödie ein Protagonist weder aufgrund seines guten noch seines schlechten Charakters vom Glück ins Unglück gerät , sondern aufgrund eines Fehlers ( hamartia ) , beispielsweise wie Ödipus aufgrund von Unwissenheit .
+Nur eine schlechte Tragödie würde zeigen , wie ein guter Charakter vom Glück ins Unglück oder ein schlechter vom Unglück ins Glück gerät .
+Der Grund hierfür ist die Funktion der Tragödie , das Bewirken von Mitleid und Furcht .
+In schlechten Tragödien würden Mitleid und Furcht nicht erregt werden , in guten ist dies aufgrund der Beschaffenheit des Protagonisten und des Fehlers als Ursache des Unglücks der Fall ( Poet .
+13 , 1452b28–1453a12 ) .
+Hymnos Von Aristoteles ist zudem ein Hymnos an Aretê überliefert , den er in Erinnerung an seinen Freund Hermias verfasst hat .
+Rezeption Antike Datei : Spangenberg - Schule des Aristoteles.jpg
+Die Lehre des Aristoteles hat auf seine Schule , den Peripatos , nach seinem Tode weit weniger Einfluss ausgeübt als Platons Lehre auf dessen Akademie .
+Aristoteles wurde keine Verehrung zuteil , die mit derjenigen Platons bei den Platonikern vergleichbar wäre .
+Dies bedeutete einerseits Offenheit und Flexibilität , andererseits Mangel an inhaltlich begründetem Zusammenhalt .
+Die Peripatetiker widmeten sich vor allem empirischer Naturforschung und befassten sich unter anderem auch mit Ethik , Seelenlehre und Staatstheorie .
+Dabei kamen Aristoteles ’ Schüler Theophrastos , sein Nachfolger als Leiter der Schule , und dessen Nachfolger Straton zu teilweise anderen Ergebnissen als der Schulgründer .
+Nach Stratons Tod ( 270/268 v. Chr. ) begann eine Periode des Niedergangs .
+Datei : Andrea briosco , aristotele e alessandro di afrodisia.JPG
+Das Studium und die Kommentierung der Schriften des Aristoteles wurde damals im Peripatos anscheinend vernachlässigt , jedenfalls weit weniger eifrig betrieben als das Platonstudium in der konkurrierenden Akademie .
+Erst im ersten Jahrhundert v. Chr. sorgte Andronikos von Rhodos für eine Zusammenstellung der Lehrschriften ( Pragmatien ) des Aristoteles , und auch bei deren Auslegung durch die Peripatetiker kam es zu einem Aufschwung .
+Die für die Öffentlichkeit bestimmten „ exoterischen “ Schriften , insbesondere die Dialoge , waren lange populär , gingen aber in der römischen Kaiserzeit verloren .
+Cicero hat sie noch gekannt .
+Die Peripatetiker betrachteten die Lehrschriften als speziell für ihren internen Unterrichtsgebrauch bestimmt .
+In der römischen Kaiserzeit war der einflussreichste Repräsentant des Aristotelismus Alexander von Aphrodisias , der gegen die Platoniker die Sterblichkeit der Seele vertrat .
+Obwohl Aristoteles großen Wert auf die Widerlegung von Kernbestandteilen des Platonismus gelegt hatte , waren es gerade die Neuplatoniker , die in der Spätantike einen maßgeblichen Beitrag zur Erhaltung und Verbreitung seiner Hinterlassenschaft leisteten , indem sie seine Logik übernahmen , kommentierten und in ihr System integrierten .
+Eine besonders wichtige Rolle spielten dabei im 3. Jahrhundert n. Chr. Porphyrios , im 5. Jahrhundert Proklos , Ammonios Hermeiou ( der in Alexandria die Tradition der Aristoteles-Kommentierung begründete ) und im 6. Jahrhundert Simplikios , der bedeutende Aristoteleskommentare verfasste .
+Im 4. Jahrhundert schrieb Themistios Paraphrasen zu Werken des Aristoteles , die eine starke Nachwirkung erzielten .
+Er war unter den spätantiken Kommentatoren der einzige ( wenn auch neuplatonisch beeinflusste ) Aristoteliker ; die anderen befassten sich mit dem Aristotelismus aus neuplatonischer Perspektive und strebten eine Synthese platonischer und aristotelischer Auffassungen an , wobei oft ein Übergewicht der platonischen erkennbar ist .
+Noch zu Beginn des 7. Jahrhunderts kommentierte der angesehene , in Konstantinopel lehrende christliche Philosoph Stephanos von Alexandria Werke des Aristoteles .
+Bei den prominenten antiken Kirchenvätern war Aristoteles wenig bekannt und unbeliebt , manche verachteten und verspotteten seine Dialektik .
+Sie verübelten ihm , dass er das Weltall für ungeschaffen und unvergänglich hielt und die Unsterblichkeit der Seele bezweifelte ( oder nach ihrem Verständnis bestritt ) .
+Ein positiveres Verhältnis zu Aristoteles hatten hingegen manche christliche Gnostiker und andere häretische Christen : Arianer ( Aëtios , Eunomius ) , Monophysiten , Pelagianer und Nestorianer – ein Umstand , der den Philosophen für die kirchlichen Autoren erst recht suspekt machte .
+Syrer – monophysitische wie nestorianische – übersetzten das Organon in ihre Sprache und setzten sich intensiv damit auseinander .
+Im 6. Jahrhundert schrieb Johannes Philoponos Aristoteles-Kommentare , übte aber auch scharfe Kritik an der aristotelischen Kosmologie und Physik .
+Er war mit seiner Impetustheorie ein Vorläufer spätmittelalterlicher und frühneuzeitlicher Kritik an der aristotelischen Bewegungslehre .
+Mittelalter Datei : Aristotle , Vienna , Cod .
+Phil. gr. 64.jpg
+Im Byzantinischen Reich des Frühmittelalters wurde Aristoteles wenig beachtet .
+Sein Einfluss machte sich vorwiegend indirekt geltend , nämlich über die meist neuplatonisch gesinnten spätantiken Autoren , die Teile seiner Lehre übernommen hatten .
+Daher war Vermischung mit neuplatonischem Gedankengut von vornherein gegeben .
+Bei Johannes von Damaskus tritt die aristotelische Komponente deutlich hervor .
+Im 11. und 12. Jahrhundert kam es zu einer Wiederbelebung des Interesses an aristotelischer Philosophie : Michael Psellos , Johannes Italos und dessen Schüler Eustratios von Nikaia ( beide wegen Häresie verurteilt ) sowie der primär philologisch orientierte Michael von Ephesos schrieben Kommentare .
+Die Kaisertochter Anna Komnena förderte diese Bestrebungen .
+Im islamischen Raum setzte die Wirkung der Werke des Aristoteles früh ein und war breiter und tiefer als in der Spätantike und im europäischen Früh- und Hochmittelalter .
+Der Aristotelismus dominierte qualitativ und quantitativ gegenüber der übrigen antiken Tradition .
+Schon im 9. Jahrhundert waren die meisten Werke des Aristoteles , häufig durch vorangehende Übersetzung ins Syrische vermittelt ( der erste syrische Aristoteleskommentator war Sergios von Resaina ) , in arabischer Sprache verfügbar , ebenso antike Kommentare .
+Hinzu kam ein reichhaltiges unechtes ( pseudo-aristotelisches ) Schrifttum teilweise neuplatonischen Inhalts , darunter Schriften wie die Theologie des Aristoteles und der Kalam fi mahd al-khair ( Liber de causis ) . Die aristotelischen Ideen waren von Anfang an mit neuplatonischen vermischt , und man glaubte an eine Übereinstimmung der Lehren Platons und des Aristoteles .
+In diesem Sinne deuteten al-Kindī ( 9. Jahrhundert ) und al-Farabi ( 10. Jahrhundert ) und die ihnen folgende spätere Tradition den Aristotelismus ; bei ibn Sina ( Avicenna ) trat das neuplatonische Element stärker in den Vordergrund .
+Einen relativ reinen Aristotelismus vertrat hingegen im 12. Jahrhundert ibn Rušd ( Averroes ) , der zahlreiche Kommentare schrieb und die aristotelische Philosophie gegen al-Ghazali verteidigte .
+Im lateinischen Mittelalter war zunächst bis ins 12. Jahrhundert nur ein kleiner Teil des Gesamtwerks des Aristoteles verbreitet , nämlich zwei der logischen Schriften ( Kategorien und De interpretatione ) , die Boethius im frühen 6. Jahrhundert übersetzt und kommentiert hatte , zusammen mit der Einleitung des Porphyrios zur Kategorienlehre .
+Dieses Schrifttum , später als Logica vetus bezeichnet , bildete die Grundlage des Logikunterrichts .
+Mit der großen Übersetzungsbewegung des 12. und 13. Jahrhunderts änderte sich diese enge Begrenzung .
+Im 12. Jahrhundert wurden die bisher fehlenden logischen Schriften ( Analytica priora und posteriora , Topik , Sophistische Widerlegungen ) in lateinischer Sprache verfügbar ; sie machten die Logica nova aus .
+Dann wurden eines nach dem anderen fast alle restlichen Werke zugänglich ( teils erst im 13. Jahrhundert ) . Die meisten Schriften wurden mehrmals ins Lateinische übertragen ( entweder aus dem Arabischen oder aus dem Griechischen ) .
+Michael Scotus übersetzte Aristoteleskommentare des Averroes aus dem Arabischen .
+Sie wurden eifrig benutzt , was in der zweiten Hälfte des 13. Jahrhunderts zur Entstehung des lateinischen Averroismus führte , der ein für damalige Verhältnisse relativ konsequenter Aristotelismus war .
+Im Lauf des 13. Jahrhunderts wurden die Schriften des Aristoteles als Standardlehrbücher zur Grundlage der an den Universitäten ( in der Fakultät der Freien Künste ) betriebenen scholastischen Wissenschaft ; 1255 wurden seine Logik , Naturphilosophie und Ethik an dieser Fakultät der Pariser Universität als Lehrstoff vorgeschrieben .
+Die Führungsrolle kam der Pariser und der Oxforder Universität zu .
+Wegweisend waren die Aristoteleskommentare des Albertus Magnus .
+Das Verfassen von Aristoteleskommentaren wurde eine Hauptbeschäftigung der Magister , und viele von ihnen hielten die kommentierten Lehrbücher für irrtumsfrei .
+Besonders intensiv studierte man neben der aristotelischen Methodik die Wissenschaftstheorie , um sie als Basis für ein hierarchisch geordnetes System der Wissenschaften zu verwenden .
+Datei : Aristotle by Raphael.jpg Widerstand erhob sich allerdings von theologischer Seite gegen einzelne Lehren , vor allem gegen die Thesen von der Ewigkeit der Welt und der absoluten Gültigkeit der Naturgesetze ( Ausschluss von Wundern ) , sowie gegen den Averroismus .
+Daher kam es 1210 , 1215 , 1231 , 1245 , 1270 und 1277 zu kirchlichen Verurteilungen von Lehrsätzen und zu Aristotelesverboten .
+Sie richteten sich aber nur gegen die naturphilosophischen Schriften oder gegen einzelne Thesen und konnten den Siegeszug des Aristotelismus nur vorübergehend hemmen .
+Diese Verbote betrafen nur Frankreich ( vor allem Paris ) , in Oxford galten sie nicht .
+Aristoteles wurde „ der Philosoph “ schlechthin : mit Philosophus ( ohne Zusatz ) war immer nur er gemeint , mit Commentator Averroes .
+Gegenpositionen ( vor allem in der Erkenntnistheorie und Anthropologie ) vertraten Anhänger der platonisch beeinflussten Lehren des Augustinus , besonders Franziskaner ( „ Franziskanerschule “ ) . Ein prominenter Kritiker des Aristotelismus war der Franziskaner Bonaventura .
+Ein anderer Franziskaner , Petrus Johannis Olivi , stellte um 1280 missbilligend fest : „ Man glaubt ihm ( Aristoteles ) ohne Grund – wie einem Gott dieser Zeit . “ Schließlich setzte sich das von dem Dominikaner Thomas von Aquin abgewandelte und weiterentwickelte aristotelische Lehrsystem ( Thomismus ) durch , zunächst in seinem Orden und später in der gesamten Kirche .
+Allerdings schrieb man weiterhin neuplatonische Schriften zu Unrecht dem Aristoteles zu , wodurch das Gesamtbild seiner Philosophie verfälscht wurde .
+Dante würdigte in seiner Göttlichen Komödie Bedeutung und Ansehen des Aristoteles , indem er ihn als „ Meister “ darstellte , der von den anderen antiken Philosophen bewundert und geehrt wird ; jedoch verwarf Dante manche aristotelische Lehren .
+Die Politik des Aristoteles wurde erst um 1260 von Wilhelm von Moerbeke ins Lateinische übersetzt und dann von Thomas von Aquin und anderen Scholastikern kommentiert und zitiert .
+Besonders die Rechtfertigung der Sklaverei bzw. Knechtschaft stieß bei den Gelehrten auf Interesse und grundsätzliche Zustimmung .
+Die Politik regte Kommentatoren und Verfasser politischer Traktate zu Erörterungen über Vor- und Nachteile von Erb- bzw. Wahlmonarchie sowie von absoluter bzw. ans Gesetz gebundener Herrschaft an .
+In der Epoche des Übergangs vom Spätmittelalter zur Frühen Neuzeit setzte sich Nikolaus von Kues kritisch mit Aristoteles auseinander .
+Er stellte sich Aristoteles als fiktiven Gesprächspartner vor , dem man die Berechtigung der cusanischen Lehre von der Coincidentia oppositorum einsichtig machen könnte , obwohl Aristoteles sie nach seinem Satz vom Widerspruch hätte verwerfen müssen .
+Neuzeit Datei : Rembrandt Harmensz .
+van Rijn 013.jpg
+Datei : Francesco Hayez 001.jpg Datei : Statue des Aristoteles.JPG
+In der Renaissance fertigten Humanisten neue , viel leichter lesbare Aristotelesübersetzungen ins Lateinische an , weshalb man weniger auf die Kommentare angewiesen war .
+Bedeutend sind u. a. die Übersetzungen der Nikomachischen Ethik und der Politik durch Leonardo Bruni .
+Man begann aber auch , die griechischen Originaltexte zu lesen .
+Es kam zu heftigem Streit zwischen Platonikern und Aristotelikern , wobei die beteiligten Humanisten mehrheitlich zu Platon neigten .
+Es gab in der Renaissance aber auch bedeutende Aristoteliker wie Pietro Pomponazzi ( 1462–1525 ) und Jacopo Zabarella ( 1533–1589 ) , und es entstanden damals im Abendland mehr Aristoteleskommentare als während des gesamten Mittelalters .
+Wie im Mittelalter herrschte auch noch bei vielen Renaissance-Gelehrten das Bestreben vor , platonische und aristotelische Standpunkte untereinander und mit der katholischen Theologie und Anthropologie zu versöhnen .
+Seit dem 15. Jahrhundert war es aber möglich , dank des besseren Zugangs zu den Quellen das Ausmaß der fundamentalen Gegensätze zwischen Platonismus , Aristotelismus und Katholizismus besser zu verstehen .
+Bei der Vermittlung dieser Erkenntnisse spielte der byzantinische Philosoph Georgios Gemistos Plethon eine wichtige Rolle .
+Unabhängig davon herrschte der ( neu ) scholastische Aristotelismus , der die mittelalterliche Tradition fortsetzte , mit seiner Methode und Terminologie an Schulen und Universitäten noch bis tief in die Neuzeit , auch in den lutherischen Gebieten , obwohl Martin Luther den Aristotelismus ablehnte .
+Im sechzehnten Jahrhundert unternahmen Bernardino Telesio und Giordano Bruno Frontalangriffe auf den Aristotelismus , und Petrus Ramus trat für eine nichtaristotelische Logik ein ( Ramismus ) .
+Bereits Giovanni Battista Benedetti ( 1530–1590 ) widerlegte 1554 in seinem Werk Demonstratio proportionum motuum localium contra Aristotilem et omnes philosophos in einem simplen Gedankenexperiment die aristotelische Annahme , dass Körper im freien Fall umso schneller fallen , je schwerer sie sind : Zwei gleiche Kugeln , die durch eine ( masselose ) Stange fest verbunden werden , fallen mit derselben Geschwindigkeit wie jede der beiden Kugeln allein .
+Aber erst seit dem 17. Jahrhundert verdrängte ein neues Wissenschaftsverständnis die aristotelisch-scholastische Tradition .
+Den Umschwung in der Physik leitete Galileo Galilei ein .
+1647 konnte die von Aristoteles aufgestellte Hypothese eines Horror Vacui von Blaise Pascal mit dem Versuch Leere in der Leere widerlegt werden .
+Erst in der 1687 veröffentlichten Schrift Philosophiae Naturalis Principia Mathematica von Isaac Newton wurde mit dem Trägheitsprinzip ein Fundament der neuen klassischen Mechanik errichtet , das die aristotelischen Annahmen ersetzte .
+In der Biologie konnten sich aristotelische Auffassungen bis ins 18. Jahrhundert halten .
+Sie erwiesen sich teilweise als fruchtbar .
+So ging William Harvey bei der Entdeckung des Blutkreislaufs von dem Prinzip des Aristoteles aus , dass die Natur nichts Unnötiges hervorbringt , und wendete es auf die Beschaffenheit der Blutgefäße und Herzkammern , von denen Aristoteles fälschlich drei annahm , an . Charles Darwin bezeichnete 1879 Aristoteles als „ einen der größten Beobachter ( wenn nicht den größten ) , die jemals gelebt haben “ .
+Sehr stark und anhaltend war die Nachwirkung von Aristoteles ’ Poetik , insbesondere seiner Tragödientheorie ( → Regeldrama ) .
+Sie prägte Theorie und Praxis des Theaters während der gesamten Frühen Neuzeit , abgesehen von manchen gewichtigen Ausnahmen besonders in Spanien und England ( Shakespeare ) .
+Die Poetik lag seit 1278 in lateinischer Übersetzung vor , 1498 und 1536 erschienen humanistische Übersetzungen .
+Auf ihr fußte die Poetik des Julius Caesar Scaliger ( 1561 ) , die Dichtungslehre von Martin Opitz ( 1624 ) , die französische Theaterlehre des 17. Jahrhunderts ( doctrine classique ) und schließlich die von Johann Christoph Gottsched geforderte Regelkunst ( Critische Dichtkunst , 1730 ) .
+Im 19. Jahrhundert setzte insbesondere in Deutschland die intensive philologische Auseinandersetzung mit dem Werk des Aristoteles ein .
+1831 erschien die von der Preußischen Akademie der Wissenschaften in Auftrag gegebene und durch Immanuel Bekker besorgte Gesamtausgabe .
+Hermann Bonitz verfasste zahlreiche Übersetzungen und den noch heute maßgeblichen Index Aristotelicus . Ende des 19. Jahrhunderts wurde unter der Leitung von Hermann Diels ebenfalls in der in Berlin ansässigen Akademie die 15.000 Seiten umfassende Ausgabe der antiken griechischen Aristoteles-Kommentare ( Commentaria in Aristotelem Graeca ) veröffentlicht .
+Infolge der intensiven philologischen Auseinandersetzung wurde Anfang des 20. Jahrhunderts das lange vorherrschende Bild , das Corpus Aristotelicum sei ein als Ganzes komponiertes philosophisches System , vor allem von Werner Jaeger revidiert .
+Die moderne Aristotelesforschung wurde in der ersten Hälfte des 20. Jahrhunderts neben Jaeger vor allem von W. D. Ross in Oxford bestimmt ; zahlreiche Schüler sorgten für eine zunehmende Beschäftigung mit Aristoteles nicht nur in den philologischen , sondern auch den philosophischen Abteilungen angelsächsischer Universitäten , die bis heute anhält .
+Heideggers Seinsanalyse der Fundamentalontologie geschah in intensiver Auseinandersetzung mit Aristoteles , was auch für Schüler wie Hans Georg Gadamer gilt .
+Den größten Einfluss hatte Aristoteles im 20. Jahrhundert in der Ethik ( Tugendethik ) und der politischen Philosophie ( in Deutschland insbesondere in der Schule um Joachim Ritter , im angelsächsischen Raum im Kommunitarismus ) .
+In der zweiten Hälfte des 20. Jahrhunderts griff die zuvor metaphysikkritische analytische Philosophie Aristoteles ’ Substanztheorie explizit ( etwa David Wiggins : Sameness and Substance , die Vier-Kategorien-Ontologie von Jonathan Lowe oder die Ontologie von Barry Smith ) oder seinen Essentialismus implizit auf ( z. B.
+Kripke ) .
+Nach ihm ist der Mondkrater Aristoteles benannt .
+Gleiches gilt seit 2012 für die Aristotle Mountains im Grahamland auf der Antarktischen Halbinsel .
+Siehe auch Symposium Aristotelicum
+Textausgaben und Übersetzungen Sammlungen
+Diverse Herausgeber in der Reihe Oxford Classical Texts ( OCT ) bei Oxford University Press Diverse Herausgeber und Übersetzer in der Reihe Loeb Classical Library ( LCL ) bei Harvard University Press ( griechischer Text mit englischer Übersetzung ) Ernst Grumach , Hellmut Flashar ( Hrsg. ) : Aristoteles .
+Werke in deutscher Übersetzung .
+19 Bände , Akademie Verlag , Berlin 1956 ff. ( mit extensivem und in der Regel sehr gutem Kommentar ) Jonathan Barnes ( Hrsg. ) : The Complete Works of Aristotle .
+The revised Oxford translation .
+2 Bände .
+Princeton ( New Jersey ) 1984 , 6. Auflage 1995 , ISBN 0-691-09950-2 ( Sammlung der maßgeblichen englischen Übersetzungen ) Aristoteles : Philosophische Schriften in sechs Bänden . Felix Meiner , Hamburg 1995 , ISBN 3-7873-1243-9 ( Übersetzungen ; diverse Übersetzer ) Immanuel Bekker ( Hrsg. ) : Aristotelis opera .
+2. Auflage , besorgt von Olof Gigon .
+De Gruyter , Berlin 1960–1987 Band 1. 1960 ( Nachdruck der Ausgabe von 1831 mit Verzeichnis neuerer Einzelausgaben ) .
+Ausgabe von 1831 online
+Band 2. 1960 ( Nachdruck der Ausgabe von 1831 mit Verzeichnis neuerer Einzelausgaben ) .
+Ausgabe von 1831 online
+Band 3. Librorum deperditorum fragmenta , hrsg. von Olof Gigon , 1987 , ISBN 3-11-002332-6 Band 4. Scholia in Aristotelem , hrsg. von Christian August Brandis ; Supplementum scholiorum , hrsg. von Hermann Usener ; Vita Marciana , hrsg. von Olof Gigon , 1961 ( Nachdruck der Scholia-Ausgabe von 1836 und der Supplementum-Ausgabe von 1870 ; Vita Marciana als Neuausgabe ) .
+Ausgabe der von 1836 online
+Band 5. Index Aristotelicus , hrsg. von Hermann Bonitz , 2. Auflage besorgt von Olof Gigon , 1961 Einzelausgaben
+Literatur Der historische Aristoteles Biographie
+Carlo Natali : Aristotle .
+His Life and School .
+Princeton University Press , Princeton / Oxford 2013 , ISBN 978-0-691-09653-7 Einführungen
+John Lloyd Ackrill : Aristoteles .
+Eine Einführung in sein Philosophieren .
+De Gruyter , Berlin 1985 , ISBN 3-11-008915-7 ( knappe Einführung vor allem in die theoretische Philosophie ) Jonathan Barnes : Aristoteles .
+Eine Einführung .
+Reclam , Stuttgart 1999 [ 1982 ] , ISBN 3-15-008773-2 ( knappe Einführung ; Biographisches und Naturwissenschaftliches relativ ausführlich , wenig zur praktischen Philosophie ) Thomas Buchheim : Aristoteles . Herder , Freiburg i. Br. 1999 , ISBN 3-451-04764-0 ( Einführung mit Schwerpunkt auf dem Organon , der Naturphilosophie und Metaphysik ; wenig praktische Philosophie , keine Rezeption ; kommentierte Bibliografie ) Wolfgang Detel : Aristoteles . Reclam , Leipzig 2005 , ISBN 3-379-20301-7 ( Einführung mit hohem systematischem Anspruch , insbesondere zu Wissenschaftstheorie und Metaphysik ; Kapitel zum Neoaristotelismus des 20. Jahrhunderts ) Otfried Höffe : Aristoteles . 3. Auflage .
+Beck , München 2006 , ISBN 3-406-54125-9 ( Biographisches , praktische Philosophie und Rezeption ausführlich ; Bezüge zu anderen Epochen , insbesondere der Neuzeit ) Christof Rapp : Aristoteles zur Einführung . 4. Auflage .
+Junius , Hamburg 2012 , ISBN 978-3-88506-690-3 ( singuläre Darstellung der Handlungstheorie , der Semantik , Dialektik und Rhetorik sowie Ontologie ; nichts zur Person ; hilfreiche , thematisch gegliederte Bibliografie ) Christopher Shields : Aristotle . Routledge , New York 2007 , ISBN 978-0-415-28332-8 ( umfangreiche thematisch gegliederte Einführung ; Review ) Wolfgang Welsch : Der Philosoph : Die Gedankenwelt des Aristoteles . Fink ( Wilhelm ) , München 2012 , ISBN 978-3-7705-5382-2 Gesamtdarstellungen
+Ingemar Düring : Aristoteles .
+Darstellung und Interpretation seines Denkens .
+Winter , Heidelberg 1966 Hellmut Flashar : Aristoteles .
+In : Hellmut Flashar ( Hrsg. ) : Grundriss der Geschichte der Philosophie .
+Die Philosophie der Antike
+, Band 3 : Ältere Akademie , Aristoteles , Peripatos . 2. Auflage .
+Schwabe , Basel 2004 , ISBN 3-7965-1998-9 , S. 167–492 Hellmut Flashar : Aristoteles : Lehrer des Abendlandes , München : Beck , 2013 , ISBN 978-3-406-64506-8 William K. C. Guthrie : A History of Greek Philosophy . Bd. 6 : Aristotle .
+An Encounter .
+Cambridge University Press , Cambridge 1981 , ISBN 0-521-23573-1 ( sehr gut lesbar , aber nichts zur Logik ) John M. Rist : The Mind of Aristotle : A Study in Philosophical Growth .
+University of Toronto Press , Toronto 1989 , ISBN 0-8020-2692-3 ( behandelt die Entwicklung von Aristoteles ’ Denken ) William David Ross : Aristotle . 1956 ; 6. Auflage .
+Routledge , London 1995 , ISBN 0-415-32857-8 ( solide und ausführliche Darstellung , besonders für Naturphilosophie und Biologie wertvoll ) Kompendien
+Georgios Anagnostopoulos ( Hrsg. ) : A Companion to Aristotle .
+Wiley-Blackwell , Malden 2009 , ISBN 978-1-4051-2223-8 . Jonathan Barnes ( Hrsg. ) : The Cambridge Companion to Aristotle . Cambridge University Press , Cambridge 1995 , ISBN 0-521-41133-5 ( gute Einführung mit einer umfangreichen , thematisch gegliederten Bibliografie ) Hilfsmittel
+Otfried Höffe ( Hrsg. ) : Aristoteles-Lexikon ( = Kröners Taschenausgabe . Band 459 ) .
+Kröner , Stuttgart 2005 , ISBN 3-520-45901-9 ( Rezension ) .
+Rezeption Übersichts- und Gesamtdarstellungen
+Olof Gigon u. a. : Aristoteles / Aristotelismus .
+In : Theologische Realenzyklopädie . Band 3 , de Gruyter , Berlin 1978 , ISBN 3-11-007462-1 , S. 726–796 , hier : 760–796 . François Queyrel u. a. : Aristote de Stagire .
+In : Richard Goulet ( Hrsg. ) : Dictionnaire des philosophes antiques . Band Supplément , CNRS Éditions , Paris 2003 , ISBN 2-271-06175-X , S. 109–654 . Epochenübergreifende Untersuchungen zu einzelnen Themen
+Christoph Horn , Ada Neschke-Hentschke ( Hrsg. ) : Politischer Aristotelismus .
+Die Rezeption der aristotelischen Politik von der Antike bis zum 19. Jahrhundert
+.
+Metzler , Stuttgart 2008 , ISBN 978-3-476-02078-9 . Joachim Knape , Thomas Schirren ( Hrsg. ) : Aristotelische Rhetorik-Tradition .
+Franz Steiner , Stuttgart 2005 , ISBN 3-515-08595-5 . Cees Leijenhorst u. a. ( Hrsg. ) : The Dynamics of Aristotelian Natural Philosophy from Antiquity to the Seventeenth Century ( = Medieval and Early Modern Science , Band 5 ) .
+Brill , Leiden 2002 , ISBN 90-04-12240-0 Jürgen Wiesner ( Hrsg. ) : Aristoteles .
+Werk und Wirkung .
+Band 2 : Kommentierung , Überlieferung , Nachleben .
+De Gruyter , Berlin 1987 , ISBN 3-11-010976-X . Antike
+Andrea Falcon ( Hrsg. ) : Brill ’ s Companion to the Reception of Aristotle in Antiquity ( = Brill ’ s Companions to Classical Reception , Band 7 ) .
+Brill , Leiden 2016 , ISBN 978-90-04-26647-6 Paul Moraux : Der Aristotelismus bei den Griechen .
+3 Bände , de Gruyter , Berlin 1973–2001 . Richard Sorabji ( Hrsg. ) : Aristotle Transformed .
+The Ancient Commentators and Their Influence .
+2. , überarbeitete Auflage .
+Bloomsbury , London 2016 , ISBN 978-1-47258-907-1 Mittelalter
+Edward Grant : Das physikalische Weltbild des Mittelalters . Artemis , Zürich 1980 , ISBN 3-7608-0538-8 . Volker Honemann : Aristoteles . In : Die deutsche Literatur des Mittelalters .
+Verfasserlexikon
+.
+2. , neu bearbeitete Auflage , Band 1. De Gruyter , Berlin 1978 , ISBN 3-11-007264-5 , Sp. 436–450 . Ludger Honnefelder u. a. ( Hrsg. ) : Albertus Magnus und die Anfänge der Aristoteles-Rezeption im lateinischen Mittelalter . Aschendorff , Münster 2005 , ISBN 3-402-03993-1 . Neuzeit
+Fritz Mauthner : Aristoteles : Ein unhistorischer Essay . Berlin , 1904 ( Die Literatur .
+Sammlung illustrierter Einzeldarstellungen
+, hg. v. Georg Brandes , 2. Band ) Thomas Buchheim u. a. ( Hrsg. ) : Kann man heute noch etwas anfangen mit Aristoteles ? Meiner , Hamburg 2003 , ISBN 3-7873-1630-2 . Weblinks Über Aristoteles – Verzeichnis spezifischerer Einträge nach Themenfeldern ( PDF-Datei ; 38 kB ) Texte von Aristoteles Texte ( griechisch / englisch ) im Perseus Project Texte von Aristoteles ( englisch ) ( MIT Classics ) Anmerkungen Düring S. 9.Trampedach S. 66–79 . Düring S. 12 ; Flashar S. 217 ; Trampedach S. 52. 54–55 . Trampedach S. 53–54 . Wolfram Hoepfner : Platons Akademie . In : Wolfram Hoepfner ( Hrsg. ) : Antike Bibliotheken . Zabern , Mainz 2002 , S. 56–62 , hier : S. 62. Aelian : Varia Historia 3 , 36.Diogenes Laertios 5 , 1 , 11–16 . Cicero : Academica 2 , 119. „ Alle Menschen streben von Natur nach Wissen . “ ( Met. I 1 , 980a1 f. ) „ Jede Unterweisung und jedes verständige Erwerben von Wissen entsteht aus bereits vorhandener Kenntnis . “ ( An . post. I 1 , 71a1 f. ) „ Jedes Herstellungswissen und jedes wissenschaftliche Vorgehen , ebenso jedes Handeln und Vorhaben strebt , so die verbreitete Meinung , nach einem Gut . “ ( EN I 1 , 1094a1 f. ) „ Jeder staatliche Verband ist , wie wir sehen , eine Gemeinschaft von besonderer Art , und jede Gemeinschaft bildet sich , um ein Gut von besonderer Art zu verwirklichen – denn alle Menschen vollziehen alle Handlungen um eines Zweckes willen , nämlich um das zu erreichen , was ihnen als gut erscheint . “ ( Pol. I 1 , 1252a1–3 ) . Hermann Weidemann : Aristoteles . Peri Hermeneias . Berlin 2002 , S. 134. Für materielle Gegenstände verwendet Aristoteles noch einen weiteren wichtigen Definitionstyp , der die ( später behandelte ) Form-Materie-Unterscheidung zugrunde legt und ontologisch ist . Demgemäß ist beispielsweise ein Haus definiert als eine auf bestimmte Weise strukturierte Anordnung von Holz und Ziegeln ( Met. VIII 3 , 1043a31 f. ) . So sagt er , dass man „ eine Induktion durchführt dadurch , dass die einzelnen Dinge klar sind – dass alles so ist dadurch , dass nichts anders ist “ ( An . Post . II 5 , 92a37 f. ) . Detel erläutert : „ Nach dieser Bemerkung weist die Induktion einen Allsatz dadurch nach , daß sie sämtliche Einzelinstanzen durchgeht und zeigt , daß es unter ihnen keine Gegeninstanzen gibt . “ Detel 1993 I , S. 251.Z . B. „ Ist ‚ zweibeiniges , sich zu Lande bewegendes Lebewesen ‘ die Definition des Menschen oder nicht ? “ Top. I 4 , 101b28–31Es gibt Ausnahmen ( z. B. wenn die Frage mehrdeutig ist ) , für die es Regeln gibt , Top. VIII.Aristoteles definiert das Enthymem als Deduktion ; allerdings sagt er von einem Sonderfall des Enthymems , er sei keine Deduktion.Hier sind charakterliche Dispositionen ( z. B. kann nur der zürnen , der über entsprechende Selbstachtung verfügt ; siehe 1387b13 f. ) und physiologische Voraussetzungen relevant . ( Rapp ( 2002 ) II , 559–570 , 582 f. ) Ein drittes Verfahren , die sogenannte êkthesis , wendet er selten an , und dann ausschließlich in der dritten Figur . Die Namen geben Aufschluss über die Form sowie gegebenenfalls darüber , wie sie bewiesen werden können . Barbara weist beispielsweise nur zusprechende , allgemeine Verbindungen auf . Kunst ( téchnē ) ( =p roduktives Wissen ) : Kunst als herstellende Erkenntnis unterscheidet sich vom Wissen insofern , als sich ihre Gegenstände auch anders verhalten können . Andere für Aristoteles unbeweisbare Sätze sind spezifische Grundlagen einzelner Wissenschaften . Diese hält er für nicht problematisch ( beispielsweise , dass die Geometrie die Existenz von Punkten oder die Biologie die von Lebewesen mit bestimmten Eigenschaften voraussetzt ) . Wobei die neuzeitlichen Kritiker einen ähnlichen Typ favorisierten wie den , den sie bei Aristoteles annahmen und verwarfen . Für eine Ausnahme einer materielosen Form siehe Theologie Es ist umstritten , ob Aristoteles eine völlig unbestimmte Materie annimmt , die sogenannte prima materia . Siehe hierzu William Charlton : Aristotle . Physics Books I and II . Oxford 1970 , S. 129–145 . Das Wort Ousia , Partizip zu ‚ sein ‘ , wörtlich : „ Seiendheit “ wird meist mit ‚ Substanz ‘ übersetzt . Mag ‚ Substanz ‘ noch für die Theorie der Kategorien adäquat sein , so ist dieser Ausdruck für die Metaphysik irreführend und problematisch . „ Der entscheidende Nachteil der geläufigen Übersetzung ‚ Substanz ‘ ist , dass damit eine bestimmte Konzeption der ousia assoziiert wird , nämlich die der Kategorien , wonach das konkrete Einzelding als Träger wechselnder Eigenschaften die eigentliche Substanz ist . “ ( Christof Rapp , in : Rapp ( 1996 ) S. 8) . Siehe auch Vasilis Politis : Aristotle and the Metaphysics . New York 2004 , S. 12 ; 192. Der Ausdruck taucht in dieser Bedeutung auch schon bei Platon auf ( Christoph Horn , Christof Rapp : ousia . In : dies . : Wörterbuch der antiken Philosophie . München 2002 , S. 320–321 ) . Aristoteles geht davon aus , dass der Sache nach schon die Vorsokratiker die Frage : „ Was ist die ‚ ousia ‘ ? “ gestellt haben . „ Was in der Philosophiegeschichtsschreibung als Platonische ‚ Idee ‘ bezeichnet wird , nennt Platon [ … ] unter anderem idea , morphê , eidos [ ! ] oder zusammenhangsabhängig auch genos und sogar usia [ ! ] sowie physis . “ Christian Schäfer : Idee / Form / Gestalt / Wesen . In : ders. : Platon-Lexikon . Darmstadt 2007 , S. 157. Der Übersicht halber diese etwas technische Schreibweise : Substanz-X = Substanz-von etwas . Ähnlich Rapp 2001 , S. 160. Die entsprechende Unterscheidung wird auch in Metaphysik V 8 gemacht , wo Aristoteles den Begriff Substanz in seinem ‚ Begriffslexikon ‘ erläutert . Es wird allerdings kontrovers diskutiert , ob die Substanz-Theorie der Metaphysik und diejenige der Kategorien kompatibel sind , und auch ob die Theorie der Metaphysik die der Kategorien eher ergänzen oder ersetzen soll . Dass mit eidos Aristoteles sowohl die Art wie auch die Form bezeichnet , hat zu zahlreichen interpretatorischen Schwierigkeiten geführt , insbesondere zum Verhältnis der Theorie der Kategorien ( in der eidos ( als Art ) zweite Substanz ist ) zu der der Metaphysik ( in der eidos ( als Form ) Substanz-X ist und erste Substanz genannt wird ) . Eine gute Darstellung dieser Kontroverse bei Steinfath , 43.Einen guten Überblick über die Problemlage bietet Marc Cohen : Aristotle ’ s Metaphysics . In : Edward N. Zalta ( Hrsg. ) : The Stanford Encyclopedia of Philosophy . ( Winter 2003 Edition ) , § 10 : Substance and Universals . Die drei wesentlichen Positionen , die von einer konsistenten Theorie ausgehen , stellt Christof Rapp in der Einleitung des von ihm herausgegebenen Bands Aristoteles . Metaphysik , Die Substanzbücher ( Ζ , Η , Θ ) , Berlin 1996 , S. 22 ff. , dar . Vermögen hat für Aristoteles verschiedene Bedeutungen . Die Grundbedeutung von Vermögen betrifft Veränderung . Hierbei gibt es ( i ) ein aktives Vermögen , etwas zu tun , und ( ii ) ein passives , etwas zu erleiden ( Met. V 12 , 1019b35 ff. ; IX 1 , 1046a4 f. ) . Beispielsweise besitzt der Baumeister das Vermögen , bestimmte Bauteile so anzuordnen , dass daraus ein Haus entsteht , und zugleich besitzen bestimmte Bauteile das Vermögen , zu einem Haus angeordnet zu werden . ( iii ) Die ontologische Potentialität ist demgegenüber das Vermögen , etwas zu sein . Zitiert nach Jonathan Barnes : Aristoteles . Stuttgart 1992 , S. 21. Wolfgang Kullmann : Aristoteles und die moderne Wissenschaft . Stuttgart 1998 , S. 284. „ Aristoteles ’ Anschauungen stimmen auch mit der entscheidenden These der modernen Molekularbiologie zusammen , dass – in der Sprache Monods formuliert – die invariante Reproduktion der Arten aufgrund teleonomischer Information nach streng kausalen , „ technischen “ , genauer nach chemischen Gesetzmässigkeiten abläuft . Durch die Entdeckung der unterschiedlichen Funktion der Nukleinsäuren einerseits , die die genetische Invarianz verbürgen , und der Proteine , die für die teleonomischen Strukturen und Leistungen verantwortlich sind , andererseits , erweist sich , dass die aristotelische Vorstellung einer programmierten zielgerichteten Epigenesis in ihrem wesentlichen Kern der Realität näher kommt als manche andere Theorie neueren Datums “ , Wolfgang Kullmann : Die Teleologie in der aristotelischen Biologie : Aristoteles als Zoologe , Embryologe und Genetiker . Heidelberg 1979 , S. 61.In einer in ihrer Bedeutung stark umstrittenen Passage spricht er allerdings von einer unsterblichen Vernunft , „ die alles bewirkt “ ( An . III 5 , 430a15 ) . Ob damit Aristoteles etwa in die Nähe des Funktionalismus der heutigen Philosophie des Geistes gerückt werden kann , ist strittig . Myles Burnyeat etwa bezweifelt dies , da Aristoteles ’ und unser Materiebegriff nicht kompatibel sei ; Hilary Putnam und Martha C. Nussbaum argumentieren dafür . Siehe Myles F. Burnyeat : Is an Aristotelean Philosophy of Mind Still Credible ? A Draft und Martha C. Nussbaum , Hilary Putnam : Changing Aristotle ’ s Mind , beide in : Martha C. Nussbaum , Amélie Oksenberg Rorty : Essays on Aristotle ’ s „ De anima “ , Oxford 1992 . Putnam allerdings hat seine Position zur aristotelischen Seelenlehre mehrmals geändert . Philipp Brüllmann , Katharina Fischer : mêson . In : Otfried Höffe ( Hrsg. ) : Aristoteles-Lexikon . Stuttgart 2005 , S. 346.Dies ist eine Auswahl der von Aristoteles behandelten Charaktertugenden . Eine vollständige Übersicht bei Wolf , S. 79–80 . Die Nikomachische Ethik weist in Buch VII und X zwei Lustabhandlungen mit zwei Definitionen auf . Siehe dazu Ottmann , S. 179–183 ; C. C. W. Taylor in : Barnes ( 1995 ) , S. 254–257 . Wolfgang Schadewaldt : Furcht und Mitleid ? Zur Deutung des aristotelischen Tragödiensatzes . In : Hermes . 83 ( 1955 ) , S. 129–171 . William D. Furley , Jan Maarten Bremer : Greek Hymns II . Greek Texts and Commentary . Tübingen 2001 , S. 221–228 . Fritz W. Zimmermann : The Origins of the So-called Theology of Aristotle . In : Jill Kraye u. a. ( Hrsg. ) : Pseudo-Aristotle in the Middle Ages : the Theology and Other Texts . London 1986 , S. 110–240 . Siehe Eckhard Keßler : Etappen der Entstehung des lateinischen Aristoteles . Zur franziskanischen Aristoteleskritik siehe Kurt Flasch : Aristoteleskritik im Mittelalter . In : Arbogast Schmitt , Gyburg Radke-Uhlmann ( Hrsg. ) : Philosophie im Umbruch . Stuttgart 2009 , S. 65–77 , hier : 65–69 . Dante Alighieri : Die Göttliche Komödie . Inferno 4 , 131–133 . Elisabeth von Roon-Bassermann : Dante und Aristoteles . Freiburg 1956 , S. 1–21 , 27 ff . Zur Aristoteles-Rezeption des Cusanus siehe Flasch ( 2009 ) S. 71–77 . Gotthard Strohmaier : Avicenna . Beck , München 1999 , ISBN 3-406-41946-1 , S. 118 f. James G. Lennox : Aristotle ’ s Philosophy of Biology . Cambridge 2001 , S. 218 f. Allan Gotthelf : From Aristotle to Darwin . In : Carlos Steel u. a. ( Hrsg. ) : Aristotle ’ s Animals in the Middle Ages and Renaissance . Leuven 1999 , S. 398. „ Im Übrigen ist wohl noch nie so vielfältig und weltweit über Aristoteles gearbeitet worden wie gegenwärtig “ , Flashar ( 2004 ) S. 177. E. J. Lowe : The Four-Category Ontology : A Metaphysical Foundation for Natural Science , Oxford University Press 2007 , sowie die Rezension von Ryan Wasserman hierzu . Barry Smith : ( PDF ; 108 kB ) , In : Th. Buchheim , H. Flashar , R. A. H. King ( Hrsg. ) : Kann man heute noch etwas anfangen mit Aristoteles ? Meiner , Hamburg 2003 , S. 3–38 . 
+
+Datei : Abraham Lincoln head on shoulders photo portrait.jpg Abraham Lincoln ( * 12. Februar 1809 bei Hodgenville , Hardin County , heute : LaRue County , Kentucky ; † 15. April 1865 in Washington , D. C. ) amtierte von 1861 bis 1865 als 16. Präsident der Vereinigten Staaten von Amerika .
+Er war der erste aus den Reihen der Republikanischen Partei und der erste , der einem Attentat zum Opfer fiel .
+1860 gewählt , gelang ihm 1864 die Wiederwahl .
+Seine Präsidentschaft gilt als eine der bedeutendsten in der Geschichte der Vereinigten Staaten : Die Wahl des Sklavereigegners veranlasste zunächst sieben , später weitere vier der sklavenhaltenden Südstaaten , aus der Union auszutreten und einen eigenen Staatenbund , die Konföderierten Staaten von Amerika , zu bilden .
+Lincoln führte die verbliebenen Nordstaaten durch den daraus entstandenen Sezessionskrieg .
+Er setzte die Wiederherstellung der Union durch und betrieb erfolgreich die Abschaffung der Sklaverei in den USA .
+Unter seiner Regierung schlug das Land den Weg zum zentral regierten , modernen Industriestaat ein und schuf so die Basis für seinen Aufstieg zur Weltmacht im 20. Jahrhundert .
+Leben Datei : Abe-Lincoln-Birthplace-2.jpg Datei : Thomas Hicks - Leopold Grozelier - Presidential Candidate Abraham Lincoln 1860 ( cropped ) . jpg
+Kindheit und Jugend Abraham Lincoln wurde in einer Blockhütte auf der Sinking Spring Farm nahe dem Dorf Hodgenville in Kentucky geboren .
+Seine Eltern waren der Farmer Thomas Lincoln und dessen Frau Nancy , die beide aus Virginia stammten .
+Thomas Lincolns Vorfahren waren einige Generationen zuvor aus der ostenglischen Grafschaft Norfolk nach Amerika ausgewandert .
+Zu seiner Familie gehörten noch Abrahams ältere Schwester Sarah sowie ein jüngerer Bruder Thomas jr. , der aber schon kurz nach der Geburt starb .
+Als frommer Baptist lehnte Lincolns Vater die in Kentucky erlaubte Sklaverei ab , obwohl einige seiner Verwandten Sklavenhalter waren .
+Ende 1816 zog er mit seiner Familie nach Little Pigeon Creek im Südwesten des sklavenfreien Staats Indiana . Zwei Jahre später starb seine Frau Nancy an der so genannten „ Milchkrankheit “ . 1819 heiratete Thomas Lincoln die Witwe Sarah Bush Johnston , die drei eigene Kinder in die Ehe mitbrachte .
+Abraham Lincoln pflegte zu seiner Stiefmutter zeitlebens eine warmherzige Beziehung – auch , weil sie , anders als sein Vater , sein Streben nach Bildung unterstützte .
+Die Bildungsmöglichkeiten an der Frontier , der Siedlungsgrenze zur Wildnis , waren äußerst begrenzt .
+Auch in der Region von Indiana , in der die Lincolns damals lebten , gab es nur sporadisch betriebene Einraum-Schulen in Blockhütten , in denen die Kinder aller Jahrgänge gemeinsam unterrichtet wurden .
+Viel mehr als Grundkenntnisse im Lesen , Schreiben und Rechnen wurde dort nicht vermittelt .
+Die Schüler lernten meist durch gemeinsames Rezitieren .
+Selbst diese Art des Unterrichts hat Lincoln nur sehr unregelmäßig genossen .
+Von 1816 bis 1827 hat er zwar verschiedene Schulen in und um das heutige Cannelton besucht , zwischen seinem 11. und seinem 15. Lebensjahr aber nicht länger als insgesamt ein Jahr . Seine umfassende Bildung hat er sich vor allem als Autodidakt angeeignet . Der junge Lincoln war lesehungrig und verschlang jedes Buch , dessen er habhaft werden konnte .
+Neben der King-James-Bibel beeinflussten ihn vor allem die Dramen William Shakespeares sowie Werke von Homer , Vergil , John Dryden , John Milton und Daniel Defoe . Seine Belesenheit und Gewandtheit im Ausdruck wurden bald im näheren Umkreis bekannt , so dass Nachbarn ihn schon als Jugendlichen baten , Briefe für sie aufzusetzen .
+Im Wesentlichen aber bestand Lincolns Leben damals aus der harten und ungeliebten Farmarbeit mit seinem Vater .
+Thomas Lincoln lieh seinen Sohn gegen Bezahlung auch an Nachbarn aus , wenn diese Unterstützung benötigten .
+Bis zu seinem 19. Lebensjahr teilte Abraham Lincoln das Pionierdasein seiner Familie in Indiana .
+1830 zogen die Lincolns erneut weiter nach Westen , ins Macon County in Illinois .
+Kurz darauf verließ Abraham das Elternhaus und ließ sich im Präriestädtchen New Salem , im benachbarten Sangamon County nieder , wo er eine Stelle als Kaufmannsgehilfe annahm .
+In den nächsten Jahren war er dort auch als Landvermesser und Posthalter tätig .
+In seiner Freizeit betätigte er sich damals als Ringer .
+Er war 1830 Meister in seinem County und musste in den folgenden zehn Jahren nur eine Niederlage hinnehmen . Das städtische Amerika lernte er erstmals im Jahr 1831 kennen , in dem er als Flößer auf dem Ohio und dem Mississippi flussabwärts bis nach New Orleans fuhr .
+Lincolns Aufstieg Im Jahr 1832 nahm Lincoln als Freiwilliger am Kriegszug gegen die Sauk-Indianer unter Häuptling Black Hawk teil , ohne aber in Kämpfe verwickelt zu werden .
+Seine Kameraden wählten ihn bei dieser Gelegenheit zum Captain .
+Dies und die Tatsache , dass er sich in einem Debattierclub in New Salem als guter Redner erwiesen hatte , ermutigten ihn , noch im selben Jahr für das Repräsentantenhaus von Illinois zu kandidieren .
+Als Parteigänger der Whigs trat er im Wahlkampf für den Ausbau der Verkehrswege und eine Verbesserung des Schulwesens ein .
+Im ersten Anlauf scheiterte Lincoln , aber 1834 errang er das Mandat , das er über vier Legislaturperioden bis 1842 behalten sollte .
+Parlamentarier und Anwalt in Illinois Datei : Lincoln Home 1.jpg Das Staatsparlament von Illinois hatte bis 1839 seinen Sitz in der ersten Landeshauptstadt Vandalia .
+Als Honest Abe – ehrlicher Abe – , ein Spitzname , der ihm bleiben sollte , erwarb sich Abraham Lincoln dort rasch so viel Vertrauen , dass er zum Sprecher des Finanzausschusses und bereits mit 27 Jahren zum Parteiführer der oppositionellen Whigs gewählt wurde .
+Aus dem Jahr 1837 datiert seine erste öffentliche Stellungnahme gegen die Sklaverei .
+In einer Parlamentsdebatte stellte er fest , „ dass die Institution der Sklaverei auf Ungerechtigkeit und schlechte Politik zurückzuführen ist “ .
+In den ersten Jahren seiner politischen Tätigkeit absolvierte Lincoln ein diszipliniertes Selbststudium der Rechtswissenschaften ; 1836 wurde er zur Anwaltskammer von Illinois zugelassen .
+Im folgenden Jahr gründete er mit dem Rechtsanwalt John T. Stuart eine gemeinsame Kanzlei in der neuen Hauptstadt von Illinois , Springfield .
+Doch auch als Anwalt lebte Lincoln noch lange in äußerst bescheidenen Verhältnissen .
+Während seiner Zeit in Springfield näherte sich Lincoln den Freimaurern an , die damals hohes Ansehen genossen .
+Obwohl er der Vereinigung wohlwollend gegenüberstand , wurde er jedoch nie – wie später irrtümlich behauptet – ihr Mitglied . Kurz vor seiner Wahl zum Präsidenten zog er ein Gesuch um Aufnahme in die Tyrian Lodge No. 333 in Springfield zurück , weil er diesen Schritt nicht als Wahlkampftaktik missverstanden sehen wollte .
+Familiengründung Datei : MaryToddLincoln.jpeg Im Jahr 1842 heiratete Abraham Lincoln Mary Todd , die einer reichen Familie von Pflanzern und Sklavenhaltern aus Kentucky entstammte .
+Bei den Todds stieß diese Verbindung auf erheblichen Widerstand , da Lincoln nur wenig Vermögen besaß und seine politischen Ansichten den ihren weitgehend widersprachen .
+Ein Verwandter Mary Lincolns , ihr Schwager Benjamin Hardin Helm , stieg im Sezessionskrieg sogar zum General der konföderierten Armee auf .
+Er fiel später in der Schlacht am Chickamauga .
+Abraham und Mary Lincoln wurden vier Söhne geboren : Robert Todd Lincoln ( * 1. August 1843 in Springfield , Illinois ; † 26. Juli 1926 in Manchester , Vermont ) Edward „ Eddie “ Baker Lincoln ( * 10. März 1846 in Springfield , Illinois ; † 1. Februar 1850 ebenda ) William „ Willie “ Wallace Lincoln ( * 21. Dezember 1850 in Springfield , Illinois ; † 20. Februar 1862 in Washington , D. C. ) Thomas „ Tad “ Lincoln ( * 4. April 1853 in Springfield , Illinois ; † 16. Juli 1871 in Chicago , Illinois ) .
+Zwei Kinder starben also bereits zu Lincolns Lebzeiten , und nur Robert erreichte das Erwachsenenalter .
+Wie sein Vater schlug er eine Karriere als Anwalt und Politiker ein und war von 1881 bis 1885 US-Kriegsminister .
+Der letzte direkte Nachfahre Abraham Lincolns , Robert Todd Lincoln Beckwith , ein Urenkel , starb 1985 im Alter von 81 Jahren .
+Abgeordneter im Repräsentantenhaus Im Jahr seiner Heirat schied Lincoln aus dem Staatsparlament von Illinois aus , um sich verstärkt seiner Anwaltstätigkeit zu widmen .
+Er erwarb sich einen Ruf als Spezialist für Eisenbahnrecht und kam allmählich zu bescheidenem Wohlstand .
+1842 bemüht sich Lincoln vergebens darum , bei den Wahlen zum Repräsentantenhaus als Kandidat der Whigs aufgestellt zu werden .
+Er führte sein Scheitern darauf zurück , dass er keiner Kirche angehörte und sich am 22. September mit dem demokratischen Politiker James Shields ein Duell mit Korbschwertern geliefert zu haben , auch wenn dabei niemand verletzt worden war .
+Als einer der führenden Köpfe der Whigs in dem jungen Bundesstaat wurde Lincoln dann 1846 ins Repräsentantenhaus gewählt .
+In Washington trat er als Gegner von Präsident James K. Polk und seiner Kriegspolitik gegen Mexiko auf .
+So forderte er Polk , der den Krieg als Akt der Selbstverteidigung darstellte , in mehreren Resolutionen dazu auf , den genauen Punkt ( englisch : spot ) zu benennen , an dem die mexikanische Armee in US-Territorium eingedrungen sei . Diese von Polk ignorierten Anträge wurden als Spot Resolutions bekannt , während Lincoln selbst wegen seiner Kriegsgegnerschaft von der Mehrheit der Presse angegriffen und als spotty Lincoln verhöhnt wurde .
+Er ging jedoch nicht so weit , der Streichung der Geldmittel für die Armee zuzustimmen . Im Januar 1849 brachte er eine Resolution zur Beschränkung der Sklaverei im District of Columbia ein .
+Ansonsten machte er bei seinem ersten Auftreten in der Bundespolitik kaum von sich reden .
+Für Lincoln war es wichtig , im engen Kontakt zu seinen Wählern zu bleiben , den er durch seine Tätigkeit als Anwalt aufgebaut hatte .
+Ein Angebot , als Partner in eine Kanzlei in Chicago einzusteigen , schlug er daher aus . Da er in Washington ohne seine Familie lebte , reizte ihn auch eine Karriere in der Bundeshauptstadt wenig .
+Der 1849 ins Amt gelangte Präsident Zachary Taylor bot ihm an , Gouverneur des neuen Territoriums Oregon zu werden , das die heutigen Staaten Oregon , Washington und Idaho sowie Teile Montanas und Wyomings einschloss .
+Aber auch dies schlug er aus und kehrte 1849 nach Springfield zurück .
+Für die nächsten fünf Jahre verabschiedete sich Abraham Lincoln aus der Politik .
+Erst die Verschärfung des Konflikts zwischen Befürwortern und Gegnern der Sklaverei brachte ihn auf die politische Bühne zurück .
+Weg zur Präsidentschaft Um zu verstehen , wie Abraham Lincoln von einer kaum über Illinois hinaus bekannten Parteigröße zu einem in ganz Amerika beachteten Politiker und schließlich zum Präsidentschaftskandidaten der neuen Republikanischen Partei werden konnte , muss man die Entwicklung der Sklavenfrage und Lincolns Haltung dazu betrachten .
+Gegensätze zwischen Nord und Süd Gesellschaftlich , kulturell und wirtschaftlich unterschieden sich der Norden und der Süden der USA in wesentlichen Punkten .
+Sie bildeten völlig gegensätzlichen Wirtschaftssysteme aus , deren Interessen sich im Laufe des 19. Jahrhunderts immer schwerer miteinander vereinbaren ließen .
+Der Süden , als Agrarland auf die Ausfuhr von Baumwolle , Tabak und anderen Plantagenprodukten angewiesen , verfocht eine Freihandelspolitik , worin er von Großbritannien unterstützt wurde .
+Der Norden , der seine noch junge Industrie vor der Einfuhr von Massenprodukten aus England schützen wollte , trat für möglichst hohe Schutzzölle ein .
+Die Partei der Whigs – insbesondere deren Gründer Henry Clay , den Lincoln als sein Vorbild ansah – forderten wie später auch die Republikaner eine starke Zentralmacht , eine Nationalbank sowie Bundesausgaben zur Verbesserung der zwischenstaatlichen Infrastruktur , etwa durch den Bau von Fernstraßen und Kanälen .
+Nicht zuletzt befürworteten sie das Prinzip der freien Arbeit in den neu zu besiedelnden Gebieten des Westens .
+Die im Süden traditionell starke Demokratische Partei dagegen lehnte all das ab und war für eine weitgehende Autonomie der Einzelstaaten .
+Dies schloss auch das Recht neuer Staaten ein , auf ihrem Gebiet die Sklaverei zu gestatten .
+Trotz seiner geringeren Bevölkerungszahl nahm der Süden mit seiner reichen Pflanzeraristokratie bis zum Bürgerkrieg die politisch und gesellschaftlich führende Rolle innerhalb der USA ein .
+So kamen zum Beispiel die meisten Präsidenten aus den Sklavenstaaten .
+Zudem wog die Stimme eines weißen Südstaatlers bei Wahlen ungleich schwerer als die eines Nordstaatlers .
+Denn die Anzahl der Abgeordneten , die ein Staat ins Repräsentantenhaus entsenden durfte , hing von seiner Einwohnerstärke ab .
+Jedem der Südstaaten aber wurde die Zahl der dort lebenden afroamerikanischen Sklaven zu drei Fünfteln angerechnet , obwohl diesen selbst das Wahlrecht verwehrt war .
+Seit Beginn des 19. Jahrhunderts schritten Industrialisierung und Bevölkerungswachstum im Norden zwar rasch voran , so dass sich das wirtschaftliche Gewicht immer mehr zu seinen Gunsten verschob .
+Gleichzeitig aber gewannen die Stimmen der Südstaatler im Kongress an Gewicht , da die Anzahl ihrer Sklaven zwischen 1780 und 1860 von 500.000 auf 4 Millionen anstieg . Der wesentliche Grund dafür , dass sich die Sklaverei trotz des seit 1808 geltenden , offiziellen Verbots des Sklavenhandels auf dem Vormarsch befand , war der anhaltende Boom der amerikanischen Baumwollwirtschaft .
+Datei :C otton gin harpers.jpg In den frühen Jahren der Republik hatten sogar viele Politiker aus den Südstaaten , die – wie George Washington oder Thomas Jefferson – selbst Sklavenhalter waren , an eine allmähliche Abschaffung oder ein Absterben der Sklaverei gedacht .
+Im Jahr 1793 jedoch erfand Eli Whitney die Cotton Gin , eine Maschine , die die Fasern der Baumwolle von ihren Samenkapseln trennt .
+Sie steigerte die Effizienz der Entkörnung um das 50fache und machte den Baumwollanbau im großen Stil – und damit auch den Einsatz von Sklaven – profitabler denn je .
+Zwischen 1790 und 1820 stieg der Baumwollexport allein nach England um mehr als das Hundertfache an , von 700.000 auf 76 Millionen Kilogramm .
+Da Baumwolle den Boden stark auslaugt , werden nach einigen Jahren neue Anbauflächen benötigt .
+Anders als alle übrigen Baumwollproduzenten weltweit verfügten die Südstaatler aber nahezu unbegrenzt über Land , Arbeitskräfte und Kapital – wegen der von Weißen noch unbesiedelten Gebiete im Westen , der Sklaverei und finanzstarken Kreditgebern im Norden .
+So beherrschten die USA 1860 dank King Cotton ( König Baumwolle ) den weltweiten Baumwollmarkt .
+In den ersten 50 Jahren nach der Gründung der USA hatte die Sklavenfrage in der Innenpolitik nur eine untergeordnete Rolle gespielt .
+Mit der Ausweitung der Sklaverei wuchs aber auch der Widerstand dagegen .
+Viele Nordstaatler lehnten sie aus wirtschaftlichen Gründen ab , so etwa die bäuerlichen Anhänger der Free Soil Party , die sich von Seiten der südstaalichen Pflanzer einem unfairen Wettbewerb um Land und billige Arbeitskraft ausgesetzt sahen .
+Ähnlich argumentierte der südstaatliche Autor Hinton Rowan Helper in seinem Bestseller The Impending Crisis of the South ( Die drohende Krise des Südens ) , in dem er die Sklaverei als Hemmnis für der ökonomische Entwicklung darstellte .
+Seit den 1830er entstanden im Norden zudem publizistisch einflussreiche Vereinigungen von Abolitionisten , die die Sklaverei grundsätzlich ablehnten .
+Die einen – wie etwa der Journalist William Lloyd Garrison – forderten aus religiös-moralischen , die anderen – wie der entflohene Sklave Frederick Douglass – aus prinzipiellen Erwägungen heraus die Abschaffung der peculiar institution ( der „ besonderen Einrichtung “ ) , wie die Sklaverei in der US-Verfassung verbrämend genannt wurde .
+Sie unterstützten die Bildung von Anti-Sklaverei-Wahlblöcken , die seit den 1840er Jahren immer mehr abolitionistisch gesinnte Politiker nach Washington brachten .
+Abgeordnete wie John Quincy Adams , Thaddeus Stevens oder Charles Sumner widersetzten sich Regelungen , die bis dahin verhindert hatten , dass das Sklaverei-Thema im Kongress auch nur erörtert wurde und setzten dieses endgültig auf die politische Agenda .
+Ihnen traten Südstaaten-Politiker wie der ehemalige Vize-Präsident und Senator von South Carolina , John C. Calhoun , entgegen .
+Er sah in der Sklaverei ein „ positives Gut “ , da die " Negerrasse " von Natur aus zum dienen bestimmt sei und es den Afroamerikanern in Gefangenschaft besser gehe als in Freiheit . Den gewaltlosen Aktionen der Abolitionisten schlug im Süden – und nicht nur dort – verstärkt Hass und Gewalt entgegen .
+In Lincolns Heimatstaat Illinois ermordeten 1837 fanatische Sklavereibefürworter den abolitionistischen Prediger Elijah P. Lovejoy .
+Er war der erste weiße Amerikaner , der wegen des Streits um die Sklavenfrage getötet wurde .
+Zuspitzung der Sklavenfrage Datei : Kansas-Nebraska Act.jpg Freie und Sklavenstaaten waren zunehmend darauf bedacht , gegenüber der jeweils anderen Seite im Senat nicht in die Minderheit zu geraten .
+Dieses Problem stellte sich jedes Mal neu , wenn ein weiterer Staat in die Union aufgenommen werden sollte .
+So wurden beispielsweise die Präsidentschaftwahlen von 1844 von der Frage dominiert , ob Texas als Sklavenstaat annektiert werden solle oder nicht .
+Eine erste Zuspitzung des Konflikts hatte 1820 durch den Missouri-Kompromiss entschärft werden können .
+Er sah vor , dass die Sklaverei nördlich der Mason-Dixon-Linie , die auf etwa 36 ° 30 ′ nördlicher Breite verlief , in allen neuen Staaten mit Ausnahme Missouris verboten sein solle .
+Infolge der großen Landgewinne , die die USA 1848 im Mexikanisch-Amerikanischen Krieg südlich dieser Linie gemacht hatten , drohte sich das Gleichgewicht erneut zugunsten des Südens zu verschieben .
+Das sogenannte Wilmot Proviso , nach dem die Sklaverei in den eroberten Gebieten verboten werden sollte , erlangte nie Gesetzeskraft .
+Mit dem Kompromiss von 1850 aber gelang es dem Kongress ein letztes Mal , die Gegensätze auszugleichen : Einerseits stimmte er dem Fugitive Slave Act zu , der freie Staaten verpflichtete , entflohene Sklaven auszuliefern , andererseits bestimmte er , dass Kalifornien der Union als sklavenfreier Staat beitreten sollte .
+Am 30. Mai 1854 jedoch verabschiedete der Kongress auf Antrag des demokratischen Senators Stephen A. Douglas , eines späteren politischen Gegners Lincolns , den Kansas-Nebraska Act .
+Dieses Gesetz stellte es den beiden Territorien – obwohl nördlich der Mason-Dixon-Linie gelegen – frei , in ihren künftigen Staatsverfassungen selbst festzulegen , ob sie die Sklaverei gestatten oder nicht .
+Daraufhin brach in Bleeding Kansas , dem blutenden Kansas , ein „ Bürgerkrieg vor dem Bürgerkrieg “ aus .
+In ihm bekämpften sich Sklavereibefürworter und Anhänger der Free-Soil-Bewegung , die für das Prinzip der freien Arbeit auf freiem Land eintraten .
+Das innenpolitische Klima in den USA verschärfte sich nach der Verabschiedung des Gesetzes in einem Maße , das ausgleichende Debatten und Kompromisse kaum noch möglich machten .
+Auf beiden Seiten nahmen irrationale Ängste zu , und Verschwörungstheorien wurde zunehmend Glauben geschenkt . Der einflussreiche Senator John C. Calhoun hatte bereits vor 1850 die Ansicht verbreitet , die Befreiung der Sklaven werde zum Rassenkrieg und zur Vernichtung der Union führen .
+Er und andere Apologeten der Sklaverei sahen in ihr nicht länger ein unvermeidliches Übel , sondern eine für Herren wie Sklaven positive Einrichtung , die es unbedingt zu schützen gälte .
+George Fitzhugh , ein in den 1850er Jahren vielbeachteter und auch von Lincoln gelesener Autor ging sogar noch weiter .
+Er forderte , dass außer den schwarzen auch die weißen Arbeiter versklavt werden sollten . Viele Demokraten argumentierten in Wahlkämpfen unverhohlen rassistisch , versuchten ihre Gegner als " schwarze Republikaner " zu verunglimpfen und setzten die Befreiung der Afroamerikaner mit " Rassenmischung " und " freier Liebe " gleich . Ein Argument , dem Lincoln mit der Aussage begegnete : " Ich kann nicht nachvollziehen , warum ich , weil ich keine Negerin als Sklavin haben will , sie unbedingt als Ehefrau wollen sollte . "
+Datei : John Brown portrait , 1859.jpg Weiter vertieft wurden die Gegensätze zwischen Nord und Süd 1857 durch das Urteil des Obersten Gerichtshofs im Fall Dred Scott versus Sandford .
+In der Urteilsbegründung stellte Chief Justice Roger B. Taney fest , dass Afroamerikanern grundsätzlich keine Bürgerrechte in den USA zustünden .
+Auch Sklaven , die in den freien Staaten und Territorien des Nordens lebten , würden dadurch nicht frei .
+Das Gericht stärkte damit die Rechte der Sklavenhalter auf ihr „ Eigentum “ , indem es das Recht des Kongresses bestritt , die Sklaverei in irgendeinem Staat oder Territorium zu verbieten . Sowohl mit dem Kansas-Nebraska-Gesetz als auch mit dem Urteil zu Ungunsten des Sklaven Dred Scott wurde der Missouri-Kompromiss faktisch aufgehoben .
+Dies löste im Norden eine Welle der Empörung aus .
+Eine letzte , entscheidende Verschärfung erfuhr der Konflikt am 16. Oktober 1859 , als eine Gruppe radikaler Abolitionisten unter Führung von John Brown das Waffendepot der US-Armee in Harpers Ferry in Virginia überfiel .
+Ihr Ziel war es , Sklaven mit den erbeuteten Waffen auszurüsten und einen Befreiungskrieg im Süden zu führen .
+Der schlecht geplante Aufstand scheiterte von Beginn an .
+Browns Truppe wurde von virginischen Milizsoldaten , die der spätere Konföderiertengeneral Robert E. Lee anführte , aufgerieben und er selbst noch im Dezember desselben Jahres hingerichtet .
+Im Süden als Terrorist , im Norden von vielen als Freiheitsheld betrachtet , galt Brown nach einem Wort von Herman Melville als „ Meteor des Krieges “ , der nur 18 Monate nach der Aktion von Harpers Ferry ausbrach .
+Eine ihrer Folgen war , dass Virginia seine Miliztruppe zu einer professionellen Armee ausbaute und dass die Präsidentschaftswahl von 1860 ganz im Zeichen der Sklavenfrage stand .
+Ein Kompromiss zwischen Gegnern und Befürworten der Sklaverei schien kaum noch möglich .
+Gemäßigte und radikale Sklavereigegner schlossen sich enger zusammen , während die Partei der Demokraten zerbrach .
+Lincoln als gemäßigter Gegner der Sklaverei Die Partei der Whigs zeigte bereits nach dem Kompromiss von 1850 erste Zerfallserscheinungen und spaltete sich vollends wegen des Streits um den Kansas-Nebraska-Act von 1854 .
+In diesem Jahr schlossen sich die meisten ihrer Mitglieder mit gemäßigten Sklavereigegnern aus den Reihen der Demokraten zur Republikanischen Partei zusammen .
+Verstärkt wurden sie durch Abolitionisten und Free Soiler .
+Sie alle sahen in den sklavereifreundlichen Regierungen der 1850er Jahre bereits die Verwirklichung der so genannten slave power , einer von ihnen befürchteten Tyrannei der Sklavenhalter-Aristokratie , über die gesamten Vereinigten Staaten .
+Mit der Verabschiedung des Kansas-Nebraska Acts schienen slave power bzw. slaveocrazy endgültig in die Offensive zu gehen .
+Dies bewog Abraham Lincoln , in die Politik zurückzukehren .
+Am 22. Februar 1856 gründeten er und 24 weitere Gegner des Kansas-Nebraska-Gesetzes auch in Illinois einen Ableger der Republikanischen Partei .
+Zu dieser Zeit war er kein bedingungsloser Gegner der Sklaverei .
+Er verabscheute sie zwar moralisch , vertrat gegenüber den Südstaaten damals aber einen streng am geltenden Recht und Gesetz orientierten Standpunkt .
+So war er der Ansicht , dass die Gründerväter der Vereinigten Staaten die Sklaverei grundsätzlich als Übel angesehen , sie aber aus pragmatischen Gründen weiterhin in jenen Staaten geduldet hätten , in denen sie zur Zeit der Unabhängigkeitserklärung von 1776 und zum Zeitpunkt der Verabschiedung der US-Verfassung von 1787 bereits bestand .
+Eine Ausdehnung der Sklaverei auf weitere Staaten und Territorien widerspreche aber dem Geist der Verfassung und den freiheitlichen Prinzipien der Amerikanischen Revolution .
+Bei einer Rede in Springfield sprach er sich im Oktober 1854 dafür aus , mit den Abolitionisten zusammenzuarbeiten , wenn es um die Wiederherstellung des Missouri-Kompromisses ging , aber sich gegen sie zu stellen , wenn sie den Fugitive Slave Act abschaffen wollten . Er nahm damit eine Haltung zwischen radikalen Abolitionisten und Free Soilern ein , was ihn für breite Wählergruppen interessant machte .
+Im Jahr 1855 scheiterte sein erster Versuch , einen Sitz im Senat zu erlangen .
+Drei Jahre später unternahm er einen zweiten Anlauf .
+Sein Gegenkandidat war Senator Stephen A. Douglas , der Führer der Demokraten auf Unionsebene .
+Zum Auftakt des Wahlkampfs brachte Lincoln in einer berühmt gewordenen House-Divided-Rede , die er am 16. Juni 1858 im Staatsparlament von Illinois hielt , die Sklavenfrage und ihre Auswirkungen auf die amerikanische Politik auf den Punkt : In derselben Rede verdächtigte Lincoln seinen Gegner Douglas , den obersten Bundesrichter Taney , Präsident James Buchanan und dessen Vorgänger Franklin Pierce Teil einer Verschwörung zu sein , deren Ziel es sei , die Sklaverei auch in den bislang freien Bundesstaaten einzuführen . Einen Beleg für diesen Verdacht , den viele Nordstaatler teilten , gab es nicht .
+Aber indem Lincoln ihn in der Rede öffentlich geäußert und dabei festgestellt hatte , dass es keinen Kompromiss zwischen Sklaverei und Freiheit geben könne , erregte er landesweites Aufsehen als einer der entschiedensten Gegner der Sklaverei in den Reihen der Republikaner .
+Douglas , der als großer Redner bekannt war , erklärte sich mit einer Serie von sieben öffentlichen Rededuellen einverstanden , die er und Lincoln zwischen Juli und Oktober 1858 in verschiedenen Städten von Illinois austrugen .
+Die Lincoln-Douglas-Debatten sollten Geschichte machten , denn wegen ihrer grundsätzlichen Bedeutung und der rhetorischen Fähigkeiten der Kontrahenten wurden Mitschriften davon überall in den USA abgedruckt .
+Bei der Debatte , die am 27. August 1858 in Freeport im Norden von Illinois stattfand , gelang es Lincoln , seinen Gegner in eine Zwickmühle zu bringen .
+Douglas war der Initiator des Kansas-Nebraska-Acts gewesen , der dem Kongress in letzter Konsequenz das Recht absprach , die Sklaverei in einem US-Territorium zu verbieten .
+Lincoln fragte ihn daher , ob es zumindest der Bevölkerung eines Territoriums selbst auf gesetzlichem Wege möglich sei , die Sklaverei von dessen Gebiet auszuschließen , bevor es sich als Bundesstaat konstituiert habe .
+Antwortete Douglass darauf mit Nein , verärgerte er die in Illinois wichtige Wählergruppe der Free Soiler .
+Antwortete er mit Ja , wurde er für die Südstaatler unwählbar .
+Douglas entschied sich für ein Ja , um die unmittelbar anstehende Wahl zu gewinnen , legte damit aber zugleich den Grundstein für das Scheitern seiner Präsidentschaftskandidatur zwei Jahre später .
+Im weiteren Verlauf des Senatswahlkampfs von 1858 passte auch Lincoln sein Auftreten den Ansichten des jeweiligen Publikums an .
+So betonte er im Norden von Illinois , in Chicago , dass alle Menschen gleich erschaffen seien , und wandte sich gegen Vorstellungen von ungleichen Rassen .
+Im Süden des Staates , in Charleston , erklärte er hingegen , dass er noch nie befürwortet habe , den Schwarzen die gleichen sozialen und politischen Rechte wie den Weißen zuzugestehen . Den reinen Abolitionismus befürwortete er nicht , zumal er die Abolitionisten für zu wenig kompromissbereit hielt .
+Zudem hätte eine solche Haltung damals politischen Selbstmord bedeutet .
+Am Ende erhielt Lincoln zwar 4.000 Stimmen mehr als Douglas , verlor die Senatswahl aber erneut . Nicht zuletzt durch die Rededuelle hatte sich aber nun als gemäßigter Gegner der Sklaverei im ganzen Land einen Namen gemacht und galt als möglicher Kandidat der Republikaner für die nächsten Präsidentschaftswahlen .
+Präsidentschaftswahl von 1860 Datei : Abraham Lincoln by Brady.jpg Datei : ElectoralCollege1860-Large.png Lincoln hatte bis zu diesem Zeitpunkt nie ein hohes Staatsamt bekleidet und seine Erfahrungen in Washington beschränkten sich auf die wenigen Jahre als Kongressabgeordneter .
+Zwar unternahm er 1859 Vortragsreisen durch die Nordstaaten , um sich der Bevölkerung und seinen Parteifreunden vorzustellen und weiter für seinen gemäßigten Standpunkt zu werben .
+Aber trotz seiner wachsenden Bekanntheit , zu der insbesondere seine Rede vor der Cooper Union am 27. Februar 1860 und die dort von ihm erstellte Fotografie beitrug , galt er noch zu Beginn des Nominierungsparteitags der Republikaner , der im Mai 1860 in Chicago stattfand , als Außenseiter im Rennen um die Präsidentschaftskandidatur .
+Hoher Favorit war der Senator und frühere Gouverneur von New York , William H. Seward .
+Auch den Kandidaten Salmon P. Chase aus Ohio und Edward Bates aus Missouri wurden allgemein größere Chancen eingeräumt als Lincoln .
+Auf der Convention in Chicago konnte er sich uneingeschränkt nur auf die Delegation seines Heimatstaats Illinois verlassen .
+Deren Mitglieder aber überzeugten zahlreiche Delegierte anderer Staaten davon , für Lincoln als Kompromisskandidaten zu stimmen , falls sich ihr erster Favorit nicht durchsetzen ließe . Da sich die Vertreter der als radikal geltenden Sklavereigegner Seward und Chase und die eher konservativen Gruppierungen um Bates bei den Abstimmungen gegenseitig blockierten , bestimmten die Republikaner am 18. Mai 1860 schließlich Abraham Lincoln zu ihrem Spitzenkandidaten für den Kampf ums Weiße Haus .
+Seine Gegner nahm er später alle in sein Kabinett auf .
+Damit zwang er die Führer der verschiedenen innerparteilichen Gruppierungen , zusammen statt gegeneinander zu arbeiten .
+Während des Wahlkampfs kam Lincoln seine hohe rhetorische Begabung zustatten .
+Er galt als einer der größten Redner seiner Zeit und viele der von ihm geprägten Aussprüche und Aphorismen gehören in den USA bis heute zum allgemeinen Bildungsgut .
+Vor allem verstand er es , komplizierte Fragen mit einfachen Worten auf den Punkt zu bringen .
+Sätze wie „ Nichts ist geregelt , was nicht gerecht geregelt ist “ , „ Die Wahlversprechen von heute sind die Steuern von morgen “ oder „ Wer anderen die Freiheit verweigert , verdient sie nicht für sich selbst “ überzeugten viele Wähler .
+Das Wahlkampflied , das sein Programm prägnant zusammenfasste , war der noch heute populäre Song Lincoln and Liberty .
+Die Präsidentschaftswahl fand im Herbst statt .
+Eine Grundlage für seinen Sieg hatte Lincoln schon zwei Jahre zuvor in den Debatten mit Stephen A. Douglas gelegt .
+Er hatte damals seinen Gegner , der die Präsidentschaftskandidatur der Demokraten anstrebte , zu Äußerungen über die Sklaverei gedrängt , die ihn für die Demokraten des Südens unwählbar machten .
+Wie die Whigs sechs Jahre zuvor , so hatte sich nun auch die Demokratische Partei gespalten .
+Die Nord-Demokraten nominierten Douglas , die Süd-Demokraten den eindeutigen Sklavereibefürworter John C. Breckinridge aus Kentucky , zu diesem Zeitpunkt noch amtierender Vizepräsident .
+Beide zusammen gewannen 2,2 Millionen Wähler , John Bell aus Tennessee , der für die von den Whigs abgespaltene Constitutional Union Party antrat , weitere 0,6 Millionen ; Lincoln aber wurde mit fast 1,9 Millionen Stimmen der stärkste Einzelkandidat .
+Er siegte in keinem einzigen der Wahlbezirke des Südens – in den meisten stand er nicht einmal auf dem Stimmzettel – , erhielt aber fast alle Wahlmännerstimmen des Nordens ( 180 ) und damit eine klare Mehrheit : Mit 40 % der Wählerstimmen gewannen er und sein Vizepräsidentschaftskandidat Hannibal Hamlin 59 % aller Wahlmänner .
+Am 6. November 1860 wurde Abraham Lincoln gewählt ; am 4. März 1861 sollte er den Amtseid ablegen .
+In diesen vier Monaten aber wurden Tatsachen geschaffen , die Lincolns gesamte Regierungszeit bestimmen sollten .
+Lincoln als Präsident Datei : Abraham Lincoln.jpg Während seiner gesamten Amtszeit als US-Präsident sah sich Abraham Lincoln gezwungen , einen Bürgerkrieg zur Wiederherstellung der Union zu führen .
+Dabei stand er im Wesentlichen vor vier großen Aufgaben : Er musste den Krieg militärisch gewinnen , bei der Bevölkerung des Nordens die Kampfbereitschaft aufrechterhalten , die Einmischung europäischer Mächte zugunsten der Konföderierten verhindern und schließlich die Abschaffung der Sklaverei betreiben , um die Ursache des Konflikts ein für alle Mal zu beseitigen .
+Amtsantritt und Kriegsbeginn Die Wahl Abraham Lincolns war nicht die Ursache , aber der Anlass der Sezession .
+Der Gedanke , sich von der Union zu lösen , war erstmals während der so genannten Nullifikationskrise von 1832/33 in South Carolina aufgetaucht .
+Befürworter dieser Idee , wie John C. Calhoun fanden aber bis in die 1850er Jahre nur vereinzelt Zustimmung .
+In den 185oer Jahren mehrten sich dann die Stimmen derer , die für die Sezession eintraten .
+Die im Norden geübte Kritik an der Sklaverei wurde von vielen tonangebenden Südstaatlern als Bedrohung der eigenen Lebensart und Kultur betrachtet und jeder Versuch , sie zu beschränken , als Eingriff in die Rechte der Einzelstaaten und in das Eigentumsrecht ihrer Bürger .
+Aufgrund dieser Sichtweise machten die Verfechter der Sezession keinen Unterschied zwischen der kompromissbereiten Haltung Lincolns und den Zielen der Abolitionisten .
+Die Aussicht , Lincoln ins Weiße Haus einziehen zu sehen , gab den Extremisten im Süden den letzten entscheidenden Auftrieb .
+Noch bevor der neue Präsident sein Amt antreten konnte , gab South Carolina am 20. Dezember 1860 als erster Staat seinen Austritt aus der Union bekannt .
+Innerhalb weniger Wochen folgten alle Staaten des tiefen Südens : Mississippi , Florida , Alabama , Georgia , Louisiana und am 2. März 1861 Texas .
+In Montgomery , der Hauptstadt Alabamas , hatte sich am 4. Februar 1861 ein Provisorischer Kongress aus Vertretern der bis dahin ausgetretenen Staaten konstituiert .
+Dieser wählte am 9. Februar den Senator von Mississippi und früheren Kriegsminister Jefferson Davis , der wie Lincoln aus Kentucky stammte , zum provisorischen Präsidenten der Konföderierten Staaten von Amerika .
+Der scheidende US-Präsident James Buchanan bestritt den Einzelstaaten zwar das Recht , die Union zu verlassen , tat in seinen letzten Wochen im Amt aber nichts , um die Sezession zu verhindern .
+Datei :P resident-Jefferson-Davis.jpg In der Rede zu seiner Amtseinführung am 4. März 1861 schlug Lincoln gegenüber dem Süden versöhnliche Töne an .
+Er versprach , nicht als erster zu Gewaltmaßnahmen zu greifen , machte aber zugleich deutlich , dass sein Amtseid ihn verpflichte , einer Spaltung der Union auf jeden Fall entgegenzutreten : Alle Hoffnungen auf eine Verhandlungslösung zerschlugen sich jedoch am 12. April 1861 .
+An diesem Tag begannen konföderierte Truppen mit der Beschießung des von unionstreuen Einheiten gehaltenen Forts Sumter , das in der Hafeneinfahrt von Charleston lag , der alten Hauptstadt von South Carolina .
+Der Süden , der die Garnison von Fort Sumter als Besatzungstruppe betrachtete , hatte also trotz des angebotenen Gewaltverzichts zu den Waffen gegriffen – und trotz der Tatsache , dass Lincolns Regierung bis dahin keine Verfassung irgendeines Einzelstaats verletzt hatte und dies erklärtermaßen auch nicht plante .
+Dieser Umstand und der erzwungene Abzug der Garnison von Fort Sumter am 14. April erzeugten nun auch im Norden eine Kriegsstimmung .
+Die Öffentlichkeit verlangte energische Schritte gegen die „ Rebellen “ . Wie es soweit kommen konnte , erklärte Lincoln vier Jahre später in der Rede zu seiner zweiten Amtseinführung so : Der Beginn der Kampfhandlungen bewog Virginia und drei weitere Staaten des oberen Südens – North Carolina , Tennessee und Arkansas – die Union nun ebenfalls zu verlassen .
+Die Konföderierten verlegten daraufhin ihre Hauptstadt nach Richmond , Virginia .
+Von diesem Staat wiederum trennten sich die westlichen Landesteile ab , die in der Union bleiben wollten .
+Sie bildeten später den neuen Bundesstaat West Virginia .
+Um die Hauptstadt Washington halten zu können , war es für den Norden von entscheidender Bedeutung , die sklavenhaltenden Grenzstaaten Delaware , Maryland , Kentucky und Missouri zum Verbleib in der Union zu bewegen .
+Zu diesem Problem ist der Ausspruch Lincolns überliefert : „ In diesem Krieg hoffe ich Gott auf meiner Seite zu haben .
+Kentucky aber muss ich auf meiner Seite haben . “ Alle vier Staaten blieben schließlich loyal – teils freiwillig , teils unter militärischem Druck .
+Lincolns Politik im Krieg Datei :P inkertonLincolnMcClernand.jpg Datei : Battle of Gettysburg.jpg Die US-Armee zählte zu Kriegsbeginn nur etwas mehr als 16.000 Soldaten , die zudem überwiegend in den Indianergebieten des Westens stationiert waren .
+Am 15. April , einen Tag nach dem Fall von Fort Sumter , berief Lincoln daher 75.000 auf 90 Tage verpflichtete Milizsoldaten ein , um der Rebellion , wie die Abspaltung der Südstaaten im Norden genannt wurde , nunmehr militärisch ein Ende zu bereiten .
+Als weitere Sofortmaßnahme verfügte er eine Seeblockade aller konföderierten Häfen und vergrößerte die US-Streitkräfte bis zum Frühsommer durch weitere Anwerbungen auf rund 174.000 Soldaten und Matrosen .
+Da der Kongress erst im Juli wieder tagen sollte , geschahen diese Truppenaushebungen ohne dessen Ermächtigung .
+Dasselbe traf auf die Einschränkung einiger Grundrechte , etwa der Pressefreiheit oder des Habeas-Corpus-Gesetzes , zu .
+So ließ Lincoln Personen , die der Spionage für die Südstaaten verdächtigt wurden , ohne gesetzliche Grundlage verhaften .
+All dies brachte ihm bei Sympathisanten des Südens – zum Teil bis heute – den Ruf eines Diktators ein .
+Als aber im Juli die Vertreter der in der Union verbliebenen Staaten zum Kongress zusammentraten , stimmten sie allen Notstandsmaßnahmen des Präsidenten nachträglich zu .
+Aus ihrer Sicht verfuhr Lincoln mit den Unterstützern der Konföderierten nicht anders , als es mit Angehörigen einer fremden , mit den USA im Krieg befindlichen Macht üblich war – und genau dies beanspruchte die Konföderation ja zu sein .
+Doch selbst die angegebenen energischen Maßnahmen Lincolns reichten nicht aus .
+Die erste Niederlage der Unionstruppen in der Schlacht am Bull Run am 21. Juli 1861 machte deutlich , dass der Konflikt militärisch nicht schnell zu lösen war .
+Die Union musste sich auf einen langwierigen Eroberungskrieg einstellen .
+Dies war mit einer kleinen Berufsarmee und einer dreimonatigen Dienstpflicht nicht zu erreichen .
+Auch die Verlängerung auf neun Monate reichte nicht aus .
+Schließlich führte Lincolns Regierung erstmals in der Geschichte der USA die allgemeine Wehrpflicht ein , eine Maßnahme , die Anfang Juli 1863 zu bürgerkriegsähnlichen Unruhen in New York führte , den sogenannten Einberufungskrawallen .
+In der Stadt gab es zeitweilig sogar Bestrebungen , sich ebenfalls von der Union loszusagen und einen souveränen Staat zu bilden .
+Ein weiteres Problem stellten betrügerische Heereslieferanten dar , die die Unionsarmeen oft mit mangelhaftem oder völlig untauglichem Material belieferten .
+Daher verabschiedete der Kongress auf Lincolns Initiative am 2. März 1863 den False Claims Act , der bis heute als Lincoln Law bekannt ist .
+Das Gesetz ermutigte Whistleblower und erwies sich als wirksames Instrument , um Betrug zu Lasten der Allgemeinheit zu unterbinden .
+Der Bürgerkrieg zog sich auch deshalb in die Länge , weil Lincoln lange Zeit keinen geeigneten Oberbefehlshaber für die Potomac-Armee fand , die die Hauptlast der Kämpfe im Grenzgebiet von Virginia , zwischen Washington , D. C. und Richmond , zu tragen hatte .
+General George B. McClellan erwies sich zwar als hervorragender Organisator , aber als zögerlicher Heerführer .
+Er vergab – etwa im Halbinsel-Feldzug vom Frühjahr 1862 – gleich mehrere Chancen , dem Krieg durch schon greifbare Siege ein frühes Ende zu bereiten .
+Andere Befehlshaber wie Ambrose E. Burnside und Joseph Hooker erlitten katastrophale Niederlagen gegen die zahlenmäßig unterlegene Nord-Virginia-Armee des konföderierten Generals Robert E. Lee .
+Abraham Lincoln , der zwischen seiner Funktion als Kompaniechef im Indianerkrieg und der als Oberbefehlshaber der US-Streitkräfte nie mehr einen soldatischen Rang bekleidet hatte , unterzog sich nun auch einem Selbststudium in Militärfragen und wurde bald zum Experten .
+Mit den auf dem westlichen Kriegsschauplatz siegreichen Generalen Ulysses S. Grant und William T. Sherman fand er schließlich zwei Kommandeure , die mit ihren Truppen – der eine von Norden , der andere von Westen – die Konföderierten in langen , blutigen Kämpfen niederrangen .
+Kriegsziele und Kriegsgründe Datei : Greeley-Horace-LOC.jpg Am 22. August 1862 schrieb Lincoln in einem offenen Brief an den bekannten Abolitionisten Horace Greeley , den Herausgeber der New York Tribune : In der Tat ging es im Bürgerkrieg vordergründig um den nationalen Zusammenhalt der Vereinigten Staaten .
+Die Frage , an der sich der Kampf entzündet hatte , lautete : Hat ein einzelner Bundesstaat der USA das Recht , jederzeit aus der gemeinsamen Union auszutreten ?
+Die Konföderierten bejahten dies , mit dem Argument , man sei dem Bund schließlich freiwillig beigetreten .
+Die Abspaltung , die sie vielfach als „ Zweite Amerikanische Revolution “ bezeichneten , stand in ihren Augen in der Tradition von 1776 . Sie kämpften also nach eigenem Selbstverständnis für die Rechte der Einzelstaaten .
+Der Norden wies dagegen darauf hin , dass keines der Einzelstaatenrechte bis dahin verletzt worden und dass nach der Unabhängigkeitserklärung von 1776 eine Revolution nur nach fortgesetzten schweren Rechtsverletzungen gerechtfertigt sei .
+Den tieferen Grund des Konflikts aber berührte Abraham Lincoln in der Gettysburg Address von 1863 .
+In dieser Rede , seiner berühmtesten , sagte er , der Krieg werde um die Frage geführt , ob ein Staat , der sich auf Demokratie und individuelle Freiheit gründe , überhaupt auf Dauer bestehen könne .
+Diese Frage stellte sich mit umso größerer Berechtigung in einer Zeit , als eine „ Regierung des Volkes , durch das Volk und für das Volk “ – wie Lincoln es in der Rede formulierte – international noch die große Ausnahme darstellte .
+Lincoln gab damit seiner Überzeugung Ausdruck , dass eine Demokratie zerbrechen müsse , wenn eine Minderheit ( wie die Südstaatler ) eine demokratische Entscheidung der Mehrheit ( wie Lincolns Wahl zum Präsidenten ) jederzeit verwerfen oder sogar mit Gewalt beantworten dürfe .
+Hinter der Frage der Einzelstaatenrechte stand aber immer unübersehbar die Sklavenfrage .
+An ihr – und nur an ihr – hatte sich der Streit um diese Rechte überhaupt erst entzündet .
+Ohne sie hätte sich das Problem der Einzelstaatenrechte nie in dieser Schärfe gestellt .
+So erwähnt beispielsweise die Erklärung zum Sezessionsbeschluss des Staates Texas vom 2. Februar 1861 den Dissens in der Frage der Sklaverei 21-mal , die Frage der Einzelstaatenrechte aber nur sechsmal . Alexander Stephens , der Vizepräsident der Konföderation , erklärte in einer viel beachteten Rede vom 21. März 1861 , der Bund der Südstaaten beruhe „ … auf der großen Wahrheit , dass der Neger dem weißen Mann nicht gleichgestellt ist ; dass sein untergeordnetes Verhältnis als Sklave gegenüber der überlegenen Rasse seine natürliche und normale Stellung ist . “ Lincoln verneinte aus wahltaktischen Gründen lange , dass die Abschaffung der Sklaverei zu seinen Kriegszielen gehörte .
+Denn zu Beginn des Konfliktes bildeten die Abolitionisten auch im Norden noch immer eine Minderheit , und kaum jemand wäre bereit gewesen , für die Befreiung der Sklaven in den Kampf zu ziehen .
+Doch ebendiese hatte Lincoln bereits in die Wege geleitet , als er den zitierten Brief an Greeley schrieb .
+Sklavenbefreiung Datei : Emancipation proclamation.jpg Datei : Emancipation proclamation document.jpg Über Lincolns Haltung zur Sklavenbefreiung bemerkte der afroamerikanische Schriftsteller und Abolitionist Frederick Douglass 1876 : In der Tat war Lincoln nie radikaler Abolitionist und wurde es auch im Krieg nicht .
+In dem berühmten Brief an Greeley unterschied er zwischen seinem persönlichen Wunsch , nach dem alle Menschen frei sein sollten , und seiner Pflicht als Amtsträger , nach Recht und Gesetz zu handeln .
+Laut Gesetz aber war die Sklaverei im Süden erlaubt .
+Nach Lincolns Vorstellung sollte sie in einem allmählichen Prozess abgeschafft und die Sklavenhalter für den Verlust ihres „ Besitzes “ entschädigt werden .
+Diesen Standpunkt vertrat er noch bis in die Anfangsphase des Bürgerkriegs hinein .
+So widerrief er beispielsweise die Anordnungen des Generalmajors John Charles Frémont , der die Sklaven von Plantagenbesitzern , die gegen die Union kämpften , für frei erklärt hatte . Auf gar keinen Fall war Lincoln vor 1861 bereit , die Sklavenfrage durch einen Krieg zu entscheiden .
+Indem sie aber von sich aus zur Gewalt gegriffen hatten , waren die Südstaaten nach Lincolns Auffassung selbst vom Weg des Rechtes und der Verfassung abgekommen .
+Je länger der Krieg dauerte , je mehr Opfer er forderte und je mehr Widerhall die Proteste der Abolitionisten fanden , desto stärker wurde Lincolns Überzeugung , dass die Sklaverei als Quelle allen Übels endgültig abgeschafft werden müsse .
+Dazu kam , dass er die Sklavenbefreiung mehr und mehr als Mittel begriff , den Süden wirtschaftlich und militärisch zu treffen .
+Kongress und Senat hatten bereits 1861 und 1862 sogenannte Confiscation Acts verabschiedet , durch die unter anderem die Sklaven konföderierter Soldaten für frei erklärt wurden .
+Dies sollte das Militär der Südstaaten schwächen . Am 22. Juli 1862 informierte Lincoln sein Kabinett über die geplante Proklamation zur Sklavenbefreiung .
+Da auch sie als Kriegsmaßnahme gedacht war , gab Außenminister Seward zu bedenken , dass die Erklärung nach der Reihe schwerer Niederlagen , die die Union bis dahin erlitten hatte , als Zeichen der Schwäche missdeutet werden könne .
+Daher gab Lincoln die Proklamation erst im September bekannt , nach dem Unionssieg in der Schlacht am Antietam .
+Am 1. Januar 1863 trat die Emanzipations-Proklamation schließlich in Kraft .
+Ihr entscheidender Passus besagte : Die Proklamation galt also vorerst nur für die Gebiete der Konföderierten , um die loyal gebliebenen Sklavenstaaten nicht zu verprellen .
+Aber die Befreiung der Sklaven war nun ein offizielles Kriegsziel der Union .
+Dessen moralisches Gewicht machte es England und Frankreich , die aus wirtschaftlichen und machtpolitischen Gründen die Sache der Konföderation unterstützten , unmöglich , aktiv auf deren Seite in den Krieg einzugreifen .
+Vollständig abgeschafft wurde die Sklaverei 1865 .
+Indianerpolitik Datei : Homestead Act ( 1862 ) - first page.jpg Als Befürworter der Free-Soil-Bewegung unterzeichnete Lincoln 1862 den Homestead Act , der 1863 in Kraft trat .
+Dieses Gesetz erlaubte es jedem Erwachsenen , sich auf unbesiedeltem Land niederzulassen und sich ein 160 Acre ( etwa 64 ha ) großes Areal anzueignen .
+Nach fünfjähriger Bewirtschaftung – oder bei Zahlung von 200 Dollar bereits nach einem halben Jahr – wurde er automatisch zum Eigentümer .
+Einerseits schuf dieses Gesetz , das bereits bestehende einzelstaatliche Regelungen ergänzte und vereinheitlichte , Rechtssicherheit für die Siedler .
+Andererseits ermöglichte es die Enteignung der Indianergebiete , indem es unterstellte , diese würden nicht bewirtschaftet .
+Vor allem nomadisch lebende Gruppen wurden nun verstärkt in Reservate abgedrängt .
+Das Heimstätten-Gesetz leistete dem Betrug Vorschub und führte zu zahllosen Konflikten zwischen Indianern und Siedlern , in denen die Gerichte meist zugunsten der letzteren entschieden .
+Im Sommer 1862 , noch vor Inkrafttreten des Homestead Act und dreißig Jahre nach seiner Teilnahme am Krieg gegen die Sauk , sah sich Lincoln erneut einem Konflikt mit Indianern gegenüber .
+Nachdem vertraglich zugesicherte , staatliche Geldzahlungen an die Santee-Sioux in Minnesota ausgeblieben waren , gingen hungernde Mitglieder des Stammes gewaltsam gegen die örtliche Indianerbehörde und weiße Siedler vor .
+Kriegsminister Stanton beauftragte im September Generalmajor John Pope mit der Niederschlagung des Sioux-Aufstands .
+Pope , der für die kurz zuvor erlittene Niederlage der Unionstruppen in der 2. Schlacht am Bull Run verantwortlich gemacht wurde , hatte sich für den Einsatz freiwillig gemeldet , um seiner Absetzung als Befehlshaber der Virginia-Armee zuvorzukommen .
+In einem Befehl an den Kommandeur der Expedition , Oberst H. H.
+Sibley , schrieb er : „ Es ist meine Absicht , die Sioux vollständig auszurotten . [ … ] Sie müssen behandelt werden wie Wahnsinnige oder wilde Tiere und auf keinen Fall wie Menschen , mit denen man Verträge oder Kompromisse schließen kann . “ Nach der Niederschlagung des Aufstands wurden mehrere Hundert Sioux vor Militärgerichte gestellt und in Verfahren , die im Schnitt 10 bis 15 Minuten dauerten , zum Tode verurteilt . Pope wollte schließlich 303 Verurteilte hinrichten lassen , doch Lincolns Regierung fürchtete den ungünstigen Eindruck einer solchen Massenexekution auf die europäischen Regierungen , deren Einmischung in den Sezessionskrieg sie fürchtete .
+Andererseits forderten zahlreiche Siedler in Minnesota die Hinrichtung .
+200 von ihnen griffen sogar das Gefangenenlager in Mankato an .
+Dennoch reduzierten Anwälte im Auftrag Lincolns die Zahl der Todesurteile drastisch .
+So wurden schließlich „ nur “ 38 Männer gehängt , einer davon , Chaska , trotz seiner Begnadigung . Dies war die größte Massenhinrichtung in der amerikanischen Geschichte .
+Im Gegenzug sagte Lincoln , der sich massiven politischen Drucks zu erwehren hatte , die spätere Vertreibung der Indianer aus dem Bundesstaat zu sowie zwei Millionen Dollar Schadensersatz .
+Lincoln begründete die Hinrichtung damit , dass er nicht durch zu große Gnade einen weiteren Aufstand provozieren , aber auch nicht grausam sein wollte . In Minnesota wurde die hohe Anzahl der Begnadigungen eher schlecht aufgenommen : Bei der Präsidentschaftswahl 1864 gewann Lincoln zwar eine Mehrheit im Staat , doch fiel diese deutlich geringer aus als 1860 .
+Darauf angesprochen , dass eine härtere Gangart dies hätte verhindern können , sagte Lincoln : „ Ich konnte es mir nicht erlauben , Männer für Stimmen aufzuhängen . “
+In Lincolns Amtszeit fiel auch das Sand-Creek-Massaker im Osten des damaligen Territoriums Colorado .
+Dabei töteten Soldaten unter dem Kommando von Oberst John Chivington am 29. November 1864 273 friedliche Cheyenne und Arapaho . Wesentlich beigetragen zur indianerfeindlichen Stimmung in dem Territorium hatte dessen Gouverneur John Evans , ein Mitbegründer der Republikanischen Partei und persönlicher Freund Lincolns .
+Evans , der Chivington für seine Tat ausgezeichnet und die wahren Umstände des Massakers verschleiert hatte , sah sich bald massiver Kritik ausgesetzt .
+Lincoln , der Evans eingesetzt hatte , stärkte ihm noch bis Anfang 1865 den Rücken , erst sein Nachfolger als Präsident , Andrew Johnson , enthob den Gouverneur im Sommer 1865 seines Amtes .
+Wiederwahl 1864 Nach ihrer Niederlage in der Schlacht von Gettysburg vom 1. bis 3. Juli 1863 waren die Konföderierten nicht mehr in der Lage , den Krieg aus eigener Kraft zu gewinnen .
+Ihre einzige Chance bestand darin , den Krieg so lange und für den Norden so verlustreich weiterzuführen , dass Abraham Lincoln die Präsidentschaftswahlen von 1864 verlieren und durch einen neuen , verhandlungsbereiten Präsidenten ersetzt würde .
+Datei : Ulysses simpson grant.jpg Diese Chance war durchaus real .
+Der unerwartet lange und blutige Stellungskrieg , den General Grant seit dem Frühjahr 1864 im Norden Virginias führte , kostete die Regierung Lincoln weitgehend das Vertrauen der Bevölkerung .
+Der Präsident war im Sommer des Wahljahrs so unpopulär , dass er selbst mit einer Niederlage rechnete .
+In einem Memorandum vom 23. August 1864 schrieb er : „ Die Wiederwahl dieser Regierung erscheint heute , wie seit einigen Tagen , als überaus unwahrscheinlich . “ Sein Gegenkandidat von den Demokraten war sein früherer Oberbefehlshaber McClellan , der grundsätzlich zu einem Verhandlungsfrieden mit dem Süden und zur Anerkennung seiner Unabhängigkeit bereit war .
+Erst in den letzten Wochen vor der Wahl wendete sich das Blatt , als die Ergebnisse des für den Norden äußerst erfolgreichen Atlanta-Feldzuges bekannt wurden : Die Truppen General Shermans hatten am 2. September 1864 Atlanta , die Hauptstadt des Rebellenstaates Georgia , erobert .
+Zwischen ihnen und Virginia standen nur noch schwache Kräfte des Südens .
+Zudem besiegte Generalmajor Philip Sheridan am 19. Oktober im Shenandoah-Tal ein konföderiertes Korps , das zeitweilig sogar Washington bedroht hatte .
+Das Kriegsende schien jetzt nur noch eine Frage der Zeit zu sein .
+Die Republikaner setzten im Wahlkampf auf den von Lincoln geprägten Slogan „ Mitten im Fluss soll man nicht die Pferde wechseln “ und bezeichneten die Positionen der Demokraten als landesverräterisch .
+Als Kandidat für die Vizepräsidentschaft ersetzte Lincoln den bisherigen Amtsinhaber , den weitgehend einflusslosen Nordstaatler Hannibal Hamlin , durch Andrew Johnson .
+Dieser gehörte der Demokratischen Partei an , stammte aus dem Konföderiertenstaat North Carolina und war 1857 von Tennessee in den Senat entsandt worden , hatte sich aber für die Union ausgesprochen .
+Seine Kandidatur sollte den Südstaatlern die Bereitschaft des Nordens signalisieren , sie nach dem Krieg gleichberechtigt in die wiederhergestellte Union zu integrieren .
+Gemeinsam mit Johnson kandidierte Lincoln im Rahmen der National Union Party , einer Wahlplattform aus Republikanern und einem Teil der Demokraten .
+Am 8. November hielten die USA als erstes demokratisches Land mitten in einem Krieg eine Wahl ab .
+Lincoln erzielte einen Erdrutschsieg : 55 Prozent der Wähler stimmten für ihn , und er erhielt sogar 212 von 233 Wahlmännerstimmen .
+Als erster Präsident seit 32 Jahren war er für eine zweite Amtszeit bestätigt worden .
+Seine Wähler entstammten vor allem der Bauern- und Arbeiterschaft sowie den städtischen Mittelschichten .
+Ihre geografischen Hochburgen waren Neuengland und die Staaten mit einem starken Anteil deutscher Einwanderer wie Wisconsin oder Illinois .
+Für den Präsidenten war es besonders bedeutsam , dass auch die Soldaten der Unionsarmee zu mehr als zwei Dritteln für ihn gestimmt hatten , obwohl sie sich von einem Sieg McClellans ein rascheres Ende der Kampfhandlungen erhoffen konnten .
+Vor der Wahl hatte Lincoln geäußert , es sei ihm lieber , mit der Mehrheit der Soldatenstimmen besiegt als ohne diese Mehrheit Präsident zu werden .
+In der Zeit bis zu seinem zweiten Amtsantritt setzte sich Lincoln energisch für die Verabschiedung des 13. Zusatzartikels zur US-Verfassung ein , der die Sklaverei auf dem Territorium der USA ein für alle Mal verbieten sollte .
+Nach dem Senat konnte er – nach einem vergeblichen Anlauf – am 31. Januar 1865 auch die nötige Zweidrittelmehrheit des Repräsentantenhauses zur Zustimmung bewegen .
+Um dem Sklavereiverbot endgültig Verfassungsrang zu verleihen , musste es jetzt nur noch von den Einzelstaaten ratifiziert werden .
+Ein weiteres , drängendes Problem war die Wiedereingliederung der Südstaaten in die Union .
+Am 4. März 1865 – anlässlich seiner zweiten Vereidigung als Präsident – versprach Lincoln , „ Groll gegen niemanden “ und „ Nächstenliebe gegen alle “ walten zu lassen .
+Er fasste bereits den Wiederaufbau des Südens und die Nachkriegsordnung ins Auge und hatte vor , den Südstaatlern milde Friedensbedingungen zu stellen .
+Die Rückkehr in die Union sollte ihnen so leicht wie möglich fallen .
+Gegen Widerstände aus der eigenen Partei setzte Lincoln den Grundsatz durch , dass ein abtrünniger Staat wieder gleichberechtigt in die Union aufgenommen werden sollte , sobald ein Zehntel seiner Bürger ihr den Treueid geleistet hätten .
+Sieg und Tod Datei : Lincolnassassination.jpg Datei : Lincoln at his death bed.jpg Der Krieg ging nun einem raschen Ende entgegen .
+Am 3. April eroberten Grants Truppen die Konföderiertenhauptstadt Richmond , und Lincoln besichtigte zwei Tage später das Amtszimmer seines Kontrahenten Jefferson Davis .
+Am 9. April 1865 kapitulierten die Reste von Lees Armee vor General Grant bei Appomattox Court House , Virginia .
+Die konföderierten Truppen unter General Joseph E. Johnston ergaben sich am 26. April General Sherman bei Durham , North Carolina .
+Den endgültigen Sieg hat Abraham Lincoln jedoch nicht mehr erlebt : Am Abend des 14. April , des Karfreitags 1865 , besuchte er mit seiner Frau Mary und einem befreundeten Ehepaar eine Komödie im Ford ’ s Theatre in Washington , D. C. Während der Vorstellung verschaffte sich der Schauspieler John Wilkes Booth , ein fanatischer Sympathisant der Südstaaten , Zutritt zur Loge des Präsidenten und schoss ihm aus nächster Distanz mit einer Deringer-Vorderladerpistole von hinten in den Kopf .
+Ärzte aus dem Publikum waren sofort zur Stelle , aber die Kugel ließ sich nicht entfernen .
+Da der Präsident nicht transportfähig war , wurde er in das Petersen House gebracht , ein Privathaus direkt gegenüber dem Theater .
+Dort starb Lincoln am folgenden Tag , dem 15. April , um 7:22 Uhr morgens , ohne das Bewusstsein noch einmal wiedererlangt zu haben .
+Andrew Johnson , seit März Lincolns Vizepräsident , legte noch am selben Tag den Amtseid als sein Nachfolger ab .
+Das Attentat war Teil einer größeren Verschwörung : Eine Gruppe von Südstaaten-Anhängern um Booth hatte geplant , neben Lincoln weitere Regierungsmitglieder zu ermorden .
+So verletzte Lewis Powell bei einem Mordanschlag Außenminister Seward schwer , ebenso dessen Sohn und weitere Mitglieder seines Haushalts .
+Der deutschstämmige George Atzerodt , der auf Vizepräsident Andrew Johnson angesetzt war , schreckte im letzten Moment vor dem Mord zurück .
+Booth , der sich nach dem Mord beim Sprung aus der Präsidentenloge das Bein verletzt hatte , gelang mit Hilfe eines weiteren Komplizen , David Herold , die Flucht nach Virginia .
+Dort wurde er am 26. April auf einer abgelegenen Farm gestellt und bei einem Schusswechsel getötet .
+Ein Militärgericht verurteilte Ende Juni Powell , Atzerodt , Herold und Booths Zimmerwirtin Mary Surratt , die der Mitwisserschaft verdächtigt wurde , zum Tode .
+Sie wurden am 7. Juli 1865 im Fort Lesley J. McNair in Washington durch Hängen hingerichtet .
+Lincolns Sarg wurde mit der Eisenbahn auf demselben Weg nach Springfield überführt , auf dem der neugewählte Präsident 1860 nach Washington gereist war .
+In allen größeren Städten wie New York und Chicago fanden Trauerprozessionen und - gottesdienste mit dem aufgebahrten Leichnam statt .
+Am 5. Mai 1865 wurde Abraham Lincoln auf dem Friedhof Oak Ridge Cemetery in seiner Heimatstadt Springfield beigesetzt .
+Am 23. Juni kapitulierten bei Fort Towson im Indianer-Territorium die letzten Truppen der Konföderation .
+Lincolns Vermächtnis , der 13. Verfassungszusatz , trat nach der Ratifizierung durch sämtliche Bundesstaaten am 18. Dezember 1865 in Kraft .
+Nachleben Datei :D ean Franklin - 06.04.03 Mount Rushmore Monument ( by-sa ) -2 new.jpg Datei : Lincoln statue , Lincoln Memorial.jpg Datei : US stamp 1903 5c Lincoln Sc304.jpg
+Als der Dichter Walt Whitman von Lincolns Tod erfuhr , widmete er ihm das Gedicht O Captain !
+My Captain !
+Es spricht von einem Kapitän , der sein Schiff durch große Gefahren sicher in den Hafen steuert , das Ziel aber selbst nicht lebend erreicht .
+Später verglich Whitman den Präsidenten , der an einem Karfreitag tödlich verwundet worden war , mit Jesus Christus .
+Dies sind nur zwei von vielen Beispielen für die bis zur Verklärung reichende Verehrung , die Abraham Lincoln bereits unmittelbar nach seiner Ermordung zuteilwurde .
+Mehr als die nüchterne Beurteilung seiner Präsidentschaft trugen dazu die Art seines Todes und der Vergleich mit den eher glanzlosen Regierungszeiten seiner ersten Amtsnachfolger bei .
+Zunächst nur in den Nordstaaten , mit wachsendem zeitlichem Abstand zum Bürgerkrieg aber in den ganzen USA , setzte sich das Bild von Lincoln als einem der bedeutendsten Präsidenten der US-Geschichte durch .
+Während die weißen Amerikaner in ihm den Bewahrer der Union sahen , betrachteten ihn die Afroamerikaner vor allem als den Sklavenbefreier .
+Auch ihr Bild von Lincoln war von religiöser Metaphorik geprägt .
+Schon bei seinem Besuch in Richmond kurz vor Kriegsende wurde Lincoln von den Schwarzen als „ Vater Abraham “ begrüßt .
+Später verglichen sie ihn mit Moses , der sie ins gelobte Land geführt habe , ohne es selbst zu betreten .
+Auch eher zurückhaltende Beobachter wie Frederick Douglass , der Lincoln während seiner Präsidentschaft unablässig wegen seiner zögerlichen Haltung in der Sklavenfrage kritisiert hatte , äußerten sich im Rückblick voller Respekt : Heute wird der Mitbegründer der Republikanischen Partei von Angehörigen aller ethnischen Gruppen verehrt , von Konservativen und Liberalen ebenso wie von Linken .
+In Umfragen unter Historikern und der US-Bevölkerung wird er gemeinsam mit George Washington und Franklin D. Roosevelt stets als einer der drei besten US-Präsidenten bewertet .
+Die Freiwilligenverbände aus den USA , die im Spanischen Bürgerkrieg auf Seiten der Republik gegen die Putschisten unter General Franco kämpften , nannten sich Abraham-Lincoln-Brigade .
+Zahlreiche Orte in den USA wurden nach dem Präsidenten benannt , von kleinen wie Fort Abraham Lincoln in North Dakota bis zu großen wie der Hauptstadt Nebraskas . Insgesamt tragen 17 Countys seinen Namen . Die US Navy taufte mehrere Schiffe auf den Namen des Präsidenten , u. a. den Flugzeugträger USS und das strategische Atom-U-Boot SSBN .
+Auch die Automarke Lincoln wurde 1917 von deren Begründer Henry M. Leland nach ihm benannt .
+Als Forschungsstätte wurde 1889 in Springfield die Illinois State Historical Library ins Leben gerufen , die – um ein Museum und weitere Einrichtungen erweitert – am 16. April 2005 als The Abraham Lincoln Presidential Library and Museum neu eröffnet wurde .
+Das Wohnhaus von Abraham Lincoln im historischen Zentrum Springfields steht unter der Obhut des U. S.
+National Park Service und ist heute ebenso ein Museum wie Lincolns Geburtsstätte in Kentucky , der Ort des Attentats – Ford ’ s Theatre – und das dem Theater gegenüberliegende Sterbehaus in Washington .
+Lincolns Bild ziert den 5-Dollar-Schein sowie die 1-Cent-Münze .
+In 10 US-Bundesstaaten wird Lincolns Geburtstag als offizieller Feiertag begangen .
+Zu seinen und George Washingtons Ehren wurde der nationale Feiertag „ Presidents Day “ eingeführt .
+Und neben den Köpfen George Washingtons , Thomas Jeffersons und Theodore Roosevelts wurde auch der Lincolns in die Felsen von Mount Rushmore in South Dakota gemeißelt .
+Der Komponist Aaron Copland schrieb 1942 das Tongedicht Lincoln Portrait mit einem gesprochenen Begleittext zu Ehren des 16. US-Präsidenten .
+Bereits 1922 war am Ufer des Potomac in Washington das Lincoln Memorial eingeweiht worden .
+Der klassizistische Tempelbau und das Kapitol markieren die beiden Enden der National Mall , der zentralen Achse der amerikanischen Hauptstadt .
+Die Gedenkstätte birgt eine Kolossalstatue Abraham Lincolns , die der Zeusstatue von Olympia nachempfunden ist .
+In ihre Südwand ist der Text der Gettysburg Address , in die Nordwand Lincolns zweite Amtsantrittsrede eingemeißelt .
+Seit ihrer Entstehung ist sie Schauplatz vieler großer Bürgerrechtsdemonstrationen gewesen .
+Martin Luther King hielt 1963 seine berühmte Rede I Have a Dream von den Stufen des Lincoln Memorials herab .
+In Lincolns 200.
+Geburtsjahr trat der erste afroamerikanische Präsident der USA sein Amt an .
+Barack Obama hatte seine Bewerbung als Präsidentschaftskandidat am 10. Februar 2007 vor dem alten Parlamentsgebäude in Springfield bekannt gegeben , in dem Lincoln 1858 seine bis heute nachwirkende House Divided Speech gehalten hatte .
+Sowohl bei seiner ersten als auch bei seiner zweiten Amtseinführung in den Jahren 2009 und 2013 legte der 44. Präsident der Vereinigten Staaten seinen Eid auf Lincolns Bibel ab .
+Werke Collected Works of Abraham Lincoln .
+8 Bände .
+Hg. von Roy Prentice Basler im Auftrag der Abraham Lincoln Association , Rutgers University Press , New Brunswick 1953 ( Korrespondenz , Reden und andere Schriften ) , ISBN 978-0-8135-0172-7 Speeches and Letters by Abraham Lincoln .
+Hg. von Merwin Roe , J. M. Dent , London 1909 , 1936 , 1949 ( Auswahlband ) Literatur Erich Angermann : Abraham Lincoln und die Erneuerung der nationalen Identität der Vereinigten Staaten von Amerika ( = Schriften des Historischen Kollegs .
+Vorträge .
+Band 7 ) .
+Stiftung Historisches Kolleg , München 1984 ( Digitalisat ) .
+Michael Burlingame : Lincoln A Life Volume One and Two , Baltimore 2013 , ISBN 978-1-4214-0973-3 , ISBN 978-1-4214-1058-6 David Herbert Donald : Lincoln .
+Simon & Schuster , New York 1995 , ISBN 0-684-80846-3 . Shel by Foote : The Civil War .
+A Narrative
+.
+Bd. 1–3 . New York 1974 , Pimlico , London 1992–2001 , ISBN 0-7126-9812-4 . Henry Louis Gates , Jr. , Donald Yacovone : Lincoln on Race & Slavery .
+Princeton University Press , Princeton 2009 , ISBN 978-0-691-14234-0 . Ronald D. Gerste : Abraham Lincoln .
+Begründer des modernen Amerika
+.
+Verlag Friedrich Pustet , Regensburg 2008 , ISBN 978-3-7917-2130-9 . Doris Kearns Goodwin : Team of Rivals .
+The Political Genius of Abraham Lincoln
+.
+Penguin Books , London 2013 , ISBN 978-0-241-96608-2 . John Hay , John George Nicolay : Abraham Lincoln : A History ( 10 Bände ) .
+The Century Magazine , New York 1890 Ibram X. Kendi : Gebrandmarkt .
+Die wahre Geschichte des Rassismus in Amerika
+, Verlag C. H. Beck , München 2017 Austin Augustus King ( Hrsg. ) : Lincoln letters .
+Bibliophile Society , Boston 1913 ( Digitalisat ) .
+Jürgen Kuczynski : Abraham Lincoln .
+Akademie Verlag , Berlin / Köln 1985 , ISBN 3-7609-0971-X . Gordon Leidner ( Hrsg. ) : Abraham Lincoln : Quotes , Quips and Speeches .
+Sourcebooks Inc . , Naperville , Illinois , U. S. A.
+2009 , ISBN 978-1-4022-6912-7 . , ( Digitalisat ) ; Deutsche Ausgabe : Gordon Leidner ( Hg. ) : Abraham Lincoln : Vermächtnisse .
+Deutsche Übersetzung : Ursula Maria Ewald , Leonhard-Thurneysser-Verlag Berlin & Basel 2015 , ISBN 978-3-946194-00-2 Pantagraph Printing & Stationery Co. , Bloomington 1910 . James M. McPherson : Für die Freiheit sterben – Die Geschichte des amerikanischen Bürgerkriegs .
+List , München / Leipzig 1988 , 1995 , ISBN 3-471-78178-1 . James M. McPherson : Abraham Lincoln .
+Oxford University Press , New York 2009 , ISBN 978-0-19-537452-0 . Jörg Nagler : Abraham Lincoln ( 1861–1865 ) .
+Bewahrung der Republik und Wiedergeburt der amerikanischen Nation
+.
+In : Die amerikanischen Präsidenten .
+41 historische Portraits von George Washington bis Bill Clinton
+.
+Hg. v. Jürgen Heideking und Christoph Mauch , C. H. Beck , München 1995 , S. 176–193 , 2005 , ISBN 3-406-39804-9 , ISBN 3-406-53147-4 . Jörg Nagler : Abraham Lincoln .
+Amerikas großer Präsident .
+Eine Biographie .
+C. H. Beck , München 2009 , ISBN 978-3-406-58747-4 . David Allen Nichols : Lincoln and the Indians .
+Civil War Policy and Politics
+.
+University of Missouri Press 1978 , Nachdruck 2000 . Stephen B. Oates : With Malice Toward None .
+A Life Of Abraham Lincoln
+.
+Harper & Raw , New York 1977 , 1996 , ISBN 0-06-013283-3 . Bill O’Reilly , Martin Dugard : Killing Lincoln .
+Henry Holt & Company , New York 2011 , ISBN 978-0-8050-9307-0 . Philip Shaw Paludan : The Presidency of Abraham Lincoln .
+Univ. Press of Kansas , Lawrence 1994 , ISBN 0-7006-0671-8 . William Armstrong Percy : The Intimate World of Abraham Lincoln .
+Free Press , 2005 ( gemeinschaftlich mit Lewis Gannett ) .
+James G. Randall : Lincoln the President .
+4 Bände .
+Dodd Mead , New York 1945 bis 1955 ( vollendet durch Richard Current ) , University of Illinois Press , 2000 . Carl Sandburg : Abraham Lincoln : The Prairie Years . 2 Bände , Harcourt , Brace & Company , New York 1926 . Carl Sandburg : Abraham Lincoln : The War Years . 4 Bände , Harcourt , Brace & Company , New York 1939 ( gewann den Pulitzer-Preis 1940 ) .
+Carl Sandburg : Abraham Lincoln .
+Das Leben eines Unsterblichen
+.
+Paul Zsolnay , Hamburg / Wien 1958 , Heyne , München 1984 , ISBN 3-453-55118-4 . Peter Schäfer , Ulrike Skorsetz : Die Präsidenten der USA in Lebensbildern .
+Von George Washington bis George W. Bush
+.
+Komet , Köln 2005 , ISBN 3-89836-450-X . James L. Swanson : Manhunt .
+The 12-Day Chase for Lincoln ’ s Killer
+.
+Harper Perennial , ISBN 978-0-06-051849-3 . Belletristik Eleanor Atkinson : „ Der junge Lincoln “ , aus dem Amerikanischen übersetzt von Heide Schulz , Hyperion-Verlag , 2018 , ISBN 978-3-89914-060-6 ( Novelle ) ; Originalausgabe : Lincoln`s Love Story , New York 1909 . George Saunders : Lincoln in the Bardo .
+Random House , New York 2017 , ISBN 978-0-8129-9534-3 ( Roman ) Gore Vidal : Lincoln .
+Hamburg : Hoffmann und Campe , 1985 .
+Übersetzung Christian Spiel , Rudolf Hermstein .
+ISBN 3-442-72912-2 ( Roman , englisch zuerst 1984 ) .
+Verfilmungen Seit 1911 ist Abraham Lincoln in fast 350 Filmen und Fernsehsendungen von Schauspielern dargestellt worden , unter anderem von Walter Huston , Henry Fonda , Raymond Massey , Hal Holbrook , Sam Waterston , Lance Henriksen , Daniel Day-Lewis und – besonders häufig ( zehn Mal ) – von Frank McGlynn senior .
+Day-Lewis erhielt für seine Hauptrolle in Steven Spielbergs Film Lincoln einen Oscar .
+Die wichtigsten Spiel- und Dokumentarfilme mit und über Lincoln sind : D. W. Griffith : Abraham Lincoln , 1930 , Spielfilm John Ford : Der junge Mr. Lincoln , 1939 , Spielfilm John Cromwell : Abe Lincoln in Illinois , 1940 , Spielfilm George Schaefer : Lincoln , 1974 , Fernsehserie Lamont Johnson : Lincoln , 1988 , Miniserie Peter W. Kunhardt : Lincoln , 1992 , Fernsehfilm Ken Burns : The Civil War .
+Der Amerikanische Bürgerkrieg
+.
+WDR / CS Associates , 1996 , Dokumentarserie John Gray : Abraham Lincoln – Die Ermordung des Präsidenten ( The Day Lincoln Was Shot ) , 1998 , Fernsehfilm Robert Redford : Die Lincoln Verschwörung , 2010 , Spielfilm Steven Spielberg : Lincoln , 2012 , Spielfilm Adrian Moat : Tom Hanks : Die Lincoln-Verschwörung ( Killing Lincoln ) , 2013 , Fernsehfilm , National Geographic Channel
+Weblinks Abraham Lincoln Papers at the Library of Congress
+Mr.
+Lincoln ’ s White House
+( englisch ) Mr.
+Lincoln and Freedom
+( engl. ) Abraham Lincoln Research Site ( engl. ) Abraham Lincoln Assassination ( engl. ) Mr.
+Lincoln and Friends
+( engl. ) Mr.
+Lincoln and New York
+( engl. ) Biografie auf der Website des ( engl. ) Lincoln ’ s death too sad to describe ( The Guardian , 14. April 1865 , Originalbericht ) Abraham Lincoln online ( engl. ) The Lincoln Institute ( engl. ) Miller Center of Public Affairs der University of Virginia ( englisch , Redakteur : Michael Burlingame ) Lincoln Home National Historic Site Springfield , Illinois ( engl. ) Lincoln Memorial Washington , D. C. ( engl. ) The Alfred Whital Stern Collection of Lincolniana , American Memory ( engl. ) Joseph Kay : In : World Socialist Web Site . 5. Mai 2001 . Ronald D. Gerste : In : NZZ . 8. Juli 2014 . Einzelnachweise David Herbert Donald : Lincoln . Simon & Schuster , 1st Touchstone Ed ( 5. November 1996 ) . Man hielt sie für eine Infektionskrankheit , tatsächlich aber wurde sie durch die Milch von Kühen ausgelöst , in deren Futter sich Ageratina altissima befand , eine giftige Pflanze , die auch als „ White Snakeroot “ bekannt war . Karen M. Kostyal : Abraham Lincoln ’ s extraordinary era : the man and his times . National Geographic , Washington , D. C. 2009 , S. 24. Jörg Nagler : Abraham Lincoln . Amerikas großer Präsident – Eine Biographie . C. H. Beck , München 2009 , S. 32. Shirley Samuels ( Hrsg. ) : The Cambridge companion to Abraham Lincoln . Cambridge University Press , Cambridge 2012 , S. 17. Jörg Nagler : Abraham Lincoln . Amerikas großer Präsident – Eine Biographie . C. H. Beck , München 2009 , S. 33. Francis Marion Van Natter : Lincoln ’ s Boyhood . A Chronicle of his Indiana Years . Public Affairs Press , Washington , D. C. 1963 , S. 102. William R. Denslow , Harry S. Truman : 10,000 Famous Freemasons from K to Z , ISBN 1-4179-7579-2 . The Lehrman Institute : Abraham Lincoln and Friends – The Boys . Jonathan Byron ( Hrsg. ) , Philip Militz ( Autor ) : Freimaurer in 60 Minuten . Thiele , München 2009 . In : Associated Press . 25. Dezember 1985 , abgerufen am 8. Februar 2014 . Richard Carwardine : Lincoln . A Life of Purpose and Power . Vintage Books , New York 2006 , S. 57 f. ; Jörg Nagler : Abraham Lincoln . Amerikas großer Präsident – Eine Biographie . C. H. Beck , München 2009 , S. 84 f. Howard Zinn : A People ’ s History of the United States . Harper Perennial , 2005 , S. 153–154 , ISBN 0-06-083865-5 . Richard Carwardine : Lincoln . A Life of Purpose and Power . Vintage Books , New York 2006 , S. 49 f. Howard Zinn : Eine Geschichte des amerikanischen Volkes , Schwarzerfreitag GmbH , Berlin 2007 , S. 169 Sven Beckert : King Cotton . Eine globale Geschichte des Kapitalismus , C. H. Beck , München 2014 , S. 112–114 Ibram X. Kendi : Gebrandmarkt . Die wahre Geschichte des Rassismus in Amerika , C. H. Beck , München 2017 , S. 224 Ibram X. Kendi : Gebrandmarkt . Die wahre Geschichte des Rassismus in Amerika , C. H. Beck , München 2017 , S. 198 f Stephen B. Oates : With Malice Toward None . A Life of Abraham Lincoln , HarperCollins , New York 1994 , S. 46 Jörg Nagler : Abraham Lincoln . Amerikas großer Präsident – Eine Biographie . C. H. Beck , München 2009 , S. 174. Stephen B. Oates : With Malice Toward None . A Life of Abraham Lincoln , HarperCollins , New York 1994 , S. 125 f Ibram X. Kendi : Gebrandmarkt . Die wahre Geschichte des Rassismus in Amerika , C. H. Beck , München 2017 , S. 230 Jörg Nagler : Abraham Lincoln . Amerikas großer Präsident – Eine Biographie . C. H. Beck , München 2009 , S. 184. Carl Sandburg : Abraham Lincoln . Das Leben eines Unsterblichen , Hamburg / Wien 1958 , S. 174 Richard Carwardine : Lincoln . A Life of Purpose and Power . Vintage Books , New York 2006 , S. 61 f. Michael Butter : „ Nichts ist , wie es scheint “ . Über Verschwörungstheorien . Suhrkamp , Berlin 2018 , S. 30 f. Jörg Nagler , Abraham Lincoln . Amerikas großer Präsident . Eine Biographie , C. H. Beck , München 2009 , S. 175. Shel by Foote : The Civil War . A Narrative . Vol . 1 : Fort Sumter to Perryville , Pimlico , London 1994 , S. 31 Howard Zinn : A People ’ s History of the United States . Harper Perennial , 2005 , ISBN 0-06-083865-5 , S. 188. Stephen B. Oates : With Malice Toward None : a Life of Abraham Lincoln . Amer Political Biography Pr , 2002 , ISBN 978-0-945707-32-5 , S. 38. Richard Carwardine : Lincoln . A Life of Purpose and Power . Vintage Books , New York 2006 , S. 88. Jörg Nagler : Abraham Lincoln : Amerikas großer Präsident – Eine Biographie . Erste , durchgesehene Auflage in der Beck ’ schen Reihe . C. H. Beck , München 2011 , ISBN 978-3-406-62215-1 , S. 203–205 . Doris Kearns Goodwin : Team of Rivals . The Political Genius of Abraham Lincoln . London 2013 , S. 10. http://www.phillipsandcohen.com/False-Claims-Act-History/ ; abgerufen am 7. April 2016 Anne Sarah Rubin : A Shattered Nation : The Rise and Fall of the Confederacy , 1861-1868 . University of North Carolina , Chapel Hill 2005 , ISBN 0-8078-2928-5 , S. 14. In : Texas State Library and Archives Commission . 25. August 2011 . zit. nach Ibram X. Kendi : Gebrandmarkt . Die wahre Geschichte des Rassismus in Amerika , Verlag C. H. Beck , München 2017 , S. 233 Howard Zinn : A People ’ s History of the United States . Harper Perennial , 2005 , S. 189. In : mrlincolnandfreedom.org . Abgerufen am 9. Juli 2010 . Zum Thema Lincoln und die Indianerpolitik der Vereinigten Staaten vgl. David A. Nichols : Lincoln and the Indians : Civil War Policy and Politics . University of Missouri Press , Columbia 1978 ; und Thomas J. DiLorenzo : Lincoln Unmasked : What You ’ re Not Supposed to Know about Dishonest Abe . Crown Forum , New York 2006 . David A. Nichols : Lincoln and the Indians : Civil War Policy and Politics . University of Missouri Press , Columbia 1978 , S. 99 f. Robert K. Elder : In : New York Times . 13. Dezember 2010.2010 entstand ein Film zu dem Ereignis unter dem Titel Dakota 38 ( s. a. Dakota38 ) . David A. Nichols : Lincoln and the Indians : Civil War Policy and Politics . Nachdruck der Ausgabe von 1978 , Illini Books , 2000 , S. 117 f. S. L. A. Marshall : Crimsoned Prairie : The Indian Wars , Da Capo Press , New York 1972 , S. 37. Richard W. Etulain ( Hrsg. ) : Lincoln Looks West . From the Mississippi to the Pacific . Southern Illinois University 2010 , S. 43. FAZ . net . 14. April 2015 , abgerufen am 29. April 2017 . Charles Curry Aiken , Joseph Nathan Kane : The American Counties : Origins of County Names , Dates of Creation , Area , and Population Data , 1950–2010 . 6. Auflage . Scarecrow Press , Lanham 2013 , ISBN 978-0-8108-8762-6 , S. xiv . In : Focus . 23. Dezember 2008 ( zu Obamas Vereidigung ) . 
+
+Datei : IndianSummerSauerland.jpg Altweibersommer ist in deutschsprachigen Ländern die Bezeichnung für eine meteorologische Singularität .
+Es handelt sich um eine Phase gleichmäßiger Witterung im Spätjahr , oft im September , die durch ein stabiles Hochdruckgebiet und ein warmes Ausklingen des Sommers gekennzeichnet ist .
+Das kurzzeitig trockenere Wetter erlaubt eine gute Fernsicht , intensiviert den Laubfall und die Laubverfärbung .
+Ähnliche Phänomene werden auch in anderen Ländern beobachtet .
+Wortherkunft Die Herkunft des Wortes ist nicht sicher , zumal neben dem Begriff Altweibersommer auch zahlreiche weitere wie Ähnlsummer , Frauensommer , Mädchensommer , Mettensommer , Mettkensommer , Metjensommer , Nachsommer , Witwensommer , Michaelssommer , Martinssommer , Allerheiligensommer und fliegender Sommer vorkommen , was die sprachgeschichtliche Deutung erschwert .
+Datei : Spinnennetze im Altweibersommer.jpg Nach der einen Erklärung leitet sich der Name von Spinnfäden her , mit denen junge Baldachinspinnen im Herbst durch die Luft segeln .
+Der Flugfaden , den die Spinnen produzieren und auf dem sie durch die Luft schweben , erinnert die Menschen an das graue Haar alter Frauen .
+Mit „ weiben “ wurde im Althochdeutschen das Knüpfen der Spinnweben bezeichnet .
+Nach der anderen Erklärung , in der von Kluge / Seebold die „ vielleicht “ ursprüngliche , von Pfeifer hingegen „ wahrscheinlicher “ eine sekundäre Bedeutung gesehen wird , liegt dem Wort das Motiv der zweiten Jugend bei Frauen , die als unzeitig und nur kurze Zeit dauernd angesehen wird , zugrunde .
+An diese letztere Deutung können das schweizerische Witwesömmerli und der bairische Ähnlsummer ( ‚ Großvatersommer ‘ ) angeschlossen werden , vielleicht liegt aber auch das Bild des alten , schwachen Sommers vor .
+Andere Begriffe für das Phänomen der milden Herbsttage kann man einfacher deuten , sie sind jedoch zum Teil lediglich weitere sekundäre Interpretationen der – unsicheren – Urbedeutung .
+So nennt man in norddeutschen Dialekten den Altweibersommer Mettkensommer und ähnlich , die Altweibersommerfäden Metten , Mettken oder Mettjen .
+Dabei liegt eine Verkleinerungsform von Made vor , das heißt , man hielt sie für Raupengespinste .
+Wegen der lautlichen Ähnlichkeit wurde dieser Begriff wohl volksetymologisch zu Mädchen umgedeutet .
+Auf bestimmte Tage wiederum beziehen sich die Wörter ( St. ) Michaelssommer ( 29. September ) , Allerheiligensommer ( 1. November ) und ( St. ) Martinssommer ( 11. November ) .
+Das Landgericht Darmstadt hat im Jahr 1989 festgestellt , dass die Verwendung des Ausdrucks Altweibersommer durch die Medien keinen Eingriff in die Persönlichkeitsrechte von älteren Damen darstellt .
+Altweibersommer in anderen Ländern In Ungarn , Polen , Tschechien , der Slowakei , Slowenien und Russland nennt man diese Zeit ähnlich wie im Deutschen Altweibersommer ( ung. vénasszonyok nyara , poln. babie lato , tschech .
+babí léto , slowak .
+babie leto , slowen .
+babje poletje oder babje leto , russ. babje leto ) .
+In Nordamerika , insbesondere in den Neuenglandstaaten , wird diese Wetterlage Indian Summer ( Québec : été indien ) genannt – im Deutschen oft mit der herbstlichen Laubfärbung verwechselt .
+In Frankreich wurde der Begriff été indien 1975 durch ein gleichnamriges Lied von Joe Dassin popularisiert .
+Früher sprach man eher von été de la Saint-Denis ( 9. Oktober ) , été de la Saint-Géraud ( 13. Oktober ) oder été de la Saint-Martin ( 11. November ) .
+Ähnlich spricht man in Finnland von Ruska-Aika ( Zeit der Braunfärbung ) und in Schweden vom brittsommar ( Birgitta-Sommer ) .
+In Skandinavien kommen Erscheinungen der aufkommenden Polarnacht hinzu .
+In der Übergangsphase von der Mitternachtssonne zur Polarnacht macht der Spätsommer mit seiner prachtvollen Laubfärbung Ausflüge in die Natur besonders attraktiv .
+Die Ruska-Saison ist für viele einheimische Naturfreunde der Höhepunkt des Jahres und Auslöser für einen intensiven Tourismus ins nördliche Lappland , den nördlichsten Teil Europas am Polarkreis .
+In den Mittelmeerländern ist die späte Warmperiode , dort im November , als St. - Martins-Sommer bekannt .
+In der Türkei wird die Wetterperiode als pastırma yazı ( Pastırma-Sommer ) bezeichnet .
+Die Bezeichnung kommt von der Pastırma-Herstellung .
+Pastırma ist ein getrocknetes Rinderfilet , von würziger Paste umgeben , das im Spätsommer von türkischen Metzgern vorbereitet und traditionell unter dem Hausdach an der warmen Luft zum Trocknen aufgehängt wird .
+In Japan wird ein warmer später Sommer als „ kleiner Frühling “ ( koharu 小春 ) bezeichnet .
+Das darauf folgende Momijigari beschreibt die Sitte , bei angenehmem Herbstwetter Landschaften und Parks mit schöner herbstlicher Laubfärbung , insbesondere von Ahornbäumen und - wäldern , zu besuchen .
+Volksglauben und Wetterregeln Im Volksglauben wurden die Spinnweben der Baldachinspinnen auch für Gespinste von Elfen , Zwergen oder der Nornen gehalten .
+Als Verursacherin galt aber auch die Jungfrau Maria , die zusammen mit 11.000 Jungfrauen das Land alljährlich um diese Zeit mit Seide überspinnen würden .
+Daher rühren auch Bezeichnungen dieser Spinnfäden wie Marienhaar , Mariengarn , Marienfaden , Marienseide , Herbstgarn , Sommerseide , Herbstfäden , Liebfrauenfäden , Unserer Lieben Frauen Gespinst , Mutter Gottes Gespinst .
+Im Volksglauben nahm man an , dass es Glück bringe , wenn sich die Fäden an der Kleidung des Menschen heften würde und wer sie mit sich herumträgt , würde berühmt werden .
+Ebenso würden sie eine baldige Hochzeit verheißt , wenn sich fliegende Spinnfäden im Haar eines jungen Mädchens verfangen .
+Der Altweibersommer hat in verschiedenen Bauernregeln seinen Niederschlag gefunden , die gutes Wetter verheißen und auf einen angenehmen Herbst schließen lassen .
+1. November : Ist ’ s zu Allerheiligen rein , tritt Altweibersommer ein .
+15. November : Der heilige Leopold ist oft noch dem Altweibersommer hold .
+Literatur Artur Lehmann : Altweibersommer .
+Die Wärmerückfälle des Herbstes in Mitteleuropa .
+Parey , Berlin 1911 ( Zugleich : Berlin , Univ. , Diss . , 1911 ) , auch in : Landwirtschaftliche Jahrbücher 41 , 1911 , , S. 57–129 . Weblinks Altweibersommer , dann bleibt der Herbst trocken .
+Der „ Altweibersommer “ ist nicht frauenfeindlich
+Christoph Landolt : , in : Wortgeschichten vom 25. September 2013 , herausgegeben von der Redaktion des Schweizerischen Idiotikons .
+Einzelnachweise Das Folgende nach Kluge . Etymologisches Wörterbuch der deutschen Sprache , bearbeitet von Elmar Seebold . 25. , durchgesehene und erweiterte Auflage Berlin 2011 ; Etymologisches Wörterbuch des Deutschen , erarbeitet unter der Leitung von Wolfgang Pfeifer . 2. , durchgesehene und ergänzte Auflage Berlin 1993 ; Deutsches Wörterbuch von Jacob Grimm und Wilhelm Grimm , Neubearbeitung , 2. Band Leipzig 1998 ; Wortgeschichten , verfasst von der Redaktion des Schweizerischen Idiotikons , Text vom 25. September 2013 . LG Darmstadt , Az. 3 O 535/88 , Urteil vom 2. Februar 1989 ; NJW 1990 , S. 1997 . Handbuch des Aberglaubens . ISBN 3-85001-570-X , Band 1 , S. 45. 
+
+Datei : Besuch Bundeskanzlerin Angela Merkel im Rathaus Köln-09916.jpg Datei : Angela Merkel Signature.svg Angela Dorothea Merkel ( * 17. Juli 1954 in Hamburg als Angela Dorothea Kasner ) ist eine deutsche Politikerin ( CDU ) .
+Sie ist seit dem 22. November 2005 Bundeskanzlerin der Bundesrepublik Deutschland .
+Vom 10. April 2000 bis zum 7. Dezember 2018 war sie CDU-Bundesvorsitzende .
+Im Oktober 2018 erklärte sie , sich spätestens mit Ablauf der Legislaturperiode 2021 aus der Politik zurückzuziehen .
+Merkel wuchs in der DDR auf und war dort als Physikerin am Zentralinstitut für Physikalische Chemie tätig .
+Bei der Bundestagswahl am 2. Dezember 1990 errang sie erstmals ein Bundestags mandat .
+Bei den folgenden sieben Bundestagswahlen wurde sie in ihrem Wahlkreis in Vorpommern direkt gewählt . Von 1991 bis 1994 war Merkel Bundesministerin für Frauen und Jugend im Kabinett Kohl IV und von 1994 bis 1998 Bundesministerin für Umwelt , Naturschutz und Reaktorsicherheit im Kabinett Kohl V.
+1998 bis zu ihrer Wahl zur Bundesvorsitzenden der Partei amtierte sie als Generalsekretärin der CDU .
+Nach dem knappen Sieg der Unionsparteien bei der vorgezogenen Bundestagswahl 2005 löste Merkel Gerhard Schröder als Bundeskanzler ab und führte zunächst eine große Koalition mit der SPD bis 2009 ( Kabinett Merkel I ) .
+Nach der Bundestagswahl 2009 ging sie mit der FDP eine schwarz-gelbe Koalition ein ( Kabinett Merkel II ) , der 2013 eine erneute große Koalition folgte , die auch nach der Bundestagswahl 2017 fortgesetzt wird ( Kabinett Merkel III und IV ) .
+Leben Elternhaus und frühe Kindheit ( 1954–1960 ) Angela Merkel wurde im Elim-Krankenhaus im Hamburger Stadtteil Eimsbüttel als erstes Kind des evangelischen Theologen Horst Kasner ( * 26. August 1926 in Berlin ; † 2. September 2011 ebenda ) und seiner Frau Herlind Kasner , geb. Jentzsch ( * 8. Juli 1928 in Danzig ; † 6. April 2019 in Berlin ) , geboren .
+Horst Kasner hatte ab 1948 an den Universitäten Heidelberg und Hamburg sowie an der Kirchlichen Hochschule Bethel in Bielefeld Theologie studiert .
+Seine Frau Herlind war Lehrerin für Latein und Englisch .
+Noch 1954 , einige Wochen nach der Geburt der Tochter , siedelte die Familie von Hamburg in die DDR über .
+Für die Evangelische Kirche in Berlin-Brandenburg trat Horst Kasner im Dorf Quitzow ( heute ein Ortsteil von Perleberg ) eine Pfarrstelle an .
+Angela Merkel ist ebenfalls evangelisch .
+1957 wechselte Kasner dauerhaft nach Templin in der Uckermark , um sich am Aufbau einer innerkirchlichen Weiterbildungsstelle zu beteiligen .
+Dort wuchs Angela Merkel auf .
+Ihre Mutter war aufgrund des Pfarrberufs des Vaters im Schuldienst der DDR unerwünscht . Am 7. Juli 1957 wurde Angelas Bruder Marcus , am 19. August 1964 ihre Schwester Irene geboren .
+In Polen erregte 2013 die Entdeckung ihrer polnischen Wurzeln Aufmerksamkeit : Ihr Großvater , der Polizeibeamte Ludwig Kasner ( 1896–1959 ) , hatte als Ludwig Kazmierczak als Angehöriger der polnischen Bevölkerungsgruppe im Deutschen Kaiserreich in Posen gelebt , im Ersten Weltkrieg erst für die deutsche und dann für die polnische Haller-Armee an der Westfront gekämpft sowie von 1919 bis 1921 an der Ostfront für Polen gegen die Ukraine und die Sowjetunion im Polnisch-Ukrainischen Krieg und Polnisch-Sowjetischen Krieg . Er war später nach Berlin übergesiedelt .
+Schulzeit und Studium ( 1961–1978 ) 1961 wurde Angela Kasner an der Polytechnischen Oberschule ( POS ) in Templin eingeschult .
+Auffallend waren ihre überdurchschnittlichen schulischen Leistungen , in den Schulfächern Russisch und Mathematik war Kasner stets Klassenbeste .
+Sie gewann Russisch-Olympiaden bis hin zur DDR-Ebene und galt während ihrer Schulzeit als zurückhaltende Schülerin . Sie war Mitglied der Freien Deutschen Jugend ( FDJ ) . 1973 legte sie an der Erweiterten Oberschule ( EOS ) in Templin das Abitur mit der Durchschnittsnote 1,0 ab .
+Kasner hatte sich bereits während ihrer Schulzeit für das Studium der Physik an der Karl-Marx-Universität ( heute : „ Universität Leipzig “ ) in Leipzig entschieden , das sie 1973 aufnahm .
+Sie gehörte nicht zu den opponierenden Kräften innerhalb der DDR , was ihre akademische Laufbahn verhindert hätte , berichtet aber , in diesen Jahren den Autor Reiner Kunze getroffen zu haben , den sie als ihren Lieblingsschriftsteller bezeichnet .
+1977 heiratete sie den Physikstudenten Ulrich Merkel ; die Ehe wurde 1982 geschieden .
+Angela Merkels Diplomarbeit aus dem Juni 1978 mit dem Titel Der Einfluß der räumlichen Korrelation auf die Reaktionsgeschwindigkeit bei bimolekularen Elementarreaktionen in dichten Medien wurde mit „ sehr gut “ bewertet .
+Die Arbeit war zugleich ein Beitrag zum Forschungsthema Statistische und Chemische Physik von Systemen der Isotopen- und Strahlenforschung im Bereich statistische und physikalische Chemie am Zentralinstitut für Isotopen- und Strahlenforschung der Akademie der Wissenschaften der DDR ( AdW ) .
+Akademie der Wissenschaften in Ost-Berlin ( 1978–1989 ) Nachdem 1978 eine Bewerbung an der Technischen Hochschule Ilmenau gescheitert war , ging Merkel mit ihrem Mann nach Ost-Berlin .
+Hier nahm sie eine Stelle am Zentralinstitut für Physikalische Chemie ( ZIPC ) der Akademie der Wissenschaften der DDR in Berlin-Adlershof an . 1986 konnte sie für mehrere Tage in die Bundesrepublik reisen .
+Sie nahm in Donezk an einem mehrwöchigen russischen Sprachkurs teil .
+Am Zentralinstitut arbeiteten rund 650 Personen , davon etwa 350 Wissenschaftler .
+Merkel arbeitete in der Abteilung Theoretische Chemie .
+Während der Arbeit an ihrer Dissertation nutzte Merkel die Gelegenheit , einige der Berechnungen bei der Tschechoslowakischen Akademie der Wissenschaften in Prag durchzuführen , da diese einen leistungsfähigen IBM-Großrechner besaß , den es in der DDR damals nicht gab .
+Am 8. Januar 1986 reichte sie ihre Dissertation mit dem Thema Untersuchung des Mechanismus von Zerfallsreaktionen mit einfachem Bindungsbruch und Berechnung ihrer Geschwindigkeitskonstanten auf der Grundlage quantenchemischer und statistischer Methoden ein . Die Arbeit wurde mit „ sehr gut “ ( magna cum laude ) bewertet . Nach der Promotionsordnung musste dem Antrag auf Promotion der Nachweis beigefügt werden , dass die während des Studiums erworbenen Kenntnisse des Marxismus-Leninismus ( „ ML “ ) wesentlich vertieft und erweitert worden waren . Merkel fertigte zum Nachweis eine schriftliche Arbeit mit dem Titel Was ist sozialistische Lebensweise ? an , die mit „ genügend “ ( rite ) bewertet wurde . Doktorvater war der Leiter der Abteilung Theoretische Chemie am ZIPC Lutz Zülicke .
+Nach der Promotion zum Doktor der Naturwissenschaften ( Dr. rer. nat. ) wechselte Merkel innerhalb des Instituts in den Bereich Analytische Chemie , in dem Klaus Ulbricht ihr Abteilungsleiter wurde .
+Merkel war weder Mitglied der SED noch einer der Blockparteien .
+Sie war nicht in der zivilen oder der kirchlichen Opposition aktiv .
+Während ihrer Tätigkeit für die Akademie der Wissenschaften engagierte sie sich in ihrer FDJ-Gruppe .
+Nach eigenen Angaben war Merkel dort als Kulturreferentin tätig .
+Zeitzeugen , die der Merkel-Biograf Gerd Langguth befragt hat , sprachen davon , sie sei für „ Agitation und Propaganda “ zuständig gewesen .
+Familie Während ihres Physikstudiums in Leipzig lernte Angela Kasner im Jahr 1974 bei einem Jugendaustausch mit Physikstudenten in Moskau und Leningrad ihren ersten Ehemann , den aus Cossengrün stammenden Physikstudenten Ulrich Merkel , kennen . Am 3. September 1977 wurden die beiden in Templin kirchlich getraut .
+1981 trennte sich das Paar und die kinderlose Ehe wurde 1982 in Ost-Berlin geschieden .
+Im Jahr 1984 lernte Merkel an der Akademie der Wissenschaften der DDR in Berlin-Adlershof den Quantenchemiker Joachim Sauer kennen , den sie am 30. Dezember 1998 heiratete .
+Aus der Ehe gingen keine gemeinsamen Kinder hervor , Sauer brachte zwei Söhne aus erster Ehe mit in die Partnerschaft .
+Das Ehepaar zog von der Luisenstraße , in unmittelbarer Sichtweite des Reichstags , in eine Wohnung Am Kupfergraben in der Nähe der Humboldt-Universität um , in der es weiterhin lebt .
+Freizeit Seit 1985 besitzen Angela Merkel und Joachim Sauer ein Wochenendhaus in Hohenwalde , einem Ortsteil von Milmersdorf in der Uckermark .
+Ihren Urlaub verbringt sie mit ihrem Mann seit Jahren an denselben Orten : zu Ostern auf der Insel Ischia im Golf von Neapel , im Sommer zum Wandern in Sulden im Vinschgau / Südtirol und im Winter zum Skilanglauf in Pontresina im Schweizer Engadin .
+Angela Merkel und ihr Mann sind Opernliebhaber und besuchen regelmäßig Premierenvorstellungen der Bayreuther Wagner-Festspiele .
+Politische Laufbahn Demokratischer Aufbruch ( 1989–1990 ) Während der Wende in der DDR im Herbst 1989 zeichnete sich ab , dass im Osten Deutschlands neue , demokratische Parteistrukturen entstehen würden .
+Zuvor hatte sie die Absicht , der SPD beizutreten , da sie jedoch zuerst eine Mitgliedschaft in einem Ortsverband beantragen musste , dies jedoch Angela Merkel nicht zusagte , begann sie im Dezember 1989 beim neu gegründeten Demokratischen Aufbruch ( DA ) zu arbeiten , zunächst im Dezember / Januar noch unentgeltlich als provisorische Systemadministratorin , ab 1. Februar 1990 dann hauptberuflich als Sachbearbeiterin in der persönlichen Arbeitsumgebung des Vorsitzenden Wolfgang Schnur in der Ost-Berliner Geschäftsstelle . Später folgten der Entwurf von Flugblättern , die Ernennung zur Pressesprecherin durch ihren Entdecker Schnur und die Mitgliedschaft im Vorstand des DA .
+Der Demokratische Aufbruch schwankte zunächst noch stark in den politischen Perspektiven und galt eine Zeitlang wie die anderen Vereinigungen der Bürgerbewegung ( Neues Forum , Demokratie Jetzt ) prinzipiell als links .
+Bald brach sich aber eine Haltung Bahn , die den Sozialismus grundsätzlich ablehnte .
+Dies verstärkte sich , als Anfang 1990 konservative westdeutsche Politiker auf die erste demokratische Volkskammerwahl am 18. März 1990 hinarbeiteten und Volker Rühe als Generalsekretär der westdeutschen CDU am 5. Februar 1990 das Wahlbündnis Allianz für Deutschland begründete .
+Der DA nahm darin als neu gegründete Bürgerbewegung eine Schlüsselstellung ein : Helmut Kohl , der Bundeskanzler und CDU-Vorsitzende , wollte nicht allein auf die Ost-CDU ( die als Blockpartei vorbelastet war ) oder die der CSU nahestehende Deutsche Soziale Union ( DSU ) setzen .
+Das Ansehen des DA wurde erheblich geschädigt , als wenige Tage vor der Volkskammer-Wahl bekannt wurde , dass Schnur von 1965 bis 1989 für das Ministerium für Staatssicherheit ( MfS ) tätig gewesen war .
+Merkel leitete die Pressekonferenz , auf der der DA-Vorstand seine Betroffenheit darüber äußerte .
+Allianz für Deutschland ( 1990 ) Die erste freie Volkskammerwahl am 18. März 1990 endete für Merkels Demokratischen Aufbruch ( DA ) mit einem 0,9-Prozent - Desaster .
+Dank der unerwarteten 41 Prozent für den Bündnispartner Ost-CDU wurde die gemeinsame Allianz für Deutschland jedoch faktischer Wahlsieger .
+Unter dem CDU-Spitzenkandidaten Lothar de Maizière entstand innerhalb der folgenden Wochen eine Koalition , bestehend aus der Allianz , den Sozialdemokraten und den Liberalen .
+Am 12. April wählten die Volkskammerabgeordneten dieser Koalitionspartner Lothar de Maizière zum neuen Ministerpräsidenten der DDR .
+In der Regierung de Maizières erhielt Rainer Eppelmann mit dem Ressort Abrüstung und Verteidigung für den DA ein Ministeramt .
+Im Einklang mit der Koalitionsarithmetik , die bei der Verteilung weiterer Posten zu beachten war , wurde Merkel in der ersten und gleichzeitig letzten frei gewählten Regierung der DDR stellvertretende Regierungssprecherin .
+In den Wochen nach der Volkskammerwahl rückte überraschend schnell die Frage der Deutschen Wiedervereinigung in den politischen Mittelpunkt .
+Merkel begleitete viele vorbereitende Gespräche , z. B.
+diejenigen zum Staatsvertrag über die Schaffung einer Währungs- , Wirtschafts- und Sozialunion , der am 18. Mai 1990 in Bonn unterzeichnet wurde .
+Maßgeblicher Verhandlungsleiter auf Seite der DDR war der parlamentarische Staatssekretär beim Ministerpräsidenten der DDR , Günther Krause , der in den nächsten Monaten ein wichtiger Förderer von Merkel wurde .
+Am 31. August 1990 wurde schließlich in Bonn von Krause und dem Innenminister der Bundesrepublik , Wolfgang Schäuble , der Einigungsvertrag unterschrieben .
+Merkel begleitete Delegationen um Lothar de Maizière auf Auslandsreisen und war beim Abschluss des Zwei-plus-Vier-Vertrages am 12. September 1990 in Moskau anwesend .
+Beitritt zur CDU ( 1990 ) Datei : Bundesarchiv Bild 183-1990-0803-017 , Lothar de Maiziere und Angela Merkel.jpg Das schlechte Abschneiden des Demokratischen Aufbruchs bei der Volkskammerwahl und die Entwicklung der nächsten Monate nötigten zu einer Anlehnung des DA an die CDU , die von Merkel mitgetragen wurde .
+Am 4. August 1990 stimmte auf einem Sonderparteitag des DA eine Mehrheit für einen Beitritt zur westdeutschen CDU nach vorhergehender Fusion mit der Ost-CDU .
+Merkel war eine von drei Delegierten , die der DA zum Vereinigungsparteitag der CDU in Hamburg am 1. und 2. Oktober 1990 schickte .
+In einer Rede stellte sie sich dort als ehemalige „ Pressesprecherin des Demokratischen Aufbruchs “ und als Mitarbeiterin de Maizières vor .
+Am Vorabend dieses 38. CDU-Bundesparteitages kam es zu einem ersten von Merkel initiierten persönlichen Gespräch mit Kohl .
+Nach der Wiedervereinigung am 3. Oktober 1990 erhielt Merkel die Planstelle einer Ministerialrätin ( A 16 ) im Bundespresse- und Informationsamt ( BPA ) .
+Eine Rückkehr an das Institut , an dem sie zwölf Jahre gearbeitet hatte , war nicht opportun , da im Einigungsvertrag die Abwicklung der Akademie der Wissenschaften festgeschrieben worden war .
+So wurden ihr Forschungsinstitut und alle anderen grundlegend umstrukturiert , neu eingegliedert oder teilweise aufgelöst .
+Merkel bewarb sich daher mit der gesicherten beruflichen Position im BPA im Rücken um ein Bundestagsmandat .
+Durch die Vermittlung von Günther Krause , der in Mecklenburg-Vorpommern CDU-Landesvorsitzender war , trat sie im Bundestagswahlkreis Stralsund – Rügen – Grimmen als Direktkandidatin an .
+Ihre Nominierung erfolgte in der Kaserne Prora auf Rügen . Gleichzeitig wurde sie auf Platz 6 der Landesliste als Listenkandidatin gesetzt .
+Bundesministerin für Frauen und Jugend ( 1991–1994 ) Datei : Bundesarchiv B 145 Bild-F087611-0001 , Berlin , Staatsakt Rohwedder , Merkel , Rönsch.jpg
+Bei der ersten gesamtdeutschen Bundestagswahl am 2. Dezember 1990 gewann Merkel ihren neuen Wahlkreis mit 48,5 Prozent der abgegebenen Erststimmen .
+Mit der konstituierenden Sitzung am 20. Dezember 1990 wurde sie Abgeordnete des Deutschen Bundestages .
+Der Wahlsieger Kohl , der sie im November 1990 nochmals zu einem Gespräch ins Kanzleramt nach Bonn eingeladen hatte , nominierte sie überraschend für ein Ministeramt in seinem Kabinett .
+Das alte Bundesministerium für Jugend , Familie , Frauen und Gesundheit wurde dreigeteilt in das Bundesministerium für Gesundheit ( Gerda Hasselfeldt ) , das Bundesministerium für Familie und Senioren ( Hannelore Rönsch ) und das Bundesministerium für Frauen und Jugend ( Angela Merkel ) .
+Merkel erhielt ein kleines Restministerium mit wenig Kompetenzen .
+Sie wurde am 18. Januar 1991 als Ministerin vereidigt .
+Als parlamentarischen Staatssekretär wählte sie Peter Hintze .
+Als beamteter Staatssekretär folgte später noch Willi Hausmann .
+Merkel war aufgrund ihrer Vergangenheit als Bürgerin der DDR wenig vertraut mit den Gebräuchen in der Union .
+Ihr schneller Quereinstieg gründete sich ausschließlich auf die Gunst des Bundeskanzlers ( „ Kohls Mädchen “ ) , während ihre späteren Konkurrenten in Karrierenetzwerken wie dem Andenpakt zusammengeschlossen waren , gegen die sie zunächst keine eigene Hausmacht geltend machen konnte .
+Daher bemühte sie sich im November 1991 um den CDU-Landesvorsitz in Brandenburg , musste jedoch eine Abstimmungsniederlage gegen Ulf Fink hinnehmen .
+Im Dezember 1991 wurde sie auf dem CDU-Bundesparteitag in Dresden zur stellvertretenden Bundesvorsitzenden und damit in das Amt gewählt , das vor ihr Lothar de Maizière innegehabt hatte .
+Von 1992 bis 1993 saß sie darüber hinaus dem Evangelischen Arbeitskreis ( EAK ) der Unionsparteien vor .
+Nach dem politischen Rückzug de Maizières und nachdem Günther Krause als Bundesverkehrsminister durch umstrittene Vergaben von Lizenzen für Autobahnraststätten in die Medien gekommen war , besaß sie eine der wenigen unbelasteten Ostbiografien innerhalb der CDU .
+Im Juni 1993 nahm sie die Chance wahr , ihre Macht in der Partei auszubauen , indem sie Krause nach seinem politischen Rückzug als CDU-Landesvorsitzende von Mecklenburg-Vorpommern nachfolgte .
+Bundesumweltministerin ( 1994–1998 ) Datei : Bundeshauptstadt Bonn 04.jpg Merkel erreichte bei der Bundestagswahl am 16. Oktober 1994 in ihrem Wahlkreis 48,6 Prozent der Erststimmen und wurde im Kabinett Kohl überraschend Bundesministerin für Umwelt , Naturschutz und Reaktorsicherheit .
+Ihr Amtsvorgänger war der auch außerhalb der Union anerkannte Klaus Töpfer .
+Dessen umweltpolitische Positionen und Forderungen stießen jedoch innerhalb des Wirtschaftsflügels der CDU und insbesondere beim Koalitionspartner FDP auf zunehmenden Widerstand .
+Die Vereidigung Merkels am 17. November 1994 und der Wechsel Töpfers an die Spitze des Bundesministeriums für Raumordnung , Bauwesen und Städtebau können parteipolitisch als Töpfers Entmachtung betrachtet werden .
+Merkel entließ drei Monate nach Amtsantritt Töpfers langjährigen beamteten Staatssekretär Clemens Stroetmann und ersetzte ihn durch Erhard Jauck .
+CDU-Generalsekretärin ( 1998–2000 ) Die Bundestagswahl am 27. September 1998 endete für die Union und ihren Kanzlerkandidaten Kohl mit einem Debakel .
+CDU und CSU erzielten mit 35,2 Prozent das schlechteste Ergebnis seit 1949 – erstmals wurde eine amtierende Bundesregierung abgewählt .
+Merkels Erststimmenanteil sank um 11 Prozentpunkte auf 37,3 Prozent .
+Wolfgang Schäuble , der als Kohls möglicher Nachfolger galt , hatte vor der Wahl des Kandidaten kritisiert , dass Kohl erneut antrat , sich damit aber gegen Kohl nicht durchsetzen können .
+Auf dem CDU-Bundesparteitag in Bonn am 7. November 1998 wurde Schäuble zum neuen Bundesvorsitzenden gewählt und auf seinen Vorschlag Merkel zur Generalsekretärin der CDU .
+Sie erhielt damit eine der wenigen Positionen mit Gestaltungsmacht , die der langjährigen Regierungspartei CDU in der Opposition geblieben waren .
+Kohl wurde Ehrenvorsitzender der CDU mit Sitz im Präsidium und Bundesvorstand .
+Die CDU schaffte in den folgenden Monaten bei Landtagswahlen einige gute Ergebnisse und im Juni 1999 bei der Europawahl zusammen mit der CSU überragende 48,7 Prozent ( 1994 : 38,8 Prozent ) .
+Hatte sich schon in der Ära Kohl die Tendenz gezeigt , dass die deutschen Wähler die auf Bundesebene in der Opposition befindlichen Parteien bei anderen Wahlen stärkten , wurde jetzt die neue Oppositionspartei CDU gestützt .
+Im November 1999 wurde die CDU-Spendenaffäre öffentlich .
+Der CDU-Ehrenvorsitzende Helmut Kohl gab in einem ZDF-Interview am 16. Dezember 1999 bekannt , dass er während seiner Zeit als Bundeskanzler unter Bruch des Parteispendengesetzes Millionenbeträge entgegengenommen hatte .
+Kohl weigerte sich , den oder die Geldgeber zu nennen , da er ihnen sein Ehrenwort gegeben habe .
+Merkel veröffentlichte am 22. Dezember 1999 einen Gastbeitrag in der Frankfurter Allgemeinen Zeitung , in dem sie Kohls Haltung kritisierte und die Partei zur Abnabelung aufforderte : Diese offene Kritik an Kohl , die bis dahin von der Parteiführung ungehört war , war nicht mit dem Parteivorsitzenden Schäuble abgesprochen , der Merkel daraufhin „ eigentlich entlassen “ wollte ; unter Funktionären wurde sie als „ Vatermörderin “ und „ Nestbeschmutzerin “ bezeichnet , erhielt aber auch viel Zuspruch für ihren riskanten Schritt , unter anderem von Christian Wulff .
+Da Schäuble ihr in der Sache Recht gab und Merkel , als unbelastet geltend , einen Neuanfang glaubwürdig vertreten konnte , beließ er sie im Amt .
+CDU-Vorsitzende ( 2000 bis 2018 ) Datei : 2015-12-14 Angela Merkel CDU Parteitag by Olaf Kosinsky -12. jpg Am 16. Februar 2000 erklärte Schäuble vor der CDU / CSU-Bundestagsfraktion seinen Rücktritt als Partei- und Fraktionsvorsitzender .
+In den darauffolgenden Wochen war die Partei führungslos , Angela Merkel befand sich als Generalsekretärin in einer Schlüsselposition .
+In dieser Zeit fanden neun sogenannte „ Regionalkonferenzen “ statt .
+Sie waren ursprünglich angesetzt worden , um die CDU-Spendenaffäre mit der Parteibasis zu diskutieren und aufzuarbeiten .
+Auf diesen lokalen Parteiversammlungen formierte sich Unterstützung für Merkel als Schäuble-Nachfolgerin .
+Ihr später Quereinstieg kam ihr nun zugute : Sie galt in der Öffentlichkeit und bei der Basis als in der Parteispendenangelegenheit unbelastet .
+Frühzeitig sprach sich der niedersächsische Oppositionsführer Christian Wulff für Merkel aus .
+Volker Rühe , Friedrich Merz und Edmund Stoiber dagegen sollen ihrer Kandidatur kritisch gegenübergestanden haben .
+Am 10. April 2000 wurde Angela Merkel auf dem CDU-Bundesparteitag in Essen mit 897 von 935 gültigen Stimmen zur neuen CDU-Bundesvorsitzenden gewählt .
+Neuer CDU-Generalsekretär wurde , auf Merkels Vorschlag , Ruprecht Polenz .
+Den Vorsitz der CDU / CSU-Bundestagsfraktion übernahm Friedrich Merz .
+Das neue Führungstrio erlebte am 14. Juli eine erste politische Niederlage : Obwohl die rot-grüne Bundesregierung nicht über die notwendige Mehrheit im Bundesrat verfügte , war es ihr gelungen , in der Abstimmung über die geplante Steuerreform einige Bundesländer mit CDU-Regierungsbeteiligung auf ihre Seite zu ziehen .
+Bereits im November 2000 trennte sich Angela Merkel von Ruprecht Polenz .
+Als seinen Nachfolger wählte sie Laurenz Meyer , der wie Polenz Bundestagsabgeordneter aus Nordrhein-Westfalen war .
+Die Jahre 2000 und 2001 bescherten der CDU unter Merkel – auch als Folge der Spendenaffäre – keine großen Landtagswahlerfolge .
+Die rot-grüne Bundesregierung schien dagegen Tritt gefasst zu haben .
+Die Positionierung für die Bundestagswahl im September 2002 begann : Friedrich Merz hatte sich selbst bereits im Februar 2001 als Kandidat für das Amt des Bundeskanzlers ins Gespräch gebracht .
+Damit war die Diskussion um die Kandidatenfrage – in den Medien häufig als „ K-Frage “ bezeichnet – eingeläutet .
+Angela Merkels Bereitschaft zur Kandidatur war bekannt .
+Sie verfügte in den Spitzen der Partei jedoch über wenig Rückhalt , da viele CDU-Ministerpräsidenten und Landesvorsitzende den bayerischen Ministerpräsidenten und CSU-Vorsitzenden Edmund Stoiber favorisierten .
+Im Dezember 2001 war auf dem Bundesparteitag in Dresden eine Entscheidung vermieden worden , diese sollte am 11. Januar 2002 auf einer Sitzung von CDU-Präsidium und Bundesvorstand in Magdeburg fallen .
+Merkel ging der unmittelbaren Konfrontation mit Stoiber jedoch aus dem Weg : Im Vorfeld hatte sie ihn zum „ Wolfratshauser Frühstück “ zu Hause besucht , bei dem sie ihm ihren Verzicht zu seinen Gunsten mitteilte .
+Angela Merkels Rückzug diente dabei dem eigenen Machterhalt , eine deutliche Abstimmungsniederlage gegen Stoiber hätte als Misstrauensvotum gegen ihre Person aufgefasst werden und eine Diskussion um den Parteivorsitz aufkommen lassen können .
+Oppositionsführerin ( 2002–2005 ) 2002 Die Bundestagswahl am 22. September 2002 endete mit einer knappen Wiederwahl der rot-grünen Regierungskoalition unter Gerhard Schröder und Joschka Fischer .
+Angela Merkel hatte die erfolglose Stoiber-Kandidatur loyal mitgetragen .
+Zu Schröders Wahlsieg hatte auch dessen schnelle Reaktion auf das Jahrhunderthochwasser beigetragen , als noch wichtiger wird indes seine ablehnende Haltung zum Irakkrieg betrachtet .
+Dem „ Nein “ der amtierenden Bundesregierung stand ein Bekenntnis Merkels zu George W. Bushs Konfrontationskurs – von ihr damals als „ Drohkulisse “ bezeichnet – gegenüber .
+Sie und Stoiber hielten an dem durch ihre Parteiprogramme vorgegebenen unbedingten Bekenntnis zu den USA fest und warfen der Regierung vor , für Irritation bei den Amerikanern zu sorgen und das historische Bündnis mit den „ Befreiern “ vom Nationalsozialismus zu gefährden .
+Unmittelbar nach der verlorenen Bundestagswahl beanspruchte Angela Merkel den CDU / CSU-Fraktionsvorsitz im Bundestag , das bisherige Amt von Friedrich Merz ; dies hatte sie unabhängig vom Wahlausgang geplant .
+Einer Regierung Stoibers wollte sie als Ministerin nicht angehören . In der Konstellation würde sie der Regierung Schröder im Parlament als Oppositionsführerin gegenübertreten .
+Merz war zunächst nicht bereit , seine Position aufzugeben , und äußerte seinerseits Kritik an Merkel .
+Auf der entscheidenden CDU-Präsidiumssitzung gab das Votum Stoibers zugunsten Merkel den Ausschlag . Das Verhältnis zwischen Merkel und Merz galt bereits vorher als konfliktbelastete Konkurrenzkonstellation .
+Bei der ersten Wiederwahl als Parteivorsitzende auf dem Bundesparteitag in Hannover am 11. November 2002 wurde Merkel mit 93,6 Prozent der Stimmen wiedergewählt .
+2003 Das Jahr 2003 brachte der CDU und ihrer Vorsitzenden Erfolge bei den Landtagswahlen in Hessen und Niedersachsen .
+Die stärker werdende Präsenz der CDU im Bundesrat ermöglichte Angela Merkel schließlich ein Mitregieren aus der Opposition heraus .
+Die CDU trug die Agenda 2010 der rot-grünen Bundesregierung mit und stimmte , nachdem sie im Vermittlungsausschuss noch weitergehende Forderungen durchgesetzt hatte , den Gesetzesänderungen in Bundestag und Bundesrat zu .
+So war sie vor allem bei der Formulierung der zum 1. Januar 2004 wirksam gewordenen Gesundheitsreform und des Vierten Gesetzes für moderne Dienstleistungen am Arbeitsmarkt ( Hartz IV ) eingebunden .
+Im Fall des Bundestagsabgeordneten Martin Hohmann , dessen Thesen zum „ jüdischen Tätervolk “ scharf kritisiert wurden , zeigte sich Merkel jedoch wenig entschlussfreudig : Der erste Fraktionsausschluss eines Unionsabgeordneten in der Geschichte des Deutschen Bundestages , im November 2003 , erfolgte erst nach längerer Bedenkzeit und unter öffentlichem Druck .
+2004 Am 6. Februar 2004 trat der politisch angeschlagene Bundeskanzler Gerhard Schröder als SPD-Vorsitzender zurück , sein Nachfolger wurde Franz Müntefering .
+Im gleichen Monat gelang der CDU ein deutlicher Sieg bei der Wahl zur Hamburgischen Bürgerschaft .
+Angela Merkel bereiste im Februar drei Tage lang die Türkei .
+Dort setzte sie sich für das Modell der „ privilegierten Partnerschaft “ ein , als Alternative zu der von der Bundesregierung angestrebten Vollmitgliedschaft in der Europäischen Union .
+In einer Rede vom 20. November 2004 äußerte sich Angela Merkel mit den Worten „ Die multikulturelle Gesellschaft ist gescheitert “ zur innenpolitischen Lage Deutschlands im Hinblick auf die Integrationsproblematik der muslimischen ( vorwiegend türkischen ) Bevölkerung .
+Dabei brachte Angela Merkel erneut den Begriff der deutschen Leitkultur in die Diskussion und kritisierte vor allem den aus ihrer Sicht mangelnden Integrationswillen der Muslime .
+Das Ende der Amtszeit von Bundespräsident Johannes Rau bedeutete die Neubesetzung des formal höchsten politischen Amtes in der Bundesrepublik Deutschland .
+Wolfgang Schäuble hatte sich früh als Kandidat ins Gespräch gebracht und konnte auf Unterstützung innerhalb von CDU und CSU hoffen .
+Innerparteiliche Gegenspieler Angela Merkels wie Roland Koch und Friedrich Merz favorisierten Schäuble , ebenso wie Edmund Stoiber ( CSU ) .
+Horst Köhler galt als Merkels Kandidat , und sein hauchdünner Wahlerfolg mit einer Stimme Mehrheit in der Bundesversammlung am 23. Mai 2004 wurde allgemein als ein weiterer Ausbau ihrer Machtposition gewertet .
+Vorgezogene Bundestagswahl 2005 Die Landtagswahl in Nordrhein-Westfalen am 22. Mai 2005 brachte der SPD eine schwere Wahlniederlage , die eine Serie von Landtagswahlniederlagen der Jahre 2003 und 2004 fortsetzte .
+Als politisch-medialen Befreiungsschlag kündigten eine halbe Stunde nach Schließung der Wahllokale zuerst SPD-Parteichef Franz Müntefering und kurze Zeit darauf Bundeskanzler Gerhard Schröder an , eine vorgezogene Neuwahl des Bundestages für den Herbst 2005 anzustreben .
+Am 30. Mai bestimmten die Parteipräsidien von CDU und CSU in einer gemeinsamen Sitzung Angela Merkel zur Kanzlerkandidatin der Unionsparteien .
+Ihre Rolle war unumstritten , die innerparteilichen Gegenspieler marginalisiert .
+Merkels Schattenkabinett wurde angesichts der angestrebten Koalition mit der FDP als Kompetenzteam vorgestellt .
+Insbesondere Paul Kirchhof und sein „ Kirchhof-Modell “ ( zur Besteuerung von Einkommen ) sowie die CDU-Vorstellungen zur Krankenversicherung ( „ Kopfpauschale “ ) galten später als „ schwer vermittelbar “ und mitverantwortlich für ein unbefriedigendes Wahlergebnis .
+Bei der Bundestagswahl am 18. September 2005 erreichten CDU / CSU mit der Spitzenkandidatin Angela Merkel 35,2 Prozent ( 2002 : 38,5 ) vor der SPD mit 34,2 Prozent .
+Ihren eigenen Wahlkreis 15 ( Stralsund , Landkreis Nordvorpommern und Landkreis Rügen ) gewann Angela Merkel mit 41,3 Prozent der Erststimmen .
+Damit blieb die Union deutlich hinter ihren Prognosen zurück und konnte ihr Wahlziel , eine Regierungsmehrheit für CDU / CSU und FDP , nicht erreichen .
+Im Gegenteil drohte sie ihren komfortablen Vorsprung analog zu 2002 an den erfahrenen Wahlkämpfer Schröder zu verlieren ; die Hoffnung , dass Merkel das häufig gelobte Ergebnis des in Teilen Deutschlands 2002 eher irritierend empfundenen Bayern Stoiber noch einmal verbessern könnte , hatte sich nicht erfüllt .
+Historisch handelte es sich bei dem CDU-Ergebnis um das schlechteste seit 1949 , bei dem gesamten Unions-Ergebnis um das zweitschlechteste .
+Merkel konnte sich aber dennoch auf einen knappen Vorsprung von vier Sitzen und damit einen der engsten Wahlausgänge der bundesdeutschen Geschichte stützen , da auch die Sozialdemokraten deutliche Stimmeneinbußen hinnehmen mussten und es anders als in den Umfragen ersichtlich zu einem Kopf-an-Kopf-Rennen gekommen war , in dessen Zuge die bisherige Regierungskoalition aus SPD und Grünen ihre Parlamentsmehrheit verloren hatte .
+Bundeskanzlerin ( seit 2005 ) Große Koalition 2005 bis 2009 Koalitionsverhandlungen Datei :C hancellor Merkel gives keynote speech hires.jpg
+In einer Fernsehdiskussion am Wahlabend , der sogenannten „ Elefantenrunde “ , beanspruchte Gerhard Schröder trotz der eingebüßten Mehrheit von Rot-Grün überraschend die Regierungsbildung für sich – in einer Form , die heftige Diskussionen auslöste und die er selbst später als „ suboptimal “ bezeichnete .
+Die nächsten Tage waren im politischen Berlin von der Frage bestimmt , ob der SPD , als im Bundestag größter Einzelfraktion einer Partei , oder der CDU / CSU , als größter Fraktionsgemeinschaft , das Amt des Bundeskanzlers – in einer wie auch immer gearteten Koalitionsregierung – gebühre .
+Am 20. September wurde Angela Merkel von der erstmals nach der Wahl zusammengetretenen Unions-Bundestagsfraktion in geheimer Wahl mit 219 von 222 Stimmen zur Fraktionsvorsitzenden wiedergewählt .
+Nach dem enttäuschenden Bundestagswahlergebnis war dies ein wichtiges Vertrauensvotum und Rückhalt für bevorstehende Koalitionsgespräche .
+Die Öffentlichkeit erlebte in den 14 Tagen bis zu einer notwendigen Nachwahl im Wahlkreis 160 ( Dresden I ) Gespräche Angela Merkels und Edmund Stoibers mit Bündnis 90/Die Grünen zwecks Sondierung einer möglichen schwarz-gelb-grünen „ Jamaika-Koalition “ zusammen mit der FDP .
+Erst nach der Entscheidung in Dresden begannen die Gespräche mit der SPD zur Bildung einer Großen Koalition .
+Am 10. Oktober veröffentlichten SPD , CDU und CSU eine gemeinsame Vereinbarung , die die geplante Wahl von Angela Merkel zur Bundeskanzlerin durch den 16. Deutschen Bundestag beinhaltete .
+Am 12. November stellte sie nach fünfwöchigen Verhandlungen der CDU / CSU mit der SPD den Koalitionsvertrag vor .
+Am 22. November 2005 wurde Angela Merkel mit 397 der 611 gültigen Stimmen ( Gegenstimmen : 202 ; Enthaltungen : 12 ) der Abgeordneten des 16. Deutschen Bundestages zur Bundeskanzlerin der Bundesrepublik Deutschland gewählt .
+Dies waren 51 Stimmen weniger , als die Koalitionsparteien Mandate besaßen .
+Nach sieben männlichen Amtsvorgängern war Angela Merkel die erste Bundeskanzlerin .
+Gleichzeitig war sie mit 51 Jahren die jüngste Amtsinhaberin , die erste Person aus den neuen Bundesländern und die erste Naturwissenschaftlerin , die dieses Amt bekleidet .
+Regierungsbildung Noch vor Beginn der Legislaturperiode verzichtete Merkels langjähriger Konkurrent Edmund Stoiber überraschend auf das für ihn vorgesehene Amt des Wirtschaftsministers , nach eigenem Bekunden wegen Franz Münteferings Rückzug vom Parteivorsitz der SPD .
+In die Vertrauens- und Schlüsselstellung als Leiter des Bundeskanzleramtes berief Angela Merkel Thomas de Maizière , Cousin des letzten DDR-Ministerpräsidenten Lothar de Maizière .
+Erste Hälfte der Amtsperiode Zu Beginn der Amtsperiode traten Merkel und ihr Kabinett weder außen- noch innenpolitisch in besonderem Maße in Erscheinung .
+Lediglich Merkels Minister sorgten für einige Schlagzeilen , die sich aber mehr auf Kompetenzfragen oder die langfristige Ausrichtung der Regierungsarbeit als auf konkrete Sachfragen bezogen .
+Ende März 2006 legte Merkel ein Acht-Punkte-Programm für die zweite „ Etappe “ der Legislaturperiode vor .
+Darin wurden geplante Anstrengungen in den Bereichen Föderalismusreform , Bürokratieabbau , Forschung und Innovation , Energiepolitik , Haushalts- und Finanzpolitik , Familienpolitik , Arbeitsmarktpolitik und insbesondere Gesundheitsreform skizziert .
+Datei :33 rdG8Leaders.jpg Ungeachtet des Fehlens nötiger einschneidender Reformen stieß Merkels eher sachlicher Regierungsstil anfangs in der Bevölkerung , unter den Führungskräften der Wirtschaft und im Ausland überwiegend auf Zustimmung .
+Am 27. November 2006 wurde sie auf dem Bundesparteitag der CDU mit 93 Prozent der Stimmen erneut zur Bundesvorsitzenden der Partei gewählt .
+Merkel sorgte für einen kleineren außenpolitischen Eklat , als sie am 23. September 2007 den Dalai Lama Tendzin Gyatsho im Berliner Bundeskanzleramt empfing .
+Das Treffen mit dem geistlichen Oberhaupt der Tibeter war von ihr als „ privater Gedankenaustausch “ mit einem religiösen Führer bezeichnet worden und sollte nicht als politische Stellungnahme zu den Autonomiebestrebungen Tibets verstanden werden .
+Trotzdem zeigte sich die Volksrepublik China verstimmt und sagte mit dem Hinweis auf „ technische Probleme “ mehrere offizielle Termine auf ministerieller Ebene ab .
+Merkels außenpolitischer Berater Christoph Heusgen konnte die Wogen wieder glätten , indem er dem chinesischen Botschafter Ma Canrong versicherte , dass Deutschland seine China-Politik nicht ändern werde und die territoriale Integrität Chinas außer Frage stehe .
+EU-Ratspräsidentschaft 2007 Datei : EPPcongressWarsaw.jpg
+Vertreten durch Angela Merkel und den Bundesaußenminister Frank-Walter Steinmeier hatte die Bundesrepublik Deutschland vom 1. Januar bis 30. Juni 2007 den Vorsitz im Rat der Europäischen Union inne .
+Der Vorsitz wurde turnusmäßig im Rahmen der Dreier-Präsidentschaft mit Portugal und Slowenien wahrgenommen .
+Als wesentliche Bestandteile der politischen Agenda nannte Merkel unter anderem den Europäischen Verfassungsvertrag , die „ Klima- und Energiepolitik “ , die „ Vertiefung der transatlantischen Wirtschaftspartnerschaft “ und eine „ Nachbarschaftspolitik für die Schwarzmeerregion und Zentralasien “ .
+Merkel drängte darauf , dass der Bezug auf Gott und den christlichen Glauben in der EU-Verfassung verankert wird . Letztlich konnte sich diese Forderung , die unter anderem auch aus Polen , Irland und Italien erhoben wurde , nicht durchsetzen – im Vertrag von Lissabon wird nur auf das „ kulturelle , religiöse und humanistische Erbe Europas “ Bezug genommen .
+Finanzkrise und Reaktionen Im Herbst 2008 wurde – unter anderem durch die Insolvenz zahlreicher großer Finanzinstitute – das historische Ausmaß der 2007 einsetzenden Finanzkrise deutlich .
+Die IKB , einige deutsche Landesbanken und auch private Institute mussten Abschreibungen in erheblicher Höhe vornehmen .
+Der Deutsche Bundestag reagierte im August zunächst mit dem Risikobegrenzungsgesetz , die BaFin untersagte bestimmte Leerverkäufe .
+Am 8. Oktober 2008 gab die Regierung Merkel eine Garantieerklärung für die Spareinlagen in Deutschland ab .
+Diese Garantie galt für jedes Institut und für jeden Sparer eines Institutes , das Teil der deutschen Einlagensicherung ist . Zuvor hatte Merkel noch die irische Regierung wegen einer eigenen Staatsgarantie scharf kritisiert , die sich allerdings allein auf einheimische Banken bezog .
+Merkels Vorgehen wurde von anderen europäischen Finanzministern als nationaler Alleingang kritisiert , von der EU-Kommission jedoch als nicht wettbewerbsverzerrend und damit unproblematisch eingestuft . Die am 5. November 2008 und am 12. Januar 2009 beschlossenen Konjunkturpakete trug Angela Merkel als Kanzlerin mit .
+Sie sah dies als Chance , gestärkt aus der Finanz- und Wirtschaftskrise hervorzugehen .
+Als Bundeskanzlerin setzte sie außerdem zusammen mit der SPD die Einführung der Umweltprämie zum 14. Januar 2009 trotz starker Kritik aus der Opposition durch .
+Damit wurde Käufern eines Neuwagens bei gleichzeitiger Verschrottung ihres mindestens 9 Jahre alten PKWs eine vom Staat gezahlte Prämie in Höhe von 2500 Euro gewährt .
+Dies sollte die durch die Weltwirtschaftskrise unter Druck geratene Automobilindustrie stützen . Dem angeschlagenen Autobauer Opel sagte Merkel Ende März 2009 ihre Unterstützung bei der Suche nach einem Investor zu und stellte staatliche Bürgschaften in Aussicht , lehnte es aber ab , Teile von Opel zu verstaatlichen .
+Beim geplanten Verkauf von Opel im Sommer 2009 plädierte Merkel für den Autozulieferer Magna als zukünftigen Eigentümer .
+Im April 2008 hatte Angela Merkel in ihrer Funktion als Kanzlerin den Bankier Josef Ackermann , damals Vorstandsvorsitzender der Deutschen Bank , und 20 bis 30 weitere Personen zu seinem 60. Geburtstagsessen eingeladen und musste daraufhin – nach einem Urteil des Oberverwaltungsgerichts Berlin-Brandenburg ( OVG ) aus dem Jahre 2012 – die Liste der geladenen Gäste veröffentlichen lassen .
+Es wurde unter anderem kritisiert , Merkel habe Politik und Lobby-Interessen miteinander vermischt .
+Weitere Politikfelder Nach der Wahl Barack Obamas zum Präsidenten der Vereinigten Staaten von Amerika gratulierte Merkel ihm zu seinem „ historischen Sieg “ . Bei ihren ersten Treffen betonten beide ihre gemeinsame Linie zum Beispiel in den Fragen der Erderwärmung oder der Atompolitik des Iran .
+Eine der wenigen Unstimmigkeiten betraf die Aufnahme von Häftlingen aus dem amerikanischen Gefangenenlager der Guantanamo Bay Naval Base .
+Obama drängte auf eine schnelle Entscheidung Merkels . Bei den Beratungen zum Beitritt weiterer Länder , wie der Balkanstaaten , zur EU stieß Merkels konservativer Kurs bei der Außenministerkonferenz in Frauenberg im März 2009 auf Kritik .
+Der Regierungspartner SPD warf ihr vor , dass ihr Programm im Widerspruch zum Europawahlprogramm der CDU stehe . Nach dem Amoklauf in Winnenden vom 11. März 2009 sprach sich die Bundeskanzlerin für stärkere Kontrollen von Waffenbesitzern aus .
+Außerdem müsse versucht werden , Waffen für Kinder und Jugendliche unzugänglich aufzubewahren .
+Wahlkampf 2009 Während des im Vorfeld zur Bundestagswahl im September 2009 geführten Wahlkampfes wurde Merkel in der Öffentlichkeit und auch von Teilen der CDU / CSU oft vorgeworfen , zu wenig Parteiprofil zu zeigen .
+So wurde zum Beispiel kritisiert , dass sie ihr Konzept zur Bekämpfung der Weltwirtschaftskrise nicht klar formulierte .
+Merkel selbst dementierte diese Vorwürfe .
+Die Oppositionsparteien übten außerdem Kritik am Verhalten Angela Merkels in der Frage eines Fernsehduells der Spitzenkandidaten aller Parteien .
+Nach dem Spitzenduell der Kanzlerkandidaten von SPD und CDU sagten beide , Merkel und Steinmeier , ihren Auftritt in einer solchen Runde ab .
+Im Wahlkampf forderte Merkel eine Senkung des Eingangssteuersatzes bei der Einkommensteuer in zwei Schritten und den vollen Erhalt des Ehegattensplittings .
+Die Bundeskanzlerin lehnte weiter einen flächendeckenden Mindestlohn ab und trat dafür ein , die Laufzeiten der Kernkraftwerke in Deutschland zu verlängern .
+Datei : 12-03-06-cebit-eroeffnung-angela-merkel-21.jpg
+Schwarz-gelbe Koalition 2009 bis 2013 Bundestagswahl 2009 und Regierungsbildung Am 27. September 2009 fand die Wahl zum 17. Deutschen Bundestag statt .
+Die Unionsparteien und die FDP erreichten dabei zusammen die notwendige Mehrheit für die von beiden Seiten angestrebte Bildung einer schwarz-gelben Koalition . Allerdings verloren beide Unionsparteien Stimmen und mussten ihr jeweils schlechtestes Ergebnis nach der ersten Bundestagswahl 1949 hinnehmen . Merkel selbst siegte im Wahlkreis 15 ( Stralsund – Nordvorpommern – Rügen ) mit 49,3 Prozent der Erststimmen und erreichte damit einen Zuwachs von 8 Prozentpunkten gegenüber der vorangegangenen Bundestagswahl . Datei : Feierliches Gelöbnis.jpgNachdem die Koalitionsparteien einen Koalitionsvertrag unterzeichnet hatten , wurde Angela Merkel am 28. Oktober 2009 mit 323 von 612 abgegebenen Stimmen erneut zur Bundeskanzlerin gewählt ; dies waren neun Stimmen weniger , als die Koalition aus CDU / CSU und FDP innehatte . Am 10. November 2009 gab Merkel ihre Regierungserklärung für die neue Legislaturperiode ab , in der sie die Überwindung der Folgen der Wirtschaftskrise in den Mittelpunkt stellte .
+Bewältigung der Wirtschaftskrise Die Koalition konnte zunächst nicht recht Fuß fassen , so dass der öffentliche Eindruck von der Regierungsarbeit zunehmend litt .
+So beschränkte sich die Koalition , die angetreten war , das Steuersystem zu vereinfachen , mit dem „ Wachstumsbeschleunigungsgesetz “ zunächst auf leichte steuerliche Entlastungen in verschiedenen Bereichen und das Einführen einer „ Hotelsteuer “ ( die Mehrwertsteuer für Hotelübernachtungen wurde von 19 auf 7 Prozent gesenkt ) . Gerade im ersten Jahr fand die Koalition nicht zu einem harmonischen Handeln zusammen , was in wechselseitigen Beschimpfungen über die Presse gipfelte .
+Erst gegen Ende des Jahres 2010 wurde die Zusammenarbeit in der Regierung als gut rezipiert .
+Die Folgen der Wirtschafts- und Bankenkrise sowie die zunehmenden Probleme in der Eurozone nahmen einen breiten Raum im Handeln der Koalition ein .
+Im Mai 2010 beschlossen die Regierungs-Chefs der 17 Euro-Länder auf einem EU-Ratstreffen in großer Hast den ersten Euro-Rettungsschirm : Griechenland ( ein Land mit etwa 10 Millionen Einwohnern ) erhielt einen unbesicherten Kredit von 80 Milliarden Euro , um eine kurz bevorstehende Staatspleite abzuwenden .
+Der Bundestag segnete den deutschen Anteil im Währungsunion-Finanzstabilitätsgesetz ab .
+Mehrere massive Aufstockungen der deutschen Haftung für Schulden anderer Euro-Länder – ein Verstoß gegen die No-Bailout-Klausel – folgten ( siehe Eurokrise , griechische Finanzkrise ) .
+Die Arbeitslosenzahl sank im Herbst 2010 auf unter 3 Millionen .
+Bundeswehrreform und Plagiatsaffäre zu Guttenberg Verteidigungsminister Karl-Theodor zu Guttenberg ( CSU ) stieß im Frühjahr 2010 eine Debatte zu einer Bundeswehrreform an , die eine maximale Truppenstärke von 185.000 Soldaten vorsah .
+Trotz großer Bedenken gaben CDU und CSU auf Parteitagen im Herbst 2010 eine breite Zustimmung .
+Der Deutsche Bundestag beschloss am 24. März 2011 mit den Stimmen der Union , FDP , SPD und der Grünen die Aussetzung der seit 55 Jahren bestehenden Wehrpflicht , so dass die Bundeswehr ab dem 1. Juli 2011 eine Berufsarmee wurde ( auch ‚ Freiwilligenarmee ‘ genannt ) .
+Im Zuge einer Plagiatsaffäre um seine Doktorarbeit erklärte zu Guttenberg , bis dahin beliebtester Minister ihres Kabinetts , unter öffentlichem und politischem Druck am 1. März 2011 seinen Rücktritt von sämtlichen bundespolitischen Ämtern .
+Merkels Äußerung , sie habe Guttenberg „ nicht als wissenschaftlichen Assistenten “ bestellt und seine Arbeit als Minister sei „ hervorragend “ , verstärkte den Unmut an Universitäten und bei Akademikern über den Umgang mit der Affäre , die diese Äußerung als Geringschätzung oder Relativierung von wissenschaftlichen Standards aufnahmen .
+Energiepolitische Wende Im Oktober 2010 verlängerte die Bundesregierung die Laufzeiten aller 17 damals aktiven deutschen Atomkraftwerke ( „ Ausstieg aus dem Ausstieg “ ) und annullierte damit den so genannten Atomkonsens ( 2000/2002 ) der rot-grünen Regierung Schröder .
+Die sieben vor 1980 in Betrieb gegangenen deutschen Atomkraftwerke erhielten Strommengen für zusätzliche acht Betriebsjahre ; die übrigen zehn erhielten Strommengen für zusätzliche 14 Betriebsjahre .
+Datei : Angela Merkel ( 9307201890 ) . jpg
+Wenige Tage nach dem Beginn der Nuklearkatastrophe von Fukushima in Japan verkündete Merkel im März 2011 jedoch eine völlige Abkehr von ihrer bisherigen Atompolitik bzw. Energiepolitik .
+Zunächst verkündete die Bundesregierung ein dreimonatiges Atom-Moratorium für die sieben ältesten deutschen Atomkraftwerke sowie für das Kernkraftwerk Krümmel ; kurz darauf setzte sie zwei Expertenkommissionen ein , um ihren beschleunigten Atomausstieg zu rechtfertigen bzw. legitimieren .
+Am 6. Juni 2011 beschloss das Kabinett Merkel II das Aus für acht Kernkraftwerke und einen stufenweisen Atomausstieg Deutschlands bis 2022 .
+Diese Kehrtwende brachte Merkel viel innerparteiliche Kritik ein , vor allem aus dem konservativen Flügel der Union . Umweltschutzorganisationen und die oppositionellen Grünen kritisierten den Atomausstieg als nicht ausreichend , dennoch nahm Angela Merkel mit dem Atomausstieg die Bundesregierung wie die sie tragenden Parteien aus der direkten Kritik und konnte auf eine breite Zustimmung aus der Bevölkerung bauen .
+Im Mai 2012 erregte es großes Aufsehen , als Merkel überraschend die Entlassung von Bundesumweltminister Norbert Röttgen herbeiführte .
+Ihre Entscheidung verkündete sie drei Tage nach Röttgens Landtagswahl-Niederlage als Spitzenkandidat der NRW-CDU gegen die amtierende NRW-Ministerpräsidentin Hannelore Kraft .
+Noch vor der Wahl hatte Merkel wiederholt Norbert Röttgen gelobt .
+Verhältnis zu den Vereinigten Staaten Im Mai 2011 gratulierte Merkel dem US-Präsidenten Obama öffentlich zur Tötung Osama bin Ladens durch eine amerikanische Spezialeinheit und bekundete ihre Freude über die Aktion .
+Innerparteilich , bei Kirchenvertretern und in der Presse geriet sie dafür unter Kritik .
+Nachdem im Zuge der Überwachungs- und Spionageaffäre 2013 Hinweise darüber bekannt geworden waren , dass das CDU-Mobiltelefon der Bundeskanzlerin über Jahre hinweg durch den US-Geheimdienst NSA abgehört worden sein könnte , forderte Merkel am 23. Oktober 2013 in einem persönlichen Telefonat mit US-Präsident Obama eine umfassende Aufklärung der Vorwürfe und eine Beantwortung einer bereits vor Monaten gestellten Anfrage der deutschen Bundesregierung .
+Eine Sprecherin des Nationalen Sicherheitsrates der Vereinigten Staaten erklärte hierzu , dass der Präsident der Kanzlerin versichert habe , „ dass die Vereinigten Staaten ihre Kommunikation nicht überwachen und auch nicht überwachen werden . “ Die Sprecherin beantwortete dabei trotz gezielter Nachfrage aber nicht , ob dies auch für die Vergangenheit gilt .
+Datei :C hancellor Merkel rawPhoneNumber.jpg Laut dem Journalisten Sidney Blumenthal , der als Berater von US-Präsident Bill Clinton und der US-Außenministerin Hillary Clinton tätig war , überwachten die Vereinigten Staaten wiederholt Gespräche von Angela Merkel mit Finanzminister Wolfgang Schäuble und von Merkel und Schäuble mit Gerhard Schindler und Generalmajor Norbert Stier , Präsident und Vizepräsident des Bundesnachrichtendienstes .
+So wurde am 6. Mai 2012 eine von Schäuble angesetzte „ sichere “ Telefonkonferenz mit Merkel zur Wahl François Hollandes zum französischen Präsidenten und zum Ergebnis der Landtagswahl in Schleswig-Holstein abgehört .
+In dem Gespräch schlug Schäuble unter anderem vor , vorgezogene Bundestagswahlen in Erwägung zu ziehen , um einem möglichen Linkstrend und somit einem drohenden Verlust der Regierungsmehrheit vorzubeugen .
+Schäuble berichtete zu Informationen des Bundesamtes für Verfassungsschutz über das Erstarken rechtsextremer Parteien in Frankreich und Griechenland sowie rechtsextremer paramilitärischer Gruppen in Schweden , Deutschland , Belgien und den Niederlanden , während sich Merkel besorgt über Beziehungen der CSU zu Rechtsextremisten in Deutschland und Österreich äußerte .
+Bei Gesprächen im Juli , August und September 2012 ging es um die Eurokrise und um anstehende Wahlen in den Niederlanden und Italien .
+Kurz vor Beginn des Brüsseler EU-Gipfels vom 24. bis 25. Oktober 2013 , bei dem die verdichteten Hinweise auf eine Spionage der Vereinigten Staaten gegen befreundete europäische Länder ausführlich erörtert wurden , obwohl dieses Thema auf der Tagesordnung nicht angekündigt war , sagte Merkel : „ Das Ausspähen unter Freunden , das geht gar nicht .
+Wir sind Verbündete , aber so ein Bündnis kann nur auf Vertrauen aufgebaut sein . “ Am selben Tag berichtete die New York Times , dass ein Auftrag zum Lauschangriff auf das Telefon Merkels in die Regierungszeit von US-Präsident George W. Bush zurückreiche und dass die US-Sicherheitsberaterin Susan E. Rice beteuert habe , der gegenwärtige US-Präsident Obama habe von dieser Sache nichts gewusst . Der Spiegel berichtete am 26. Oktober 2013 , dass Merkels Mobiltelefon offenbar seit mehr als zehn Jahren überwacht werde und dass in der Botschaft der Vereinigten Staaten in Berlin Mitarbeiter der NSA und der CIA mittels moderner Hochleistungsantennen die Kommunikation im Regierungsviertel illegal abhören würden . Dabei seien nicht nur Verbindungsdaten der Gesprächspartner , sondern auch Inhalte von einzelnen Gesprächen aufgezeichnet worden .
+Am 27. Oktober 2013 wurde unter Berufung auf einen hohen NSA-Mitarbeiter berichtet , dass NSA-Chef Keith B. Alexander den US-Präsidenten 2010 persönlich über die Abhöraktion gegen Merkel informiert habe und dass nicht bloß ihr CDU-Mobiltelefon belauscht wurde , sondern auch ein angeblich abhörsicheres Handy der Bundeskanzlerin . Obama habe die Maßnahmen seinerzeit nicht nur weiterlaufen lassen , sondern auch darauf gedrängt , das neue Kanzler-Handy zu knacken . Am 30. Oktober 2013 berichtete die New York Times unter Berufung auf einen früheren Geheimdienstmitarbeiter , dass die NSA in Deutschland jede erreichbare Telefonnummer „ aufsauge “ ; auch ranghohe Beamte und die Chefs der Oppositionsparteien seien Spionageziele .
+Für die Berichte der NSA hätten sich das Außenministerium , das Finanzministerium , andere Geheimdienste der Vereinigten Staaten sowie der Nationale Sicherheitsrat bei Präsident Obama interessiert .
+Obamas Sicherheitsberater hätten nach den ihnen regelmäßig vorgelegten Berichten kaum übersehen können , dass internationale Politiker wie Merkel ausgespäht würden .
+Der Start der Abhöraktion der Vereinigten Staaten gegen Deutschland sei 2002 erfolgt und habe sich vor allem gegen Bundeskanzler Gerhard Schröder gerichtet , weil dessen Ablehnung des Irakkrieges und dessen „ Nähe “ zum russischen Präsidenten Putin bei den Vereinigten Staaten die Frage aufgeworfen habe , ob ihm noch getraut werden könne . Dass NSA-Chef Alexander mit Obama über eine Merkel betreffende Operation je gesprochen habe , wurde von der NSA allerdings umgehend dementiert . Gestützt auf US-Regierungskreise brachte das Wall Street Journal am 27. Oktober 2013 die Version , dass das NSA-Abhörprogramm gegen Merkel und die Spitzenpolitiker anderer Nationen gestoppt worden sei , als eine Überprüfung durch die US-Regierung dem US-Präsidenten im Sommer 2013 die Existenz dieser Geheimdienstoperationen offenbart habe . Mit dem Blick auf die Ausspähungen , die die Vereinigten Staaten offenbar auch gegen andere Nationen sowie gegen die Vereinten Nationen , die Europäische Union , den Internationalen Währungsfonds und die Weltbank gerichtet hatten , ließen Dilma Rousseff , die Präsidentin Brasiliens , und Bundeskanzlerin Merkel eine Resolution der Vereinten Nationen vorbereiten , die den Internationalen Pakt über bürgerliche und politische Rechte ergänzen soll und alle Staaten auffordert , Gesetzgebung und Praxis bei Überwachungsaktionen im Ausland auf den Prüfstand zu stellen .
+Der am 1. November 2013 beim UN-Menschenrechtsausschuss eingereichte , die USA konkret nicht nennende Textentwurf einer Resolution wurde nach mehrwöchiger Beratung auf Drängen der USA und anderer Staaten abgeschwächt und von der Vollversammlung der Vereinten Nationen am 26. November 2013 einstimmig beschlossen .
+Im Zusammenhang mit der Eurokrise beschloss der Bundestag am 13. Juni 2013 ein Gesetz zur Etablierung eines einheitlichen Bankenaufsichtsmechanismus , welcher auch eine Rekapitalisierung von finanziell in Schwierigkeiten geratenen Banken mit Geldern aus dem Europäischen Stabilitätsmechanismus ( ESM ) erlaubt , welcher bis dahin nur Hilfszahlungen an Staaten erlaubte .
+Große Koalition ( seit 2013 ) Bundestagswahl 2013 und Regierungsbildung Datei : Angela Merkel Apolda 2014 003.jpg Am 22. September 2013 fand die Wahl zum 18. Deutschen Bundestag statt .
+Während die Unionsparteien mit 41,5 Prozent das beste Zweitstimmenergebnis seit 1990 erhielten , schaffte der bisherige Koalitionspartner , die FDP , den Wiedereinzug in den Bundestag mit 4,8 Prozent erstmals seit 1949 nicht .
+Merkel selbst siegte im Wahlkreis 15 ( Stralsund – Nordvorpommern – Rügen ) mit 56,2 Prozent der Erststimmen und erreichte damit einen Zuwachs von 6,9 Prozentpunkten gegenüber der vorangegangenen Bundestagswahl .
+Datei : Angela Merkel ( Tobias Koch ) . jpg
+Nachdem die Koalitionsparteien einen Koalitionsvertrag unterzeichnet hatten , wurde Angela Merkel am 17. Dezember mit 462 von insgesamt 621 abgegebenen Stimmen erneut zur Bundeskanzlerin gewählt ; dies sind 42 Stimmen weniger , als die Koalition aus CDU / CSU und SPD innehatte .
+Angela Merkel ist die erste Person an der Spitze der deutschen Regierung , die in der Bundesrepublik ( 1954 ) geboren wurde .
+Seit dem 26. März 2014 , als der estnische Premierminister Andrus Ansip zurücktrat , ist Merkel die am längsten amtierende Regierungschefin der Europäischen Union .
+Bundestagswahl 2017 und Regierungsbildung Am 20. November 2016 gab Merkel bekannt , bei der Bundestagswahl 2017 für eine vierte Amtszeit als Bundeskanzlerin kandidieren zu wollen .
+Am 6. Dezember 2016 wurde sie auf dem CDU-Bundesparteitag in Essen mit 89,5 Prozent der knapp 1000 Delegiertenstimmen als Parteivorsitzende wiedergewählt . Die CDU / CSU erlitt starke Verluste und erzielte ihr schlechtestes Ergebnis seit der Bundestagswahl 1949 .
+Merkel selbst errang bei der Wahl das Direktmandat im Wahlkreis 15 ( Vorpommern-Rügen – Vorpommern-Greifswald I ) mit 44,0 Prozent der Erststimmen und verzeichnete damit einen Verlust von 12,3 Prozent gegenüber der vorangegangenen Bundestagswahl , verteidigte den Wahlkreis aber noch mit knapp 25 Prozent Vorsprung .
+Nach der Bundestagswahl 2017 gab die SPD bekannt , dass sie nicht für eine große Koalition zur Verfügung stünde , wodurch die sogenannte Jamaika-Koalition aus CDU / CSU , FDP und Grünen als einziges realistisches Bündnis mit Mehrheit galt .
+Mehr als vier Wochen lang gab es Sondierungsgespräche zwischen den Parteien , die in der Nacht des 19. November vom FDP-Vorsitzenden Christian Lindner für gescheitert erklärt wurden.Datei : 2018-03-12 Unterzeichnung des Koalitionsvertrages der 19. Wahlperiode des Bundestages by Sandro Halank–027 . jpgBundespräsident Frank-Walter Steinmeier führte daraufhin intensive Gespräche mit den Parteispitzen und erinnerte die gewählten Bundestagsabgeordneten nachdrücklich an die Verpflichtung zum Gemeinwohl und zur Regierungsbildung .
+Das Verfahren zur Wahl des Bundeskanzlers ( und ggfs. folgende Neuwahlen ) kann nach GG nur mit einem Vorschlag des Bundespräsidenten begonnen werden .
+Eine schwarz-rot-grüne Koalition ( Kenia-Koalition ) wurde zwischenzeitlich ins Gespräch gebracht , Angela Merkel und die Führungsspitze der SPD bevorzugen seit November 2017 alternativ eine Große Koalition ( GroKo ) mit einem erneuerten Koalitionsvertrag wie in der vorherigen Legislaturperiode als Königsweg , nicht jedoch Jusos sowie weite Teile der sozialdemokratischen Basis .
+Am 12. Januar schlossen CDU , CSU und SPD ihre Sondierungsgespräche ab und legten ein 28-seitiges Papier vor .
+Auf einem Sonderparteitag der SPD in Bonn stimmten am 21. Januar 56,4 Prozent der Delegierten für die Aufnahme von Koalitionsverhandlungen mit den Unionsparteien .
+Diese endeten am 7. Februar 2018 mit der Einigung von Union und SPD auf einen Koalitionsvertrag .
+Am 26. Februar 2018 stimmte ein CDU-Parteitag für eine Neuauflage der Großen Koalition , am 4. März 2018 wurde bekanntgegeben , dass 66 % der teilnehmenden SPD-Mitglieder bei einem Mitgliedervotum für den Koalitionsvertrag gestimmt haben .
+Angela Merkel wurde am 14. März 2018 mit 364 Ja-Stimmen ( 355 waren mindestens erforderlich ) im ersten Wahlgang erneut zur Bundeskanzlerin gewählt und anschließend durch den Bundespräsidenten vereidigt .
+Sie erhielt damit 35 Stimmen weniger , als CDU / CSU und SPD über Sitze im Bundestag verfügen .
+Nach großen Verlusten der Unionsparteien bei den Landtagswahlen in Bayern und Hessen 2018 hat Merkel am 29. Oktober 2018 in einer Präsidiumssitzung angekündigt , nicht mehr für das Amt der CDU-Vorsitzenden zu kandidieren und nach Ende der Legislaturperiode im Jahr 2021 das Amt der Bundeskanzlerin nicht erneut anzustreben .
+Am 7. Dezember 2018 übergab sie den Posten des Bundesvorsitz der CDU an Annegret Kramp-Karrenbauer nach deren Wahl im zweiten Wahlgang .
+Politische Positionen Datei : Angela Merkel und José Barroso vor dem Brandenburger Tor.jpg
+Außenpolitik Merkel ist Mitglied der Atlantik-Brücke , welche sich für intensive Beziehungen zwischen Deutschland und den Vereinigten Staaten einsetzt .
+Barack Obama bezeichnete Angela Merkel rückblickend gegen Ende seiner Präsidentschaft als seine außenpolitisch wichtigste Partnerin . Datei :P resident and First Lady Obama with Chancellor Merkel.jpg
+Zukunft der Europäischen Union Während eines EU-Gipfels in Brüssel am 7. November 2012 warb Bundeskanzlerin Angela Merkel für die Vereinigten Staaten von Europa : „ Ich bin dafür , dass die Kommission eines Tages so etwas wie eine europäische Regierung ist “ . 2005 äußerte Merkel – unter anderem bei einem Besuch in Istanbul – , sie favorisiere eine „ privilegierte Partnerschaft “ der Türkei statt einer Vollmitgliedschaft in der EU .
+Militärische Konfliktlösung Im Vorfeld des Irakkriegs bekundete Angela Merkel ihre Sympathien für die Irakpolitik der USA und die „ Koalition der Willigen “ . Sie kritisierte als deutsche Oppositionsführerin vom Boden der USA aus die Außenpolitik der Bundesregierung , was ihr scharfen Widerspruch aus Berlin einbrachte .
+Der SPD-Fraktionsvorsitzende Franz Müntefering beurteilte Merkels Äußerung als „ Bückling gegenüber der US-Administration “ .
+In einer Rede im Deutschen Bundestag am 19. März 2003 erklärte Merkel die Unterstützung der Union für das Ultimatum an Saddam Hussein als „ letzte Chance des Friedens “ und forderte die Bundesregierung auf , dies ebenso zu tun , um „ den Krieg im Irak wirklich zu verhindern “ .
+Angela Merkels Grundhaltung zu militärischen Konfliktlösungen beschreibt sie in Veröffentlichungen aus dieser Zeit .
+Als „ Ultima Ratio “ akzeptierte Merkel beispielsweise das NATO-Engagement im Kosovokrieg ( 1999 ) und stellt historische Vergleiche zur deutschen Geschichte an : Bezüglich des Abzugs der Atomwaffen in Deutschland besteht Merkel darauf , dass die Verhandlungen über den Abzug der Raketen gemeinsam mit den anderen Nato-Ländern und keinesfalls im Alleingang durchgeführt werden .
+Integrationspolitik Nachdem der türkische Ministerpräsident Erdoğan bei einem Deutschland-Besuch im Februar 2008 die Türken in Deutschland vor einer Assimilation gewarnt hatte , kritisierte sie dessen „ Integrationsverständnis “ .
+2010 erklärte sie auf dem Deutschlandtag der Jungen Union den „ Ansatz für Multikulti “ für gescheitert .
+Man müsse Migranten nicht nur fördern , sondern auch fordern .
+2013 sprach sie sich gegen die doppelte Staatsbürgerschaft und gegen die Trennung von muslimischen Jungen und Mädchen im Sportunterricht aus .
+Letzteres sei das „ völlig falsche integrationspolitische Signal “ und das Gegenteil von Integration . 2017 verteidigte Merkel die doppelte Staatsbürgerschaft auch gegen den Parteitags-Beschluss der CDU .
+In ihrer Parteitagsrede vom 6. Dezember 2016 befürwortete Merkel ein gesetzliches Vollverschleierungsverbot .
+Muslime in Deutschland Bei einem Besuch des türkischen Ministerpräsidenten Ahmet Davutoğlu im Berliner Kanzleramt sagte sie im Januar 2015 : „ Der frühere Bundespräsident Christian Wulff hat gesagt : Der Islam gehört zu Deutschland .
+Und das ist so .
+Dieser Meinung bin ich auch . “
+Anlässlich des islamischen Fastenmonats Ramadan im Jahre 2015 hat Angela Merkel zu gegenseitiger Wertschätzung der Religionen aufgerufen .
+Bei einem Empfang in Berlin bekräftigte sie zudem : „ Es ist offenkundig , dass der Islam inzwischen unzweifelhaft zu Deutschland gehört . “
+Vor Vertretern verschiedener Glaubensrichtungen verwies sie auf die weltweiten Gewalttaten im Namen einer Religion – „ zu oft leider im Namen des Islams “ . Doch jede Ausgrenzung von Muslimen in Deutschland , jeder Generalverdacht verbiete sich , sagte Merkel .
+Die allermeisten Muslime seien rechtschaffene und verfassungstreue Bürger .
+Islamistischer Terrorismus Auf die Frage , wie sie Deutschland vor dem islamistischen Terror schützen wolle , antwortete Merkel in einem Interview vom 18. September 2015 sinngemäß , der islamistische Terror im Ausland werde zum Teil aus Deutschland dorthin exportiert , da viele der im Ausland agierenden Terroristen in Deutschland aufgewachsen seien ; auch hätten die Europäer aufgrund ihrer eigenen geschichtlichen Vergangenheit in diesem Zusammenhang wenig Grund , Hochmut zu zeigen .
+Nahost-Politik Merkel hat sich bisher zurückhaltend zu einer deutschen Beteiligung an einer Friedenstruppe der Vereinten Nationen im Südlibanon zur Befriedung des Israel-Libanon-Konflikts geäußert .
+Israels Premier Olmert plädierte für die Beteiligung deutscher Soldaten .
+„ Ich habe Kanzlerin Angela Merkel mitgeteilt , dass wir absolut kein Problem haben mit deutschen Soldaten im Südlibanon “ , sagte er der Süddeutschen Zeitung .
+Zurzeit gebe es keine Nation , die sich Israel gegenüber freundschaftlicher verhalte als Deutschland .
+Am 18. März 2008 hielt Merkel in Israel vor der Knesset eine Rede , die sie auf Hebräisch begann . Sie betonte die historische Verantwortung Deutschlands für Israel ; die Sicherheit des jüdischen Staates sei Teil der deutschen Staatsräson und niemals verhandelbar .
+Merkel war die erste ausländische Regierungschefin , die von der Knesset zu einer Rede eingeladen worden war .
+Bei einem Telefonat mit dem israelischen Ministerpräsidenten Benjamin Netanjahu im Jahr 2011 sagte Merkel , ihr fehle „ jegliches Verständnis “ für die Genehmigung eines Siedlungsausbau in Ost-Jerusalem durch die israelische Regierung .
+Zum Bürgerkrieg in Syrien forderte Merkel im Dezember 2011 ein Urteil des UN-Sicherheitsrates gegen den syrischen Staatspräsidenten Baschar al-Assad und stellte sich auf die Seite der Opposition . Im TV-Duell erklärte sie jedoch , Deutschland werde sich nicht an einem Militärschlag gegen Syrien beteiligen . Merkel will eine gemeinsame Haltung mit der Europäischen Union finden .
+Weißrussland Bei einem Treffen mit dem italienischen Ministerpräsidenten Silvio Berlusconi sagte Merkel im Jahr 2011 , sie und Berlusconi seien sich einig , dass angesichts der Situation in Weißrussland leider wieder darüber gesprochen werden müsse , Sanktionen aufleben zu lassen , die sie eigentlich schon verlassen hätten .
+Sie sehe die Entwicklung in Weißrussland mit großer Sorge , im Besonderen auch den Umgang mit der Opposition .
+Ukraine Datei : Vladimir Putin at celebrating the 70th anniversary of D-Day ( 2014-06-06 ; 06 ) . jpeg Merkel engagierte sich im Rahmen des sogenannten Normandie-Formats „ Merkel-Hollande-Poroschenko-Putin “ mehrfach stundenlang bei der Konfliktlösung zwischen den pro-russischen bzw. kontra-russischen Kräften der Ostukraine , besonders beim Zustandekommen zweier Waffenstillstandsabkommen in der weißrussischen Hauptstadt Minsk , ( siehe auch Minsk II ) .
+Militärische Intervention in Libyen Datei : Secretary Clinton Poses for a Group Photo With World Leaders.jpg
+Im Vorfeld der militärischen Intervention in Libyen im Frühjahr 2011 zeigte sich Merkel überrascht darüber , „ mit welcher Schnelligkeit bestimmte Fragen ins Auge gefasst werden “ und kritisierte , dass es eine „ Reihe von französischen Aktivitäten “ gegeben habe , die „ erst sehr kurzfristig “ bekannt geworden seien .
+Gaddafi führe ohne Zweifel Krieg gegen die eigene Bevölkerung .
+Man müsse aber „ sehr aufpassen , dass wir nichts beginnen , was wir nicht zu Ende bringen können . “ Überrascht zeigte sie sich darüber , dass Frankreich den Nationalen Übergangsrat als libysche Regierung anerkannt hatte .
+Es handele sich dabei um keine Anerkennung im Sinne des Völkerrechts .
+Wirtschafts- und Sozialpolitik Merkel versuchte sich Ende 2000 mit der Formulierung einer „ Neuen Sozialen Marktwirtschaft “ zu profilieren .
+Der Titel greift den etablierten Begriff der Sozialen Marktwirtschaft auf .
+Unter den unscharfen Thesen , deren konkrete Umsetzung im Vagen bleibt , finden sich auch Positionen , die bereits im Schröder-Blair-Papier aus dem Jahr 1999 auftauchten .
+Eine CDU-Präsidiumskommission unter Merkels Vorsitz erarbeitete bis zum 27. August 2001 ein Diskussionspapier , das im Dezember 2001 auf dem Bundesparteitag der CDU in Dresden verabschiedet und somit Teil der CDU-Programmatik wurde .
+Datei : Flickr - europeanpeoplesparty - EPP Summit September 2010 ( 53 ) ( 1 ) . jpg
+Eurokrise Im Zuge der Finanzkrise ab 2007 kam es zur Eurokrise , die Merkel mit ihrer Politik zu lösen versuchte .
+Sie bekräftigte immer wieder , dass der Euro eine starke Währung sei und suchte die Unterstützung von Frankreichs Präsidenten Hollande . Insbesondere bei den französischen Sozialisten war dies umstritten .
+So attackierte Frankreichs Industrieminister Arnaud Montebourg Merkel scharf und verglich sie mit Bismarck .
+Merkel tritt für einen strikten Sparkurs ein , der von einigen Kritikern wie dem Internationalen Währungsfonds als wachstumshemmend und krisenverschärfend betrachtet wird . Im Februar 2010 schloss Merkel Finanzhilfen für Griechenland ausdrücklich aus , erteilte jedoch bereits zwei Monate später ihre Zustimmung für das erste deutsche Hilfspaket für Griechenland in Höhe von 17 Milliarden Euro . Ende 2012 sagte sie , dass sie sich einen weiteren Schuldenschnitt für Griechenland im Jahr 2014 vorstellen könne . Sie stimmte 2010 sowohl für die provisorische EFSF als auch 2012 für den ESM mit dem Ziel der Stabilisierung des Euros .
+Sie befürwortet den Aufkauf von Staatsanleihen von Krisenstaaten durch die Europäische Zentralbank , der zum Ziel hat , die Kreditaufnahme für die Krisenstaaten zu erleichtern . Merkel lehnt nach eigenem Bekunden EU-Anleihen , die der gemeinschaftlichen Schuldenaufnahme in der EU oder dem Euro-Währungsraum dienen könnten , ab .
+Sozialausgaben Auf dem Weltwirtschaftsforum in Davos , 2013 , begann Kanzlerin Merkel eine Serie von viel beachteten internationalen Statements , die allesamt zum Inhalt hatten , dass Europa nur 7 % der Weltbevölkerung stellt und nur 25 % des weltweiten Bruttosozialprodukts erwirtschaftet , aber für fast 50 % der weltweiten Sozialleistungen aufkommt .
+Seit diesem Statement in Davos wurde dieses Argument ein wiederkehrender Bestandteil ihrer wichtigsten Reden .
+Die internationale Finanzpresse , unter anderem der Londoner Economist sagte , ebenso wie Merkels Vision von vornherein als pragmatisch bezeichnet werden müsse , gelte Gleiches für ihren Plan zur Implementierung : Die Vision kann in drei Statistiken , einigen wenigen Karten und Fakten auf einer DIN-A-4-Seite zusammengefasst werden .
+Die Zahlen sind 7 % , 25 % und 50 % .
+Wenn Europa wettbewerbsfähig bleiben wolle , könne es sich schlicht nicht leisten , weiter so großzügig zu sein ( das war noch zwei Jahre vor der Flüchtlingskrise in Europa ab 2015 , bei der sie selbst eine andere Politik verfolgte , siehe unten ) .
+Der Economist verglich damals Merkels Verwendung dieser Zahlen mit dem Verhalten der britischen Premierministerin Margaret Thatcher , die zu gegebener Zeit Passagen von Friedrich Hayeks aus ihrer Handtasche zog .
+In ähnlichem Sinn äußerte sich die Financial Times , die hervorhob , dass Merkel einen eindeutigen Bezug zwischen den Sozialleistungen und der mangelnden Wettbewerbsfähigkeit herstelle .
+Familienpolitik Als Bundesministerin für Frauen und Jugend sah sich Angela Merkel in den neuen Bundesländern mit einer dramatisch gesunkenen Frauenerwerbsquote und , damit einhergehend , mit einem Einbruch der Geburtenrate konfrontiert .
+Hinzu kam die unterschiedliche Rechtslage zum Schwangerschaftsabbruch in Ost und West , die laut Einigungsvertrag von einer späteren gemeinsamen Regelung abgelöst werden sollte .
+Einen politischen Schwerpunkt während ihrer Amtszeit bildete daher die Neuregelung des § 218 und die Einführung einer faktischen Fristenlösung mit Beratungspflicht im gesamten Bundesgebiet .
+Der Verbesserung der beruflichen Situation von Frauen sollte das Gleichberechtigungsgesetz ( 1993/94 ) dienen .
+Als im Rückblick größten Erfolg ihrer Amtszeit bewertet Merkel die von ihr betriebene Änderung des Kinder- und Jugendhilfegesetzes .
+Diese Novellierung brachte den formellen Rechtsanspruch auf einen Kindergartenplatz für Kinder ab drei Jahren .
+Zur Diskussion um die Beschneidung aus religiösen Gründen und den Schutz der Unversehrtheit von Kindern positionierte sich Merkel im Juli 2012 : Merkel sprach sich gegen die steuerliche Gleichstellung von homosexuellen Paaren aus und erklärte , sie wolle die Privilegierung der Ehe erhalten .
+In diesem Zusammenhang stellte sich Merkel ausdrücklich gegen das gemeinsame Adoptionsrecht von gleichgeschlechtlichen Paaren .
+Diese Haltung begründete sie mit einem „ schlechten Bauchgefühl “ . Im Juni 2017 zeigte sie sich erstmals offen für eine Diskussion zur Eheöffnung , sprach von einer „ Gewissensentscheidung “ und gab schließlich am 27. Juni 2017 den Weg frei für eine Abstimmung ohne Fraktionszwang im Bundestag . Sie selbst stimmte gegen die Eheöffnung .
+Energie- und Umweltpolitik Im April 1995 war Merkel als deutsche Umweltministerin Gastgeberin der ersten UN-Klimakonferenz ( COP-1 ) in Berlin .
+Mit dem Berliner Mandat kam es zu einem Abschluss , der einen Einstieg in die internationale Reduzierung von Treibhausgasen bilden sollte .
+1997 bei den nachfolgenden Verhandlungen zum Kyoto-Protokoll setzte sich Merkel für vergleichsweise hohe Reduktionsziele ein .
+Eine Initiative zur Eindämmung des Sommersmogs in Deutschland scheiterte im Mai 1995 innerhalb des Kabinetts und wurde später nur in sehr abgeschwächter Form umgesetzt .
+Angela Merkel galt bis 2010 als Befürworterin der zivilen Nutzung von Kernenergie , der Stromgewinnung in Kernkraftwerken .
+In ihrem Amt war sie für die Abwicklung von Atommülltransporten zuständig .
+Im Mai 1998 wurden Überschreitungen der Grenzwerte bei Castor-Transporten nach Frankreich bekannt .
+Aus der Opposition wurde Merkels Rücktritt wegen der Verletzung der ministeriellen Aufsichtspflicht gefordert .
+Die Ministerin konnte jedoch darauf verweisen , dass wichtige Kompetenzen und Verantwortlichkeiten auch bei den Bundesländern und der Atomwirtschaft lagen .
+In Merkels Amtszeit fällt das Kreislaufwirtschaftsgesetz zur Vermeidung und Verwertung von Abfällen .
+In öffentlichen Äußerungen des Jahres 1997 findet sich die Forderung nach einer jährlich steigenden Abgabe auf Energieträger wie Öl , Gas und Strom ( Ökosteuer ) .
+Zwischenzeitlich erwarb sich Merkel in den Jahren 2006/07 den Ruf als „ Klimakanzlerin “ dank ihres Engagements für Klimaziele auf europäischer und internationaler Ebene , während der Stellenwert der Klimapolitik seither wieder sank . So nahm sie etwa beim UN-Klimagipfel in New York im September 2014 nicht mehr teil und besuchte stattdessen eine Tagung des Bundesverbands der Deutschen Industrie .
+Auch klimapolitische Initiativen sind noch nicht konkret geplant . Beispielsweise äußerte der Klimaforscher Mojib Latif , Merkel sei aufgrund des kaum vorhandenen Klimaschutzes in Deutschland sowie mehrfacher Interventionen für die Autoindustrie „ nie wirklich eine Klimakanzlerin “ gewesen .
+Von Kritikern wird Merkel vorgeworfen , Zusagen zu den von den Stromverbrauchern zu tragenden Kosten der von ihr maßgeblich beeinflussten Energiewende nicht eingehalten zu haben .
+Entgegen ihrer Aussage in einer Regierungserklärung im Jahre 2011 , wonach die von allen Energieverbrauchern zu tragende EEG-Umlage nicht über die Größenordnung von 3,5 ct / kWh steigen soll , ist diese Umlage weiter angestiegen und beträgt derzeit ( 2019 ) 6,405 ct / kWh .
+Asylpolitik In der Flüchtlingskrise 2015 fand Merkels Entscheidung vom 4. September 2015 , in Absprache mit den Regierungschefs von Österreich und Ungarn den an der österreichisch-ungarischen Grenze und in Budapest festsitzenden Flüchtlingen vor allem aus Syrien und Afghanistan die Einreise nach Deutschland ohne Registrierung durch Ungarn zu gestatten , großes Echo in den Medien und der Öffentlichkeit innerhalb und außerhalb Deutschlands .
+Zugleich unterstrich Merkel die Bedeutung einer einheitlichen europäischen Flüchtlings- und Asylpolitik .
+Zu den erklärten Eckpunkten ihrer Asyl-Politik gehören eine hohe Priorität für die Integration von Anfang an , schnellere Asylverfahren mit beschleunigter Abschiebung von allein aus wirtschaftlicher Not kommenden Menschen , klare Regeln und keine Toleranz für Parallelgesellschaften und eine konsequente Verfolgung fremdenfeindlicher Angriffe . Sie äußerte : „ Wenn Europa in der Flüchtlingsfrage versagt , dann ginge ein entscheidender Gründungsimpuls eines geeinten Europas verloren .
+Nämlich die enge Verbindung mit den universellen Menschenrechten , die Europa von Anfang an bestimmt hat und die auch weiter gelten muss . “ Zudem vertritt sie den Standpunkt , dass der aktuelle Zustrom der Migranten „ mehr Chancen als Risiken “ für Deutschland biete , wenn die Integration gelinge . In einem Interview sagte sie am 11. September 2015 unter anderem : „ Das Grundrecht auf Asyl für politisch Verfolgte kennt keine Obergrenze ; das gilt auch für die Flüchtlinge , die aus der Hölle eines Bürgerkriegs zu uns kommen . “ Großes Medienecho fand ihr Satz : Angesichts der großen Anzahl von Flüchtlingen erreichte aber die Zustimmung der Bundesbürger für Merkel im Oktober 2015 einen Tiefpunkt .
+Mit der Arbeit der Bundeskanzlerin waren laut ARD-Deutschlandtrend nur noch 54 Prozent der Befragten zufrieden , das waren neun Prozent weniger als im Vormonat , zudem handelte es sich um den schlechtesten Wert seit Dezember 2011 .
+In einer CDU / CSU-Fraktionssitzung , in der Merkel drei Stunden lang mit Kritik aus der Fraktion konfrontiert wurde , sagte sie : Am 13. Dezember 2015 formulierte in Karlsruhe ein Parteitag der CDU in einem Leitantrag einen Kompromiss , in dem einerseits Merkels Asylpolitik , insbesondere die konsequente Ablehnung von Obergrenzen , mit großer Mehrheit unterstützt wurde , andererseits das Ziel festgeschrieben wurde , „ die Zahl der Flüchtlinge spürbar zu reduzieren “ . Diese Formulierung fand am folgenden Tag in einer Gastrede auch die Billigung des Hauptbefürworters der „ Kontingente “ , des CSU-Parteivorsitzenden Horst Seehofer . Merkel bestätigte nochmals ihren Satz vom 31. August „ Wir schaffen das “ und ergänzte „ Ich kann das sagen , weil es zur Identität unseres Landes gehört “ .
+Am 16. Dezember unterstützte sie vor dem Bundestag in Berlin in einer Regierungserklärung zur Asylpolitik die Absicht der EU , ihre Außengrenzen , auch bei gegenteiliger Meinung der betroffenen Länder , verstärkt durch EU-eigene Organisationen wie Frontex zu schützen .
+Merkels Haltung rief wiederholte Kritik aus der eigenen Fraktion , besonders jedoch aus der CSU , hervor .
+Der bayerische Ministerpräsident Horst Seehofer bezeichnete Merkels Nicht-Aktivität an den Grenzen als „ Herrschaft des Unrechts “ und forderte mehrfach eine Obergrenze für Flüchtlinge .
+Außerdem wurde Merkels Flüchtlingspolitik von verschiedenen Intellektuellen wie beispielsweise dem Althistoriker Alexander Demandt , dem Philosophen Peter Sloterdijk oder der Schriftstellerin Monika Maron kritisiert . Der Historiker Jörg Baberowski bemängelte sowohl Merkels Flüchtlingspolitik als auch die Versuche , Kritiker in eine „ dunkeldeutsche “ Ecke zu verbannen . Der Entwicklungsökonom Paul Collier sieht zum Beispiel eine Politik der offenen Grenzen grundsätzlich als ethisch verwerflich an , weil sie den Menschen eine Art russisches Roulette aufnötige : Sie kommen über das Mittelmeer und müssen hoffen , dass ihr Boot nicht untergehe , ehe sie von Hilfsschiffen aufgenommen werden .
+In seiner Leitkolumne in der New York Times warnte Ross Douthat vor der demographischen Auswirkung angesichts einer millionenfachen Zuwanderung mehrheitlich junger Männer , warf Merkel eine „ edelgesinnte Verrücktheit “ vor und forderte sie zum Rücktritt auf . Auf der anderen Seite wählte die Zeitschrift Time Merkel zur Person des Jahres 2015 für ihre Haltung in der Flüchtlingskrise sowie ihre Rolle in der Ukraine-Krise .
+Im Januar 2016 schränkte Merkel bei einer Landesvertreterversammlung der CDU in Neubrandenburg ein , dass sie von den meisten Flüchtlingen erwarte , dass diese „ wenn wieder Frieden in Syrien ist , wenn der IS im Irak besiegt ist , sie mit dem Wissen , das sie bei uns erworben haben , wieder in ihre Heimat zurückkehren . “ Nur ein geringer Teil habe Anspruch auf klassisches Asyl , die meisten Flüchtlinge genössen nur einen zeitweiligen Schutz durch die Genfer Flüchtlingskonvention .
+Innere Sicherheit In einem von der CSU in Auftrag gegebenen Gutachten vom Januar 2016 kam der Jurist und Bundesverfassungsrichter a. D.
+Udo di Fabio zu dem Befund , die Bundesregierung breche mit ihrer Weigerung , die Landesgrenzen umfassend zu kontrollieren , die Verfassung .
+Die Staatsgrenzen seien „ die tragenden Wände der Demokratien “ . Der wenngleich schwierigen Aufgabe , sie zu schützen , könne sich keine Regierung entziehen .
+Ende Juli 2016 machte Merkel den Vorschlag , eine Nationalgarde aus Reservisten mit militärischer oder polizeilicher Ausbildung zu gründen , um die Polizei bei der Inneren Sicherheit zu unterstützen .
+Am 19. August 2016 erklärte Angela Merkel : In der Neujahrsansprache 2016/2017 erklärte Merkel unter Bezug auf den Anschlag auf den Berliner Weihnachtsmarkt an der Gedächtniskirche und andere terroristische Vorfälle : Bei der Klausurtagung der CDU in Perl am 14. Januar 2017 erklärte Merkel : Sie kündigte Sicherheit durch einen an .
+Verkehrs- und Infrastrukturpolitik Kurz vor der Bundestagswahl 2013 kam es zu einem öffentlichen Dissens zwischen Merkel und Horst Seehofer ( CSU ) zur Frage „ PKW-Maut “ . Während des Wahlkampfes betonte Merkel ihre ablehnende Haltung gegenüber der „ PKW-Maut “ . Sie bekräftigte im Kanzlerduell mit Peer Steinbrück ihr „ Nein “ zu einer PKW-Maut mit den Worten : „ Mit mir wird es keine Pkw-Maut geben “ , allerdings setzte sich die CSU später im Koalitionsvertrag durch .
+Rezeption Öffentlichkeitsarbeit Seit dem 8. Juni 2006 wendet sich Merkel als erstes Regierungsoberhaupt weltweit per Video-Podcast an die Öffentlichkeit . Sie nutzt dieses Medium wöchentlich ( samstags ) , um den Bürgern die Politik der jeweiligen Regierungskoalition zu vermitteln .
+Zunächst wurde der Podcast für etwa 6500 Euro pro Episode vom Merkel-Biografen Wolfgang Stock produziert .
+Nach Kritik am Stil der Videobotschaft wurde die Produktion neu ausgeschrieben .
+Den Zuschlag erhielt die Evisco AG aus München .
+Da Jürgen Hausmann , einer der Vorstände der Evisco AG , ein Schwiegersohn des damaligen bayerischen Ministerpräsidenten Edmund Stoiber ist , wurden in den Medien Zweifel am ordnungsgemäßen Ablauf des Ausschreibungsverfahrens laut .
+Das ausschreibende Bundespresseamt wies die Vorwürfe zurück .
+Tremor Weltweite Beachtung erhält seit Juni 2019 ein nach Expertenmeinung wohl gesundheitlich unbedenklicher orthostatischer Tremor , der bei Merkel innerhalb weniger Wochen nur im bewegungslosen Stehen während zweier Staatsempfänge und einer Ministerernennung auftrat . Die militärische Zeremonie der darauf folgenden Staatsempfänge absolvierte sie im Sitzen . Auf diesbezügliche Fragen antwortete Merkel , es gebe keinen Grund zur Sorge und die Öffentlichkeit dürfe davon ausgehen , dass sie stets der „ Verantwortung “ ihres Amtes entsprechend handele und auf ihre „ Gesundheit achte “ .
+Satire Seit Merkels Amtantritt als Bundeskanzlerin wurde ihre Person verschiedentlich zum Zwecke der Satire parodiert .
+Internationale Bekanntheit erlangte in diesem Zusammenhang Tracey Ullman mit ihren Sketchen in Tracey Ullman ’ s Show .
+Popkultur Merkel-Raute Datei : AM Juli 2010 - 3zu4.jpg Merkel ist für eine stereotype Geste bekannt , bei der sie ihre Hände mit den Innenflächen so vor dem Bauch hält , dass sich die Daumen und Zeigefinger an den Spitzen berühren .
+Dadurch bildet sich die Form einer Raute , was in der Presse als Merkel-Raute kolportiert wurde . Zur Bundestagswahl 2013 nutzte die CDU im Rahmen einer Personalisierungsstrategie die für die Kanzlerin typische Geste der Merkelraute und bildete sie auf einem Riesenplakat in Berlin ab . Berlins ehemaliger SPD-Landeschef Jan Stöß bezeichnete dies als Personenkult .
+Deutschlandkette Als Deutschlandkette wurde eine Halskette bekannt , die die deutsche Bundeskanzlerin Angela Merkel am 1. September 2013 beim Fernsehduell anlässlich der Bundestagswahl 2013 trug .
+Merkozy Merkozy ( auch : Sarkel bzw. Sarkokel ) ist ein von den Medien kreiertes Kofferwort aus den Nachnamen von Angela Merkel und dem französischen Staatspräsidenten Nicolas Sarkozy .
+Das Konzept wurde nach der Ablösung Sarkozys fortgesetzt , wobei Merkhollande ( ab 2012 , auch Merkollande ) und Mercron ( ab 2017 ) deutlich weniger genutzt wurden und werden .
+Merkelphone Ein vom Bundesamt für Sicherheit in der Informationstechnik zugelassenes abhörsicheres Mobiltelefon wird in der Öffentlichkeit häufig unter der Bezeichnung Merkelphone geführt .
+Auszeichnungen und Ehrungen Staatliche Orden Datei : Merkel an Obama Presidential Medal of Freedom.jpg
+Großes Verdienstkreuz des Verdienstordens der Bundesrepublik Deutschland , erhalten 1996 Großkreuz des Verdienstordens der Italienischen Republik , verliehen am 21. März 2006 König-Abdulaziz-Orden , der höchste Orden Saudi-Arabiens für ausländische Regierungschefs , erhalten im Jahr 2007 Großkreuz des norwegischen Verdienstordens , erhalten am 15. Oktober 2007 Großkreuz des Verdienstordens der Bundesrepublik Deutschland , erhalten von Bundespräsident Horst Köhler am 11. Januar 2008 Großkreuz des Ordens El Sol del Perú , verliehen vom peruanischen Präsidenten Alan García am 17. Mai 2008
+Großkreuz des Ordens des Infanten Dom Henrique , verliehen vom portugiesischen Präsidenten Aníbal Cavaco Silva am 2. März 2009
+Orden „ Stara Planina “ , der höchste bulgarische Orden , erhalten am 11. Oktober 2010 Presidential Medal of Freedom , die gleichrangig mit der Congressional Gold Medal höchste zivile Auszeichnung der Vereinigten Staaten von Amerika , erhalten von Präsident Barack Obama am 7. Juni 2011
+„ Ehrenmedaille des Präsidenten “ , höchste Auszeichnung Israels ( 2014 ) , erhalten von Präsident Schimon Peres am 25. Februar 2014
+Großes Goldenes Ehrenzeichen am Bande für Verdienste um die Republik Österreich , verliehen am 27. August 2015 vom österreichischen Bundeskanzler Werner Faymann
+Auszeichnungen privater Organisationen Datei : EPP Congress Marseille 2011 a.jpg
+Preis der Deutschen Gesellschaft e. V.
+für Verdienste um die deutsche und europäische Verständigung im Jahr 2005 .
+Leo-Baeck-Preis des Zentralrats der Juden in Deutschland im Jahr 2007
+World Statesman Award der Appeal of Conscience Foundation , verliehen im Jahr 2007 für ihr bisheriges Lebenswerk
+Robert-Schuman-Medaille der EVP verliehen 2007 Europe Award of Merit-Medaille der B ’ nai B ’ rith , erhalten am 11. März 2008 für ihr Engagement im Kampf gegen den Antisemitismus und Rassismus
+Karlspreis , erhalten am 1. Mai 2008 „ für ihre Verdienste um die Weiterentwicklung der Europäischen Union “ . Die Laudatio hielt der französische Staatspräsident Nicolas Sarkozy .
+Lucius D. Clay Medaille 2009 Eric-M.-Warburg-Preis der Atlantik-Brücke , verliehen am 25. Juni 2009 in der Library of Congress in Washington , D. C.
+Deutscher Medienpreis 2009 , ausgezeichnet am 9. Februar 2010 in Baden-Baden .
+Die Jury begründete ihre Entscheidung damit , dass im Mittelpunkt ihres politischen Denkens und Handelns stets der Mensch stehe .
+„ Die Würde und die Rechte des Individuums leiten Angela Merkel bei ihren politischen Entscheidungen , die geprägt sind von Berechenbarkeit und Verlässlichkeit “ . Weiter verfolge die Kanzlerin einen Kurs , „ der die Partnerschaft in den Vordergrund stellt , ohne dass sie die manchmal notwendige Konfrontation scheut “ .
+Leo-Baeck-Medaille , erhalten am 21. September 2010 in New York für ihr Engagement für die Aussöhnung zwischen Juden und Deutschen
+Kaiser-Otto-Preis , erhalten am 24. August 2011 in Magdeburg für Verdienste um die europäische Vereinigung Preis für Verständigung und Toleranz des Jüdischen Museums Berlin , erhalten am 24. Oktober 2011 in Berlin Heinz-Galinski-Preis ( 28. November 2012 )
+Indira-Gandhi-Friedenspreis 2013
+Abraham-Geiger-Preis , 2015
+Freedom Medal des Four Freedoms Awards , 2016
+Eugen-Bolz-Preis für das Jahr 2017
+Elie Wiesel Award für das Jahr 2017 , ausgestellt vom United States Holocaust Memorial Museum
+Lampe des Friedens vom Franziskaner-Konvent in Assisi ihre Bemühungen um die Versöhnung und das friedliche Zusammenleben der Völker , erhalten am 15. Mai 2018
+Fulbright-Preis 2018
+Ehrendoktorwürden Datei : Merkelunileipzigdr.jpg
+Ehrendoktorwürde in Philosophie der Hebräischen Universität Jerusalem , verliehen im Jahr 2007 Ehrendoktorwürde der Universität Leipzig , verliehen am 3. Juni 2008 durch die Fakultät für Physik und Geowissenschaften „ für ihre Verdienste um das Fachgebiet Physik und seine Reputation bei ihrem Einsatz für den Schutz der Umwelt , der Demokratie und der Menschenrechte “ . Die Laudatio hielt Javier Solana .
+Ehrendoktorwürde der Technischen Universität Breslau , verliehen am 24. September 2008 für ihre Verdienste um die Annäherung zwischen Deutschland und Polen
+Ehrendoktorwürde der New School , verliehen am 19. Februar 2009 .
+Die Laudatio hielt Fritz Stern .
+Ehrendoktorwürde der Universität Bern , verliehen am 5. Dezember 2009 durch den Senat und die Universitätsleitung bei deren 175.
+Stiftungsfeier für ihren Einsatz für das öffentliche Wohl und den Klimaschutz sowie für ihre Verdienste um die europäische Integration , die Pflege des jüdisch-christlichen Dialogs und ihr Engagement für die Anliegen der Frauen
+Ehrendoktorwürde der Universität Russe in Bulgarien , erhalten am 11. Oktober 2010
+Ehrendoktorwürde der Babeș-Bolyai-Universität , erhalten am 12. Oktober 2010 in Klausenburg / Cluj ( Rumänien ) für „ ihre Verdienste um Europa und ihren Beitrag zur Lösung der Globalisierungs-Probleme “
+Ehrendoktorwürde der Ewha Frauenuniversität , erhalten am 11. November 2010 in Seoul
+Ehrendoktorwürde der Universität Tel Aviv , verliehen am 1. Februar 2011
+Ehrendoktorwürde der Radboud-Universität Nijmegen , verliehen am 23. Mai 2013
+Ehrendoktorwürde der Comenius-Universität Bratislava , verliehen am 20. Oktober 2014
+Ehrendoktorwürde der Universität Szeged , verliehen am 2. Februar 2015
+Ehrendoktorwürde der Universität Nanjing , verliehen am 12. Juni 2016
+Ehrendoktorwürden der Katholischen Universität Löwen und der Universität Gent , verliehen am 12. Januar 2017
+Ehrendoktorwürde der Universität Haifa , verliehen am 4. Oktober 2018
+Ehrendoktorwürde der Universität Harvard , verliehen am 30. Mai 2019 durch die juristische Fakultät
+Sonstige In den Ranglisten des US-Wirtschaftsmagazins Forbes hat Merkel während ihrer Kanzlerschaft häufig hohe Positionen erreicht .
+In den Jahren 2006 bis 2009 und seit 2011 steht sie in der Liste der 100 mächtigsten Frauen der Welt auf dem ersten Platz . Auf der Liste der mächtigsten Personen der Welt rangierte sie im Jahr 2012 hinter Barack Obama auf Platz 2. Es ist der höchste Rang , den jemals eine Frau in dieser Liste erreicht hat . 2013 lag sie hinter Papst Franziskus auf dem 5. Platz und 2015 hinter Wladimir Putin und vor Barack Obama auf Platz 2. Für das US-Nachrichtenmagazin Time gehörte sie bisher ( Stand : 2016 ) achtmal zu den 100 Personen , die die Welt am meisten prägten , nämlich 2006 , 2007 , 2009 , 2011 , 2012 , 2014 , 2015 und 2016 .
+Am 9. Dezember 2015 kürte sie Time zur Person of the Year , der ersten Deutschen mit dieser Würdigung seit Willy Brandt 1970 . Auf dem Titelbild der Zeitschrift wurde sie als „ Chancellor of the Free World “ ( Kanzlerin der Freien Welt ) bezeichnet .
+Am 16. Februar 2008 wurde sie zum Ehrenmitglied von Energie Cottbus ernannt .
+Am 2. Juni 2011 wurde im Rahmen ihres Besuchs in Singapur eine Orchideen-Züchtung der Gattung Dendrobium auf den Namen „ Dendrobium Angela Merkel “ getauft .
+In der ersten Hälfte der 2010er Jahre kamen viele Menschen als Flüchtlinge nach Deutschland .
+In mehreren Fällen benannten Eltern aus Dankbarkeit für das Engagement Angela Merkels in der Flüchtlingssache ihr neugeborenes Kind nach Angela Merkel .
+In der Presse erwähnt ist ein syrisches Kind mit dem Vornamen Angela Merkel ; ein weiteres syrisches Kind mit dem Namen Serbia Merkel Al-Mustafa ; das als Christ Merkel benannte Kind einer Kamerunerin und die Tochter einer Ghanaerin Angela Merkel Adé . Nach Auskunft des namenskundlichen Instituts in Leipzig sei diese Form der Verehrung in vielen Kulturen üblich .
+Ehrenbürger der Stadt Templin ( Seit 27. Juni 2018 )
+Veröffentlichungen ( ) Filme Wolfgang Landgraeber , Wilfried Prill : Kohls Mädchen , Kohls Erbin – Angela Merkels Weg zur Macht . ( Phoenix , 2000 ) Torsten Körner , Matthias Schmidt : Angela Merkel – Die Unerwartete .
+( Broadview TV , MDR , in Zusammenarbeit mit arte , 2016 ) Literatur ( alphabetisch geordnet )
+Nikolaus Blome : Angela Merkel – Die Zauderkünstlerin . Pantheon .
+München 2013 , ISBN 978-3-570-55201-8 . Ralph Bollmann : Die Deutsche : Angela Merkel und wir . Klett-Cotta , Stuttgart 2013 , ISBN 978-3-608-94750-2 . Jacqueline Boysen : Angela Merkel .
+Eine Karriere .
+2. Auflage .
+Ullstein , Berlin 2005 , ISBN 978-3-548-36832-0 . Judy Dempsey : Das Phänomen Merkel – Deutschlands Macht und Möglichkeiten . Edition Körber-Stiftung , Hamburg 2013 , ISBN 978-3-89684-097-4 . Stephan Hebel : Mutter Blamage und die Brandstifter .
+Das Versagen der Angela Merkel – warum Deutschland eine echte Alternative braucht .
+Westend , Frankfurt am Main 2017 , ISBN 978-3-86489-162-5 . Ders . : Merkel .
+Bilanz und Erbe einer Kanzlerschaft .
+Westend , Frankfurt am Main 2018 , ISBN 978-3-86489-254-7 . Margaret Heckel : So regiert die Kanzlerin .
+Eine Reportage .
+Piper , München 2009 , ISBN 978-3-492-05331-0 . Uwe-Karsten Heye , Hugo Müller-Vogg : Steinbrück oder Merkel ?
+Deutschland hat die Wahl .
+Quadriga , Berlin 2013 , ISBN 978-3-86995-056-3 . Gertrud Höhler : Die Patin .
+Wie Angela Merkel Deutschland umbaut .
+Orell Füssli , Zürich 2012 , ISBN 978-3-280-05480-2 . Stefan Kornelius : Angela Merkel .
+Die Kanzlerin und ihre Welt .
+Hoffmann und Campe , Hamburg 2013 , ISBN 978-3-455-50291-6 . Dirk Kurbjuweit : Alternativlos – Merkel , die Deutschen und das Ende der Politik . Hanser , München 2014 , ISBN 978-3-446-24620-1 . Günther Lachmann , Ralf Georg Reuth : Das erste Leben der Angela M. Piper , München 2013 , ISBN 978-3-492-05581-9 . Gerd Langguth : Angela Merkel .
+Aufstieg zur Macht .
+Biografie .
+Aktualisierte und erweiterte Neuausgabe .
+Deutscher Taschenbuch Verlag , München 2007 , ISBN 978-3-423-34414-2 . Jule Philippi : Heimatliebe ist mehr als eine Spreewaldgurke , Weisheiten unserer Kanzlerin . Rowohlt-Taschenbuch , Reinbek bei Hamburg 2006 , ISBN 978-3-499-62217-5 . Philip Plickert ( Hrsg. ) : Merkel : Eine kritische Bilanz . FinanzBuch Verlag , München 2017 , ISBN 978-3-95972-065-6 . Volker Resing : Angela Merkel .
+Die Protestantin .
+Ein Porträt .
+Überarbeitete und ergänzte Neuausgabe .
+Benno , Leipzig 2015 , ISBN 978-3-7462-4563-8 . Andreas Rinke : Das Merkel-Lexikon : Die Kanzlerin von A–Z . Dietrich zu Klampen , Springe 2016 , ISBN 978-3-86674-540-7 . Evelyn Roll : Das Mädchen und die Macht .
+Angela Merkels demokratischer Aufbruch .
+Rowohlt , Berlin 2001 , ISBN 978-3-87134-429-9 . Cora Stephan : Angela Merkel .
+Ein Irrtum .
+Knaus , München 2011 , ISBN 978-3-8135-0416-3 . Wolfgang Stock : Angela Merkel .
+Eine politische Biographie .
+Neuauflage .
+Olzog , München 2005 , ISBN 978-3-7892-8168-6 . Weblinks Persönliche Website
+Angela Merkel auf Die Bundeskanzlerin , Website des Presse- und Informationsamtes der Bundesregierung
+Hanns Jürgen Küsters : Biographie .
+In : Konrad-Adenauer-Stiftung , Geschichte der CDU Einzelnachweise Die Aussprache des Namens Angela mit Betonung auf der ersten Silbe ist viel häufiger als mit Betonung auf der zweiten Silbe ( außer in Österreich , siehe Duden online ) . Merkel bevorzugt jedoch die Betonung auf der zweiten Silbe , siehe Gerd Langguth : Angela Merkel . DTV , München 2005 , ISBN 3-423-24485-2 , S. 50. Siehe die Mitgliederlisten des Deutschen Bundestages für die 19. Wahlperiode ( ab 2017 ) ( 44,0 % ) , 18. Wahlperiode ( ab 2013 ) ( 56,2 % ) , 17. Wahlperiode ( ab 2009 ) ( 49,3 % ) , 16. Wahlperiode ( ab 2005 ) ( 41,3 % ) , 15. Wahlperiode ( ab 2002 ) ( 41,6 % ) , 14. Wahlperiode ( ab 1998 ) ( 37,3 % ) , 13. Wahlperiode ( ab 1994 ) ( 48,6 % ) , 12. Wahlperiode ( ab 1990 ) ( 48,5 % ) . , FAZ In : Die Welt , 16. März 2013 . , In : FAZ , 22. März 2013 https://www.promiflash.de/news/2012/03/09/angela-merkel-trieb-ihre-lehrer-in-den-wahnsinn.html Thüringer Allgemeine vom 17. Juli 2014 . Untersuchung des Mechanismus von Zerfallsreaktionen mit einfachem Bindungsbruch und Berechnung ihrer Geschwindigkeitskonstanten auf der Grundlage quantenchemischer und statistischer Methoden . Dissertation zur Erlangung des akademischen Grades Doktor eines Wissenschaftszweiges ( Dr. rer. nat. ) ; Diplom-Physikerin Angela Merkel geboren am 17. Juli 1954 ; eingereicht bei der Akademie der Wissenschaften der DDR Forschungsbereich Chemie , Zentralinstitut für physikalische Chemie ; Berlin , den 8. Januar 1986 . Gerd Langguth : Angela Merkel . Aufstieg zur Macht . Biografie . Deutscher Taschenbuch Verlag , 2. Auflage , München 2007 , ISBN 978-3-423-34414-2 , S. 116 ; Mein Weg . Angela Merkel im Gespräch mit Hugo Müller-Vogg . Hoffmann und Campe , Hamburg 2005 , ISBN 3-455-09538-0 , S. 62. DDR-Vergangenheit holt Merkel ein : Nichts verheimlicht – nicht alles erzählt , ntv . de , 13. Mai 2013 auf Konrad Adenauer Stiftung , abgerufen am 1. November 2015 . Youtube-Video eines Vortrags von Vera Lengsfeld . Stefan Wolter : In : Der Tagesspiegel , 10. August 2014 . Siehe zu Kohls politischem Kalkül dabei Hans-Peter Schwarz : Helmut Kohl : Eine politische Biographie . 2. Auflage . DVA , München 2012 , S. 382 , 760. Angela Merkel : In : Frankfurter Allgemeine Zeitung , 22. Dezember 1999 , zitiert in : Deutsche Geschichte in Dokumenten und Bildern . Abgerufen am 22. Juli 2015 . Hans Peter Schütz : Wolfgang Schäuble . Zwei Leben . Droemer , München 2012 , S. 98–101 . Rühe war 1989–1992 CDU-Generalsekretär und 1992–1998 Bundesminister der Verteidigung . Merz war seit Oktober 1998 stellvertretender Vorsitzender der CDU / CSU-Bundestagsfraktion . Stoiber war seit 1993 bayerischer Ministerpräsident und CSU-Vorsitzender . Als Edmund Stoiber Kanzler werden wollte auf welt.de , 26. August 2013 , abgerufen 27. Mai 2017 Nico Grasselt , Karl-Rudolf Korte : Führung in Politik und Wirtschaft . Instrumente , Stile und Techniken . VS Verlag für Sozialwissenschaften , Wiesbaden 2007 , S. 180–183 . FAZ . net : . 24. September 2007.Spiegel Online : Außenminister-Gespräch : Peking versetzt Steinmeier . 24. September 2007.Bundespresseamt : Rede von Bundeskanzlerin Angela Merkel im Europäischen Parlament . 17. Januar 2007.Spiegel Online : EU-Verfassung : Kanzlerin fordert Gottesbezug . 25. Mai 2006 . in der Netzeitung , 6. Oktober 2008.p2news.com : Kabinett beschließt Abwrackprämie . 27. Januar 2009.welt.de : Merkel favorisiert Opel-Übernahme durch Magna . 28. August 2009 . Merkel muss Ackermann-Gästeliste veröffentlichen , DIE ZEIT online 20. März 2012bundesregierung.de : . 5. November 2008.google.com / hostednews : . Merkel will mehr Waffenkontrollen . auf : faz . de , 15. März 2009 , abgerufen am 31. Oktober 2015 . auf stern.deBundeswahlleiter : Offenbach Post , 27. September 2009 , abgerufen am 31. Oktober 2015 . Angela Merkels Duellant auf : Süddeutsche Zeitung , 17. Mai 2010 , abgerufen am 31. Oktober 2015 . Spiegel Online : Dämpfer bei Kanzlerwahl : Schwarz-Gelb verweigert Merkel volle Stimmenzahl . 28. Oktober 2009 . In : Süddeutsche Zeitung , 24. März 2011 . In : FAZ . net , 21. Februar 2011.Katja Tichomirowa : In : Frankfurter Rundschau , 28. Februar 2011 . Deutscher Bundestag : Pressemitteilung mit Links zu Rechtsänderungen und Maßnahmen . ( PDF ; 382 kB ) Ergebnisbericht von Infratest Dimap vom April 2011 . Jacob Appelbaum , Holger Stark , Marcel Rosenbach , Jörg Schindler : Artikel vom 23. Oktober 2013 im Portal spiegel.de , abgerufen am 23. Oktober 2013 . Christian Tretbar : Artikel vom 23. Oktober 2013 im Portal tagesspiegel.de , abgerufen am 23. Oktober 2013 . , Presseerklärung des Weißen Hauses vom 23. Oktober 2013 zum Telefongespräch zwischen US-Präsident Obama und Bundeskanzlerin Merkel am 23. Oktober 2013 , abgerufen im Portal whitehouse.gov am 23. Oktober 2013 . Ian Traynor , Philip Oltermann , Paul Lewis : Artikel vom 23. Oktober 2013 im Portal theguardian.com , abgerufen am 23. Oktober 2013 . , Artikel vom 24. Oktober 2013 im Portal faz . net , abgerufen am 29. Oktober 2013 . David E. Sanger , Mark Mazzetti : Artikel vom 24. Oktober 2013 im Portal nytimes.com , abgerufen am 26. Oktober 2013 . Artikel vom 26. Oktober 2013 im Portal spiegel.de , abgerufen am 26. Oktober 2013 . Artikel vom 26. Oktober 2013 im Portal faz . net , abgerufen am 26. Oktober 2013 . Artikel vom 29. Oktober 2013 im Portal spiegel.de , abgerufen am 29. Oktober 2013 . Artikel vom 27. Oktober 2013 im Portal tagesspiegel.de , abgerufen am 27. Oktober 2013 . Artikel vom 27. Oktober 2013 im Portal focus.de , abgerufen am 27. Oktober 2013 . Michael Backhaus , Kayhan Özgenc : Artikel vom 27. Oktober 2013 im Portal bild.de , abgerufen am 27. Oktober 2013 . Artikel vom 31. Oktober 2013 im Portal sueddeutsche.de , abgerufen am 31. Oktober 2013 . Artikel vom 31. Oktober 2013 im Portal n-tv.de , abgerufen am 31. Oktober 2013 . Artikel vom 27. Oktober 2013 im Portal faz . net , abgerufen am 27. Oktober 2013 . Artikel vom 27. Oktober 2013 im Portal focus.de , abgerufen am 27. Oktober 2013 . Matthias Rüb : Artikel vom 27. Oktober 2013 im Portal faz . net , abgerufen am 27. Oktober 2013 . Artikel vom 26. Oktober 2013 im Portal zeit.de , abgerufen am 1. November 2013 . Artikel vom 1. November 2013 im Portal handelsblatt.com , abgerufen am 1. November 2013 . . Artikel vom 26. November 2013 im Portal tagesschau.de , abgerufen am 5. Februar 2014 . „ Wiederwahl als Parteichefin : 89,5 Prozent für Merkel . “ tagesschau.de . Zugegriffen 6. Dezember 2016 . Merkel wirbt für Vereinigte Staaten von Europa Hamburger Abendblatt , 7. November 2012 , abgerufen am 31. Oktober 2015 Westerwelle will Abzug aller US-Atomraketen . In : Handelsblatt , 24. Oktober 2009 ( online ) Spiegel Online : Integrationsdebatte : Merkel knöpft sich Erdogan vor . 11. Februar 2008 , abgerufen am 7. Dezember 2016.Spiegel Online : Integration : Merkel erklärt Multikulti für gescheitert , 16. September 2010 , abgerufen am 7. Dezember 2016 . Süddeutsche Zeitung : Merkel bekräftigt Nein zu doppelter Staatsangehörigkeit , am 28. Mai 2013 , abgerufen am 7. Dezember 2016 . Die Welt Online : Die Welt : Merkel ist gegen getrennte Sportstunden für Muslime , abgerufen am 7. Dezember 2016 . Berliner Zeitung : CDU-Parteitag Merkel über Vollverschleierung und Volksverhetzung , abgerufen am 7. Dezember 2016.Spiegel Online : Kanzlerin Merkel : „ Der Islam gehört zu Deutschland “ , vom 12. Januar 2015 , abgerufen am 9. Januar 2016 . „ Für Merkel gehört der Islam offenkundig zu Deutschland “ , in : Die Zeit , vom 1. Juli 2015 , abgerufen am 9. Januar 2016 . „ Islam gehört unzweifelhaft zu Deutschland “ , in : Handelsblatt , vom 1. Juli 2015 , abgerufen am 9. Januar 2016 . YouTube : Interview mit Angela Merkel am 18. September 2015 , abgerufen am 23. März 2017 . Süddeutsche Zeitung : Israels Premier – „ Niemand kann uns stoppen “ . 3. August 2006 . Frankfurter Allgemeine Zeitung : Dokumentation : Die Rede der Kanzlerin vor der Knesset . 18. März 2008 . Frankfurter Allgemeine Zeitung : Kanzlerin vor der Knesset – Merkel : Wir sind mit Israel auf immer verbunden . 18. März 2008 . In : Spiegel Online , 30. September 2011 , abgerufen am 21. Februar 2013 . auf : Die Zeit , 1. September 2013 , abgerufen am 31. Oktober 2015 . Merkel droht Belarus mit Sanktionen auf : Süddeutsche Zeitung , 12. Januar 2011 , abgerufen am 31. Oktober 2015 . Angela Merkel : „ Der Euro wird stark bleiben “ auf : Webseite der CDU , 24. April 2013 , abgerufen am 31. Oktober 2015 . Le Figaro : „ Merkel comparée à Bismarck ? Montebourg persiste “ vom 1. Dezember 2011 Französischer Sozialist – Merkel will " Euro töten " vom 30. November 2011 IWF warnt Merkel vor zu striktem Sparkurs Handelsblatt , 3. Juni 2013 , abgerufen am 31. Oktober 2015 . , Münchner Merkur , 28. Februar 2010 , abgerufen am 31. Oktober 2015 . Rede von Bundeskanzlerin Merkel beim Jahrestreffen 2013 des World Economic Forum Die Bundesregierung , 24. Januar 2013 , abgerufen am 1. November 2015 . unter anderem bei der Verleihung der Ehrendoktorwürde an der Universität Szeged in Ungarn , siehe : Rede von Bundeskanzlerin Merkel anlässlich der Verleihung der Ehrendoktorwürde der Universität Szeged Die Bundesregierung 2. Februar 2015 , abgerufen am 1. November 2015 . auf : The Economist , 15. Juni 2013 , abgerufen am 1. November 2015 . auf Financial Times ( kostenpflichtiger Zugang ) . Der Wirtschaftswissenschaftler Arno Tausch von der Corvinus University kam hingegen in seiner Untersuchung zu dem Schluss , dass basierend auf den Daten über die globalen Sozialschutzausgaben in 169 Staaten der ILO in Genf sowie der Weltbank über das Bruttonationaleinkommen ( GNI ) gemessen in Kaufkraftparitäten für Merkels Aussage gar keine Grundlage bestehe . Nach Tausch würden die 27 der 28 EU-Staaten mit kompletten Daten nur 33 % der weltweiten Sozialausgaben tätigen , während die 13 nicht-EU-Mitgliedsländer der OECD , unter ihnen die reichen angelsächsischen überseeischen Demokratien und Japan , 40 % der weltweiten Sozialschutzausgaben tätigen , die BRICS-Staaten 18 % und der Rest der 9 % . Irland , Ungarn , Luxemburg und Litauen brauchen nach dieser Studie weniger als 2 % ihres BIP , um 1 % der Bevölkerung aus der Armut zu heben , während in Deutschland mehr als 3 % des BIP verwendet werden , um 1 % der Bevölkerung aus der Armut zu heben , und in Griechenland mehr als 6 % . Statt europäische Sozialleistungen zu kürzen , sollte Deutschland sein eigenes Sozialsystem besser zur Armutsbekämpfung gestalten und ansonsten vom erfolgreichen De-facto-Keynesianismus in den überseeischen angelsächsischen Demokratien lernen . Vgl. Tausch , Arno , Wo Frau Kanzlerin Angela Merkel Irrt : Der Sozialschutz in Der Welt , Der Anteil Europas Und Die Beurteilung Seiner Effizienz ( Where Chancellor Angela Merkel Got it Wrong : Social Protection in the World , Europe ’ s Share in it and the Assessment of its Efficiency ) ( September 4 , 2015 ) . Bei Social Science Research Network online 4. September 2015 , abgerufen am 1. November 2015 . auf : Focus , 16. Juli 2012 , abgerufen am 1. November 2015 . In : Spiegel online , 1. Dezember 2012 , abgerufen am 1. November 2015 . Bundestag beschließt Ehe für alle – Merkel stimmt dagegen . In : Spiegel online , 30. Juni 2017 , aufgerufen am 25. Februar 2018 . Silke Kersting : In : Handelsblatt , 23. Mai 2017 . Abgerufen am 28. Juli 2018 . George Monbiot : In : The Guardian , 19. September 2017 . Abgerufen am 28. Juli 2018 . Antwort der Bundesregierung auf die Kleine Anfrage der Abgeordneten Annalena Baerbock , Bärbel Höhn , Jürgen Trittin , weiterer Abgeordneter und der Fraktion BÜNDNIS 90/DIE GRÜNEN – Drucksache 18/2290 – Klimaaußenpolitik der Bundesregierung mit Blick auf die VN-Klimakonferenz im Jahr 2015 in Paris In : Die Welt , 27. Juli 2018 . Abgerufen am 28. Juli 2018 . In : ZDF heute , 28. Juli 2018 . Abgerufen am 28. Juli 2018 . Spiegel Online : Wien rechnet mit 10.000 Flüchtlingen aus Ungarn 5. September 2015 , abgerufen 14. Oktober 2016 . , Reuters , 5. September 2015 , abgerufen 28. Oktober 2015 . , Günter Bannas in FAZ online vom 20. September 2015 , abgerufen 28. Oktober 2015 . Rheinische Post online 11. September 2015 : , abgerufen am 1. November 2015.ARD-Deutschlandtrend , 1. Oktober 2015 : wz . de , 14. Dezember 2015 , abgerufen am 16. Dezember 2015 FAZ , , 22. Februar 2016 Kanzlerin schließt Einführung von Pkw-Maut aus , online auf spiegel.de vom 1. September 2013 . Bundespresseamt : auf bundeskanzlerin.de Focus : Merkel-Podcast : Auftrag für Stoibers Schwiegersohn . 10. August 2006 . ORF : Angela Merkels Videoblog neu vergeben . 10. August 2006 . Bundeskanzlerin Merkel zittert zum dritten Mal – „ Mir geht es gut “ , Handelsblatt , 10. Juli 2019 , abgerufen am 20. Juli 2019 Angela Merkel nach Zitteranfällen : „ Ich achte auf meine Gesundheit “ , SPIEGEL ONLINE , 11. Juli 2019 , abgerufen am 20. Juli 2019 Rolling Stone : Grandiose Comedy : Tracey Ullman parodiert Bundeskanzlerin Angela Merkel . 21. Januar 2016 . Cidadãos Nacionais com Ordens Portuguesas – Página Oficial das Ordens Honoríficas Portuguesas The Whitehouse : Rede von Barack Obama vom 15. Februar 2011 . Ehrung im Juni : Obama überreicht Merkel Freiheitsmedaille , Der Spiegel , 4. April 2010 . In : haGalil.com , 21. Februar 2014 . Bundeskanzleramt Österreich , 27. August 2015 , abgerufen am 1. November 2015 . Zentralrat der Juden in Deutschland : von Wolf Biermann und von Merkel anlässlich der Verleihung des Leo-Baeck-Preises Die Tageszeitung : Ehrungen die die Welt nicht braucht : Merkel wird „ World Statesman “ . 26. September 2007 . Aufzeichnung der Verleihung des Karlspreises 2008 auf der Website des WDR , gesehen 17. Juni 2012 . abgerufen am 12. Juli 2012 ( PDF ; 1,7 MB ) Meldung vom 22. Januar 2010 auf stern.de „ Eure Rede aber sei ja , ja , nein , nein “ domradio.de , 28. November 2012 , abgerufen am 1. November 2015 . sapo.pt : Prémio da Paz Indira Gandhi foi para … Merkel , 19. November 2013 ( portugiesisch ) , abgerufen am 20. November 2013 . , Webseite vom 21. April 2016 im Portal fourfreedoms.nl , abgerufen am 22. April 2016 Eugen Bolz-Preis für Angela Merkel Deutschlandfunk vom 12. Mai 2018 Merkel mit Fulbright-Preis ausgezeichnet . Süddeutsche Fulbright Prize for International Understanding an Dr. Angela MerkelCouncil of the European Union : Laudatio by EU High Representative Javier Solana at the occasion of the honorary doctorate for Dr Angela Merkel . 3. Juni 2008 ( PDF ; 126 kB ) Stern online vom 11. November 2010 . , abgerufen am 23. Mai 2013 . In : Forbes , 19. August 2009 ( englisch ) ; In : Spiegel Online , 22. Mai 2013 , abgerufen am 3. November 2015 ; In : Rheinische Post , 29. Mai 2014 ; Cynthia Kroet : In : Politico , 6. Juni 2016 ( englisch ) . In : Deutsche Welle , 6. Dezember 2012 , abgerufen am 28. Dezember 2012 ( englisch ) . In : Welt.de , 5. November 2015 . Michael Elliott : In : Time.com , 8. Mai 2006 ; Henry Kissinger : In : Time.com , 3. Mai 2007 ; Michael Elliott : In : Time.com , 30. April 2009 ; Christine Lagarde : In : Time.com , 21. April 2011 ; Michael Schuman : In : Time.com , 18. April 2012 ; Jürgen Klinsmann : In : Time.com , 23. April 2014 ; Petro Poroschenko : In : Time.com , 16. April 2015 ; Samantha Power : In : Time.com , 21. April 2016 ( englisch ) . Karl Vick : In : Time.com , 9. Dezember 2015 ( englisch ) . Fabienne Piepiora : Artikel vom 12. Januar 2016 im Portal waz . de , abgerufen am 12. Januar 2016 . [ 1 ] . Artikel vom 29. April 2016 im Portal focus.de , abgerufen am 24. Februar 2017 . Unbekannter Autor : Artikel vom 4. Dezember 2015 im Portal waz . de , abgerufen am 12. Januar 2016 . 
+
+Datei : Alicia Silverstone 2019 by Glenn Francis.jpg Alicia Silverstone [ ] ( * 4. Oktober 1976 in San Francisco ) ist eine US-amerikanische Schauspielerin , Autorin sowie Tierschutz- und Umweltaktivistin .
+Bekanntheit erlangte sie in den 1990er Jahren durch den Film Clueless – Was sonst ! und als Batgirl in Batman &amp; Robin sowie durch ihre Auftritte in drei Musikvideos der Band Aerosmith .
+Jugend Silverstone wurde als Tochter britischer Eltern , eines Immobilieninvestors und einer Flugbegleiterin , geboren .
+Sie hat zwei ältere Geschwister , eine Halbschwester aus der ersten Ehe ihres Vaters und einen Bruder . Alicia Silverstone kommt aus einer jüdischen Familie und bezeichnet sich selbst als jüdisch . Sie wuchs in San Francisco auf und besuchte die „ Crocker Middle School “ und anschließend die „ San Mateo High School “ .
+Im Alter von sechs Jahren begann Silverstone zu modeln und trat in Werbespots auf , erstmals für Domino ’ s Pizza .
+Sie verbrachte ihre Sommerferien gern in England , wo sie eine wachsende Begeisterung für dortige Theateraufführungen entwickelte .
+Neben Ballettstunden belegte sie deswegen mit 13 Jahren auch Schauspielkurse .
+Karriere Ihre erste Rolle war 1992 ein Auftritt in der elften Episode der fünften Staffel der Fernsehserie Wunderbare Jahre als Jessica .
+Ihre erste Kinorolle hatte sie in dem Film Das Biest ein Jahr später .
+Um die Auflagen für Kinderarbeit zu umgehen , beantragte Silverstone im Alter von 15 Jahren erfolgreich die rechtliche Selbständigkeit .
+Für den Film wurde sie mit zwei MTV Movie Awards ausgezeichnet .
+Bei dieser Preisverleihung fiel sie Steven Tyler , dem Leadsänger der Rockband Aerosmith auf , was ihr eine Rolle in drei Videos der Band einbrachte , Cryin ’ , Amazing und Crazy .
+In dem Video von Crazy spielte sie zusammen mit Liv Tyler , der Tochter des Sängers .
+Ihren schauspielerischen Durchbruch hatte sie 1995 mit der Komödie Clueless – Was sonst ! , in der sie zum typischen Beispiel des kalifornischen Teenagers wurde .
+Die Regisseurin Amy Heckerling besetzte Silverstone in der Hauptrolle , nachdem sie sie in den Aerosmith-Videos gesehen hatte .
+Clueless war sowohl bei Kritikern als auch beim Kinopublikum ein Erfolg .
+Silverstone konnte erneut zwei MTV Movie Awards gewinnen und schloss einen Vertrag für zehn Millionen Dollar mit Columbia TriStar über weitere Filme .
+Im selben Jahr war sie auch in der Romanverfilmung Innocent Babysitter zu sehen .
+1997 spielte sie das Batgirl in der vierten Batman - Verfilmung Batman &amp; Robin an der Seite von George Clooney .
+Der Film erhielt überwiegend schlechte Kritiken und Silverstone wurde mit dem Negativpreis Goldene Himbeere als schlechteste Nebendarstellerin prämiert .
+Des Weiteren war sie in einer Hauptrolle in der Komödie Ärger im Gepäck neben Benicio del Toro und Christopher Walken zu sehen .
+Erstmals war sie hier auch als Produzentin tätig .
+1999 spielte sie an der Seite von Brendan Fraser die Hauptrolle in der romantischen Komödie Eve und der letzte Gentleman .
+Datei : Alicia Silverstone main.jpg Zu Beginn des neuen Jahrtausends zog sich Silverstone aus dem Mainstream-Kino zurück und stand überwiegend für Independent-Filme und Fernsehprojekte vor der Kamera .
+Außerdem spielte sie in einigen Theaterstücken .
+Im Jahr 2000 war sie in der Shakespeare - Adaption Verlorene Liebesmüh ’ ( von und mit Kenneth Branagh ) zu sehen .
+In dem Film musste sie auch singen und tanzen .
+Ab 2001 lieh sie der Comicfigur Sharon Spitz in der Serie Braceface ihre Stimme und erhielt dafür 2002 eine Nominierung für den Fernsehpreis Emmy .
+2002 gab sie ihr Broadway - Debüt als Elaine Robinson in dem Stück Die Reifeprüfung neben Kathleen Turner .
+Ein Jahr später spielte sie die Hauptrolle einer jungen Anwältin in der Serie Kate Fox &amp; die Liebe .
+Die Serie erhielt gute Kritiken und Silverstone wurde für einen Golden Globe nominiert , trotzdem war sie kein Erfolg und wurde nach einer Staffel wieder eingestellt .
+2004 war sie an der Seite von Sarah Michelle Gellar in der erfolgreichen Komödie Scooby Doo 2 zu sehen und spielte 2005 eine Friseurin in Beauty Shop , der Fortsetzung des Films Barbershop .
+2006 war Silverstone als Jack Starbright in Stormbreaker neben Ewan McGregor und Mickey Rourke zu sehen .
+Der Film entstand nach dem Roman Das Geheimnis von Port West von Anthony Horowitz aus der Alex Rider-Buchreihe .
+Ursprünglich sollten weitere Bücher dieser Reihe verfilmt werden , da der Film jedoch kein finanzieller Erfolg war , wurden keine Fortsetzungen produziert .
+2008 hatte sie einen Cameo-Auftritt in der Komödie Tropic Thunder .
+Von 2009 bis 2010 stand sie für das Theaterstück Time Stands Still auf der Bühne .
+Das Stück sowie Silverstones Leistung wurden positiv aufgenommen . 2010 beendete sie ihre Mitarbeit an dem Stück , um sich wieder ihrer Filmkarriere zu widmen .
+Ihre Rolle der Mandy wurde mit Christina Ricci neu besetzt .
+2010 spielte sie eine Lehrerin in der Teenagerkomödie Von der Kunst , sich durchzumogeln .
+Im gleichen Jahr drehte sie neben Sigourney Weaver den Vampirfilm Vamps – Dating mit Biss , welcher allerdings erst zwei Jahre später den Weg ins Kino fand . Für diesen Film stand sie nach Clueless zum zweiten Mal unter der Regie von Amy Heckerling vor der Kamera .
+Des Weiteren spielte sie neben Hugh Jackman und Jennifer Garner in dem Drama Alles in Butter , das ebenfalls 2012 in den amerikanischen Kinos veröffentlicht wurde .
+2012 spielte Silverstone eine wiederkehrende Rolle in der Serie Suburgatory an der Seite ihres ehemaligen Clueless-Kollegen Jeremy Sisto .
+2013 drehte sie den Serien-Piloten HR , indem sie die Leiterin einer Personalabteilung darstellt , die nach einer Kopfverletzung ihre Lebenseinstellung ändert . In Ass Backwards – Die Schönsten sind wir ( 2013 ) übernahm Silverstone die Rolle der ehemaligen Schönheitskönigin Laurel .
+Die Komödie wurde 2013 auf einigen Filmfestivals gezeigt und in Deutschland direkt auf DVD veröffentlicht .
+Persönliches Seit mehreren Jahren ist Silverstone eines der prominentesten Gesichter mehrerer PeTA-Kampagnen , die sich für Tierrechte und den Veganismus einsetzen .
+Sie selbst ist Veganerin seit 1998 . 2004 wurde sie von PeTA zur Sexiest Female Vegetarian gekürt .
+2007 ließ sie sich nackt für einen Werbespot und Plakatwerbung der Tierschutzorganisation ablichten . 2016 ließ sie sich für eine Werbekampagne gegen das Tragen von Wolle erneut nackt fotografieren .
+2009 erschien The Kind Diet , ein von ihr geschriebenes Buch über vegane Ernährung , das inzwischen unter dem Titel Meine Rezepte für eine bessere Welt auch auf Deutsch erschienen ist .
+Das Buch schaffte es auf Platz 1 der Bestsellerliste der New York Times . Dazu betreibt sie ein Weblog . 2014 erschien ihr zweites Buch , The Kind Mama , in dem sie für Attachment Parenting wirbt .
+Seit dem 11. Juni 2005 war sie mit Christopher Jarecki , dem Sänger der Band S. T. U. N. , verheiratet . Sie lebten in Los Angeles .
+Am 5. Mai 2011 wurden sie Eltern eines Jungen .
+2018 ließen sie sich scheiden .
+Filmografie Filme 1993 : Das Biest ( The Crush ) 1993 : Die Macht der Liebe ( Torch Song , Fernsehfilm ) 1993 : Scherben des Glücks ( Scattered Dreams , Fernsehfilm ) 1994 : Cool and the Crazy ( Fernsehfilm ) 1995 : Le Nouveau Monde1995 : Hideaway – Das Versteckspiel ( Hideaway ) 1995 : Clueless – Was sonst !
+( Clueless ) 1995 : Innocent Babysitter ( The Babysitter ) 1995 : Deception – Tödliche Täuschung ( True Crime ) 1997 : Batman &amp; Robin1997 : Ärger im Gepäck ( Excess Baggage ) 1999 : Eve und der letzte Gentleman ( Blast from the Past ) 2000 : Verlorene Liebesmüh ’ ( Love ’ s Labour ’ s Lost ) 2002 : Global Heresy2003 : Abgezockt !
+( Scorched ) 2004 : Scooby Doo 2 – Die Monster sind los ( Scooby Doo 2 : Monsters Unleashed ) 2005 : Beauty Shop2005 : Silence Becomes You – Bilder des Verrats ( Silence Becomes You ) 2006 : Stormbreaker2006 : Licht der Hoffnung ( Candles on Bay Street , Fernsehfilm ) 2008 : Tropic Thunder2011 : Von der Kunst , sich durchzumogeln ( The Art of Getting By ) 2012 : Alles in Butter ( Butter ) 2012 : Vamps – Dating mit Biss ( Vamps ) 2013 : Ass Backwards – Die Schönsten sind wir ( Ass Backwards ) 2013 : Gods Behaving Badly2014 : Angels in Stardust2014 : Ab durch den Dschungel ( Jungle Shuffle , Sprechrolle ) 2015 : Das Königreich des Nussknackers ( The Nutcracker Sweet , Sprechrolle ) 2016 : King Cobra2016 : Catfight2016 : Space Dogs : Auf zum Mond ( Space Dogs Adventure to the Moon , Sprechrolle ) 2016 : Wer kriegt den Hund ?
+( Who Gets the Dog ? ) 2017 : Gregs Tagebuch – Böse Falle !
+( Diary of a Wimpy Kid : The Long Haul ) 2017 : The Killing of a Sacred Deer2017 : The Tribes of Palos Verdes2018 : Book Club – Das Beste kommt noch ( Book Club ) 2019 : The Lodge Fernsehserien 1992 : Wunderbare Jahre ( The Wonder Years , Folge 5x11 Road Test ) 2001–2003 : Alles klar , Sharon Spitz ? ( Braceface , Sprechrolle , 54 Folgen ) 2003 : Kate Fox &amp; die Liebe ( Miss Match , 18 Folgen ) 2007 : The Singles Table ( 5 Folgen ) 2011 : Childrens Hospital ( Folge 3x10 Munch by Proxy ) 2012 : Suburgatory ( 4 Folgen ) 2015 : Making a Scene with James Franco ( 3 Folgen ) 2018 : American Woman ( 11 Folgen ) Theater 1993 : Carol ’ s Eve 2002 : Die Reifeprüfung ( The Graduate )
+2006 : Boston Marriage 2007 : Speed the Plow 2009–2010 : Time Stands Still 2012 : The Performers 2015 : Of Good Stock
+Musikvideos 1993 : Cryin ' ( Aerosmith ) 1993 : Amazing ( Aerosmith ) 1994 : Crazy ( Aerosmith ) 2009 : Her Diamonds ( Rob Thomas ) 2011 : Fight for Your Right Revisited ( Beastie Boys ) Bibliografie 2009 : The Kind Diet ( Meine Rezepte für eine bessere Welt .
+Arkana Verlag , April 2011 ) 2014 : The Kind Mama Auszeichnungen und Nominierungen Weblinks Alicia Silverstones Blog : The Kind Life Einzelnachweise http://www.imdb.com/name/nm0000224/bio?ref_=nm_ov_bio_sm huffingtonpost.com cinefacts.de moviepilot.de http://www.serienjunkies.de/news/aliciasilverstone-uebernimmt-hauptrolle-pilot-47177.html http://www.stern.de/video/alicia-silverstone--nackt-fuer-peta-fotoshooting-7207244.html thatsfit.com nytimes.com thekindlife.com | text = Archivlink | url = http://red-carpet.de/lifestyle/alicia-silverstone-gibt-tipps-zu-kinderernaehrung-das-darf-ihr-sohn-nicht-essen-201426885 | wayback = 20140424160239 spielfilm.de http://www.broadwayworld.com/off-broadway/article/Alicia-Silverstone-returns-to-MTC-Tickets-just-49-for-Of-Good-Stock-20150615 
+
+Datei : Biruni-russian.jpg Abu r-Raihan Muhammad ibn Ahmad al-Biruni ( ; persisch auch nur kurz , Abū Raiḥān Bīrūnī ) – kurz auch ( al- ) Biruni ; geboren am 4. September 973 in der choresmischen Hauptstadt Kath ( unweit des heutigen Chiwa in Usbekistan ) ; gestorben am 9. Dezember 1048 in Ghazna ( heute in Afghanistan ) war ein persischer ( choresmischer ) Universalgelehrter , Mathematiker , Kartograf , Astronom , Astrologe , Philosoph , Pharmakologe , Mineraloge , Forschungsreisender , Historiker und Übersetzer in Zentralasien .
+Leben und Werk Datei : Lunar eclipse al-Biruni.jpg Datei : AzerbazkanBiruni.JPG Die ersten 20 Jahre lebte Abū r-Raiḥān Muḥammad ibn Aḥmad in Choresmien , wo er schon in jungen Jahren von dem Gelehrten Abu Nasr Mansur ibn Iraq ausgebildet wurde .
+Als die von Kath aus herrschende Afrighiden-Dynastie , welcher al-Biruni nahestand , 995 von den Mamuniden aus Gurgandsch gestürzt wurde , verließ er das Land und ging an den Hof des Samaniden Mansur II .
+nach Buchara .
+Hier wirkte zu dieser Zeit auch der vor allem als Mediziner und Philosoph bekannte Ibn Sina ( Avicenna ) , mit dem al-Biruni ( nachdem er um 997 einen programmatischen Briefwechsel eingeleitet hatte ) viele Jahre lang zusammenarbeitete und den er auch in seiner „ Chronologie “ aus dem Jahr 1000 erwähnte .
+998 zog er nach Tabaristan und lebte am Hof des Ziyariden Qabus ( Qābūs ibn Wuschmagīr ) , bevor er in seine Heimat zurückkehrte , wo er sieben Jahre lang zum Gurgandschischen Gelehrtenkreis um Khwarazm-Schah Mamun II .
+gehörte .
+Offenbar hatte er zuvor mit den Mamuniden Frieden geschlossen und die Beobachtung einer Mondfinsternis am 24. Mai 997 in Kath zeigt , dass er Choresmien schon eher wieder besucht haben muss .
+Al-Biruni hatte damals mit Abu'l - Wafa verabredet , dass dieser das Ereignis in Bagdad beobachtet ; durch einen Vergleich der notierten Eintrittszeiten des Erdschattens konnten sie die Differenz in den geographischen Längen von Kath und Bagdad bestimmen .
+Al-Biruni beschäftigte sich in dieser Zeit mit Astronomie , Geschichte und Kartografie .
+1017 eroberte der Ghaznawidensultan Mahmud von Ghazni Choresmien und nahm al-Biruni , Abu Nasr Mansur ibn Iraq und andere als seine Gefangenen mit nach Ghazna .
+In der Folgezeit erhielt al-Biruni von Mahmud finanzielle Zuwendungen für astronomische Aufgaben .
+Die Beobachtung einer Sonnenfinsternis am 8. April 1019 in Laghman nördlich von Kabul zeigt , dass er sich zumindest im Herrschaftsbereich Mahmuds frei bewegen konnte .
+Er bestimmte auch die genaue geographische Breite von Kath. Ab 1022 beherrschte Mahmud Teile von Nordindien .
+Al-Biruni begleitete ihn auf diesen Feldzügen .
+Er war der erste islamische Wissenschaftler , der sich mit der brahmanischen Wissenschaft beschäftigte und darüber im Kitab al-Hind umfassend berichtete .
+Al-Biruni , dessen Muttersprache choresmisch war , übersetzte zahlreiche arabische und griechische Werke ins Sanskrit , darunter die Elemente des Euklid .
+1023 ermittelte er mit einem von ihm erfundenen neuen Messverfahren den Radius der Erdkugel zu 6339,6 km , was dem realen heutigen Wert am Äquator von 6378,1 Kilometer recht nahe kommt .
+Abu ' r-Raihan Muhammad al-Biruni konstruierte das erste Pyknometer .
+Damit bestimmte er die Dichte ( das spezifische Gewicht ) von unterschiedlichen Materialien .
+Ehrungen Datei : Biruni Iranian.jpg Eine moderne Stadt im Bereich von al-Birunis Geburtsort wurde 1958 ihm zu Ehren in Beruniy umbenannt .
+Die Universität Schiraz benannte ihr astronomisches Observatorium Abu Reihan Observatorium .
+Die Internationale Astronomische Union ( IAU ) ehrte ihn durch die Benennung des Mondkraters Al-Biruni .
+Schriften Al-Biruni schrieb etwa 146 Bücher mit geschätzten 13.000 Seiten Umfang und tauschte sich mit Kollegen wie Avicenna ( Ibn Sina ) per Briefverkehr aus .
+Etwa ein Fünftel seines Werkes ist erhalten geblieben , darunter : al-Qānūn al-Masʿūdī , ein Sultan Masud I. von Ghazni gewidmetes Handbuch der Astronomie
+„ Buch der Unterweisung in die Anfänge der Kunst der Sterndeutung “ Kitāb aṣ-Ṣaidala : Pharmakognosie , ein alphabetisches Verzeichnis von Heilpflanzen und Nahrungsmitteln Kitāb al-Ǧamāhir fī maʿrifat al-ǧawāhir , ein Buch über Mineralien
+Kitāb Taḥdīd nihāyat al-amkin li-taṣḥīḥ masāfāt al-masākin , ein Buch über Geodäsie
+Kitāb Tārīḫ al-Hind , ein Buch zur Geschichte Indiens
+Kitāb al-Āṯār al-bāqiya ʿan al-qurūn al-ḫāliya ( „ Buch der Hinterlassenschaften früherer Jahrhunderte “ ) , ein dem Ziyariden Qabus gewidmetes Geschichtswerk ( entstanden um 1000 ) – englische Übersetzung von Sachau : The chronology of ancient nations ( Digitalisat ) Literatur Karl Schoy : Die trigonometrischen Lehren des persischen Astronomen Abu'l -Rai.h.n Mu. h.
+Ibn A. hmad al-Bîrûnî : dargestellt nach Al-q.nûn al-masûdî
+.
+Nach dem Tode des Verfassers herausgegeben von Julius Ruska und Heinrich Wieleitner .
+Hannover , Orient-Buchhandlung Lafaire , 1927 Muhammad Taqi ad-Din al-Hilali : Die Einleitung zu Al-Birunis Steinbuch .
+Mit Erläuterungen übersetzt .
+Dissertation unter Aufsicht von Richard Hartmann und Hans Heinrich Schaeder .
+Mit einer Widmung an Herbert W. Duda .
+Leipzig , Harrassowitz Verlag 1941 . Digitalisat
+Gotthard Strohmaier Al-Biruni , Spektrum der Wissenschaft Mai 2001 Friedrun R. Hau : al-Bīrūnī , Abū Raiḥān . In : Werner E. Gerabek , Bernhard D. Haage , Gundolf Keil , Wolfgang Wegner ( Hrsg. ) : Enzyklopädie Medizingeschichte . De Gruyter , Berlin / New York 2005 , ISBN 3-11-015714-4 , S. 184. Weblinks Hogendijk , Jan : The Works of al-Bīrūnī ( englisch ) – Handschriften , kritische Editionen , Übersetzungen und online Versionen
+Artikel in der Encyclopædia Iranica 4/3 ( 1989 ) , 274ff .
+Abu Raihan Mohamad al Biruni das Buch über Mineralien ( englisch ) , Online Version Anmerkungen Den Beinamen „ al-Bīrūnī “ hat er erst später bekommen , wahrscheinlich wegen seiner skeptischen Haltung . Die Anhänger des griechischen Skeptikers Pyrrhon , die Pyrrhoneer , hießen arabisch Bīrūnīyūn . Gotthard Strohmaier : Avicenna . Beck , München 1999 , ISBN 3-406-41946-1 , S. 43–56 . 
+
+Ankara [ ] , früher Angora ( antiker Name , ) , ist seit 1923 die Hauptstadt der Türkei und der gleichnamigen Provinz Ankara .
+Die Stadt , die nach türkischem Recht als Großstadtgemeinde ( Büyükşehir Belediyesi ) verfasst und nunmehr flächen- und einwohnermäßig mit der gleichnamigen Provinz identisch ist , hatte 2015 5,27 Millionen Einwohner und ist damit nach Istanbul die zweitgrößte Stadt des Landes .
+Datei : Ankara Overview From Citadel.JPG
+Etymologie und Name der Stadt Die genaue etymologische Herkunft des Namens Ankara ist nicht bekannt .
+Pausanias berichtet , dass König Midas an der Stelle einen Anker gefunden haben und die Stadt dann dort dem Gegenstand entsprechend als Ankyra ( griechisch für Anker ) gegründet haben soll .
+Stephanos von Byzanz behauptet , die Galater hätten im Kampf gegen die Ptolemäer aus Ägypten nach dem Sieg einen Anker als Kriegstrophäe mitgebracht und diese Bezeichnung bei der Gründung der Stadt im Stadtnamen verewigt .
+Es sind Münzprägungen mit Ankermotiv bekannt .
+Dagegen gibt es Hinweise , dass die Stadtbezeichnung schon seit den Phrygern oder gar den Hethitern in einer ähnlichen Form benutzt und später von den Griechen zu Ancyra umgewandelt wurde .
+Ähnlich wurde in der islamischen Zeit Ankaras die These aufgestellt , die damals Engürü genannte Stadtbezeichnung stamme von dem persischen Wort für Traube ( engûr ) ab , das sich auf die üppigen Weinanbaugebiete um Ankara beziehe .
+Am 28. März 1930 erhielt die Hauptstadt anstelle der in der lateinischen Schrift bis dahin bei den Europäern und im Verkehr mit Europäern üblichen neugriechischen Namensform Angora die offizielle Bezeichnung Ankara .
+Die türkischen Namensformen waren Engüriye , Engürü oder Engüri ; frühere Namensformen waren ( alt- ) griechisch Ankyra , lateinisch Ancyra , arabisch Anḳira und Anḳuriyya oder Ḳalʿat al-Salāsil , zu deutsch „ Kettenfestung “ .
+Geographie und Klima Datei : Ankara , Turkey.jpg Ankara liegt rund 900 m bis 1050 m über dem Meeresspiegel und hat ein streng trockenes Kontinentalklima , das durch heiße trockene Sommer und kalte schneereiche Winter geprägt ist .
+Die Stadt liegt nördlich am Fuße des Köroğlu-Gebirges und zieht sich südlich in Richtung Konya-Plateau .
+Die Jahresdurchschnittstemperatur beträgt 12,2 ° C.
+Die wärmsten Monate sind Juli und August mit durchschnittlich knapp 24 ° C , die kältesten Januar und Februar mit Temperaturen etwas über dem Gefrierpunkt .
+Die meisten Niederschläge fallen im April mit durchschnittlich 51 Millimetern , die geringsten Niederschläge werden für den Monat August mit 12 Millimeter im Mittel verzeichnet .
+Die Jahressumme der Niederschläge beträgt im Schnitt 404 mm ; damit ist Ankara eines der trockensten Gebiete der Türkei .
+In der Stadt vereinigen sich zwei kleine Bäche namens Hatip Çayı , auch Bent Deresi genannt , und Çubuk Çayı zu dem Ankara-Fluss ( Ankara Çayı ) , der in der Stadt größtenteils überbaut und stark verschmutzt ist .
+Geschichte Antike und byzantinische Zeit Datei : AugustusAnkara1.jpg Ursprünglich eine blühende phrygische Siedlung an der persischen Königsstraße , wurde es Zentrum des keltischen Stammes der Galater , die etwa 230 v. Chr. in Kleinasien siedelten .
+189 v. Chr. wurde Ancyra von Gnaeus Manlius Vulso besetzt , blieb aber unter regionaler Herrschaft .
+25 v. Chr. wurde es Hauptstadt der römischen Provinz Galatien .
+Aus der Zeit erhalten geblieben ist der Augustustempel , die römischen Bäder und die Juliansäule .
+Bei der Teilung des Römischen Reiches nach dem Tode des Kaisers Theodosius I. im Jahr 395 fiel die Stadt an das Oströmische Reich , das später Byzantinisches Reich genannt wurde , und gehörte bis 1073 zu diesem .
+620 eroberten vorrückende Sassaniden die Stadt und hielten sie sieben Jahre .
+Die Byzantiner machten die Stadt von 717–775 zum militärischen Hauptquartier ihrer Verwaltungseinheit Bukellarion .
+Ankara wurde mehrmals von arabischen Truppen unter den abbasidischen Kalifen Hārūn ar-Raschīd ( 797 ) und al-Mu ' tasim bi- ' llāh ( 838 ) erobert und von den Byzantinern nach einigen Jahren wieder eingenommen .
+Die von den Byzantinern als häretische Gruppe bezeichneten Paulikianer konnten die Stadt kurz einnehmen ( 871 ) , sie wurden wie die Truppen der Abbasiden ( 931 ) ebenfalls wieder zurückgeworfen . Aus der byzantinischen Zeit stammen die eindrucksvollen Befestigungsmauern der Zitadelle sowie die in den Augustustempel eingebaute Kirche , von der noch die Apsis und die kleine Krypta erhalten sind .
+Seldschuken und Osmanen Nach dem Sieg Alp Arslans in der Schlacht bei Manzikert 1071 löste sich die byzantinische Reichsverwaltung in Anatolien vorübergehend vollständig auf .
+In den so entstandenen anarchischen Verhältnissen ließen sich türkische Stammesgruppen in Anatolien nieder , denen oftmals rivalisierende Adelsfraktionen in den byzantinischen Städten Kleinasiens die Tore öffneten , um die militärischen Fähigkeiten dieser Gruppen für eigene Zwecke zu nutzen .
+Im Zuge der Konsolidierung und Zentralisierung der Herrschaft dieser türkischen Gruppen unter einer seldschukischen Nebenlinie geriet Ankara unter die Herrschaft des Sultanats der Rum-Seldschuken .
+Nach dem Mongoleneinfall 1243 und dem Zusammenbrechen des seldschukischen Staates übernahmen kleine unabhängige Fürstentümer , die Beyliks , die Kontrolle über die westanatolischen Grenzgebiete ( Uc ) , während Ostanatolien und das östliche Mittelanatolien unter die direkte Herrschaft der mongolischen Ilchane und später auch unter die Herrschaft türkischer Fürsten fielen .
+Hierbei lag Ankara im Grenzgebiet zwischen den Grenzfürstentümern der Uc , namentlich der Osmanen und der Karamanen und dem Herrschaftsbereich der Ilchane .
+In diesem Herrschaftsvakuum geriet Ankara wie vergleichbare Städte unter die Leitung der Ahi .
+Datei : Ankara rijkmuseum.jpeg Datei : I. -Türkiye-Büyük-Millet-Meclisi-Ankara-1920.jpg Die Ahi waren als Ausläufer der Futuwwa-Bewegung gildenartige Bruderschaften der städtischen Bevölkerung , etwa der Handwerker , deren Führer in Abwesenheit anderer Herrschaftsinstanzen staatliche Aufgaben in Anspruch nahmen .
+1356 eroberte Orhan I. Ankara und gliederte es ins Osmanische Reich ein , welches dessen Entwicklung fortan – mit der Ausnahme der Besatzung 1401–1402 durch Timur nach der Schlacht bei Ankara – bis zum Ersten Weltkrieg bestimmen werden sollte .
+Ankara war Hauptstadt eines Sandschak im Ey.let Anadolu und wurde 1841 Verwaltungssitz des neu gebildeten gleichnamigen Eyalets ( ab 1867 Vil.yet Ankara ) .
+Seit 1892 ist Ankara durch die Anatolische Eisenbahn mit Istanbul verbunden .
+Nach der Niederlage der Osmanen im Ersten Weltkrieg besetzten alliierte Streitkräfte die damalige Hauptstadt Istanbul .
+Auch Ankara wurde 1919 für eine kurze Zeit nach der osmanischen Kapitulationserklärung von alliierten Truppen unter der Führung Withalls besetzt und wieder geräumt .
+Im anatolischen Kernland formierte sich gegen die Besatzungsmächte Widerstand , und nach der Ankunft Mustafa Kemals in Ankara Ende 1919 wurde 1920 die Große Nationalversammlung der Türkei ausgerufen , da das osmanische Parlament in Istanbul unter dem Druck der britischen Besatzung stand und viele seiner Abgeordneten nach seiner Auflösung durch die Briten inhaftiert und nach Malta deportiert wurden .
+Als die griechischen Besatzungstruppen 1921 bis nach Polatlı ( etwa 60 km vor Ankara vordrangen ) und der Artilleriebeschuss schon in Ankara zu hören war , gab es im Parlament Überlegungen nach Kayseri umzuziehen , wovon nach der erfolgreichen Schlacht am Sakarya abgesehen wurde .
+Datei : Turkey .
+Ankara .
+Street with castle in distance 1935 ( cropped ) . jpg
+Republik Mit dem endgültigen Sieg der von Kemal Atatürk geführten Truppen im Türkischen Befreiungskrieg wurde Ankara wegen seiner Lage in Zentralanatolien und in bewusster Abgrenzung zur osmanischen Hauptstadt Istanbul im Vorfeld der Ausrufung der Republik am 13. Oktober 1923 zur Hauptstadt erklärt .
+Als repräsentative Hauptstadt der jungen Republik musste zunächst die Infrastruktur bereitgestellt werden .
+Die Stadt war durch einen Brand 1917 größtenteils zerstört worden , die Umgebung war versumpft ( Malaria war ein großes Problem ) und hinzu kam ein stetiger Zustrom von Menschen .
+In acht Jahren ( 1920–1928 ) vervierfachte sich die Bevölkerungszahl von ca. 25.000 auf 100.000 Zur Neukonzeption wurde größtenteils auf deutsche Architekten zurückgegriffen , so basierte die grundlegende Stadtplanung auf einem von Carl Christoph Lörcher für 1924–1925 entwickelten Plan , der aber im weiteren Verlauf aufgrund stärkeren Zuzugs neu bewertet und von dem ab 1929 im türkischen Dienst stehenden Hermann Jansen im sogenannten „ Jansen-Plan “ neu konzipiert wurde . Clemens Holzmeister errichtete das Parlamentsgebäude , mehrere Ministerien und Gerichtsgebäude sowie eine Villa für Atatürk .
+Datei : Ak Saray - Presidential Palace Ankara 2014 002.jpg In den folgenden Jahrzehnten musste die Stadtverwaltung sich mit der Landflucht auseinandersetzen , die in Gecekondu-Vierteln sichtbar wurde .
+Spätestens seit den 1950ern wurde immer stärker auf repräsentative Bauten verzichtet , das Stadtbild im Zentrum dominieren große funktionale Quaderbauten und Verkehrsstraßen .
+Die als „ grüne Stadt inmitten der anatolischen Steppe “ geplante Hauptstadt verlor stark an städtischer Grünfläche .
+Mitte der 1980er Jahre versuchte die sogenannte TOKI türkeiweit das Wohn- und Platzproblem mit billigen Hochhaussiedlungen zu lösen , welche seitdem das Stadtbild Ankaras dominieren .
+Von 1994 bis 2017 war der islamisch-konservative Melih Gökçek der Oberbürgermeister .
+Im Jahre 2009 wurde die Stadt für ihre herausragenden Bemühungen um die europäische Integration mit dem Europapreis ausgezeichnet .
+2014 wurde der neue Amtssitz des Präsidenten eingeweiht , der trotz gerichtlichem Baustopp auf der Grünfläche der Waldfarm Atatürks errichtet wurde und knapp eine halbe Milliarde Euro kostete .
+Am 10. Oktober 2015 kam es während einer Demonstration am Bahnhof der Stadt zu einem terroristischen Sprengstoffanschlag mit über 100 Toten .
+2017 wurde Gökçek als Bürgermeister durch den ebenfalls der AKP angehörenden Mustafa Tuna abgelöst , der bei der Kommunalwahl 2019 jedoch knapp seinem Herausforderer Mansur Yavaş von der CHP unterlag .
+Wappen Datei : Emblem von Ankara ( hethitische Sonne ) . jpg Das Wappen der Stadt ist ein langjähriges Streitthema .
+Das jahrzehntelang akzeptierte Wappen oder Emblem war die als „ hethitische Sonne “ bezeichnete scheibenförmige Standarte ( Bronzestandarten von Alaca Höyük ) .
+Sie wurde 1995 von dem damaligen Bürgermeister Melih Gökçek der islamisch-konservativen AKP durch eine Abbildung der Kocatepe-Moschee , die mit ihrer klassischen Architektur anderen Moscheen der Türkei sehr ähnelt und 1987 fertiggestellt wurde , ersetzt .
+Verschiedene Gerichtsbeschlüsse bemängelten die fehlende repräsentative Symbolik und kritisierten Befugnisübertritte des Bürgermeisters .
+Dieser integrierte als Reaktion daraufhin den Atakule-Fernsehturm in das Wappen .
+Später schlug Gökcek zwei Katzenaugen der Katzenrasse Türkisch Angora als Wappen vor ; der Vorschlag wurde aber aufgrund von Protesten zurückgezogen .
+Die Wappenfrage bleibt ein Streitthema .
+Wirtschaft und Infrastruktur Wirtschaft und Tourismus Datei : Ziraat Bankası 5.JPG Datei : Angora 001.jpg Ankara ist nicht nur das Verwaltungszentrum der Türkei , sondern gilt neben Istanbul und Izmir auch als eines der größten Wirtschaftszentren des Landes .
+Von Bedeutung ist die Rüstungsindustrie , wie die TUSAS Turkish Aerospace Industries , die ASELSAN ( Militärtechnik ) oder die MKE Munitions- und Waffenindustrie , die Roketsan oder Havelsan .
+Des Weiteren existieren eine große MAN Autobusfabrik in der Nähe des Flughafens , ein Traktorenwerk , ein Baumaschinenhersteller ( Hidromek ) , sowie Betriebe der Nahrungs- und Genussmittelindustrie , während die ehemals bedeutende Ziegen- und Wollhaarverarbeitung bedeutungslos geworden ist .
+Die Industriebetriebe konzentrieren sich größtenteils im Westen der Stadt .
+Das Einkaufs- und Handelszentrum der Stadt liegt größtenteils in Kızılay um den Kızılay-Platz .
+Ankara ist im Vergleich zu den anderen türkischen Städten wenig touristisch erschlossen .
+Dies wird zumeist mit dem vorherrschenden Image einer unbegrünten Beamtenstadt erklärt .
+Zu den meistbesuchten Orten zählt das Mausoleum des Staatsgründers Atatürk und das Museum für anatolischen Zivilisationen .
+Zumeist wird der Besuch im Rahmen einer größeren Tour , wie z. B.
+bei einer Reise nach Kappadokien organisiert .
+Für die religiösen inländischen Touristen ist die Hacı-Bayram-Moschee eine Pilgerstätte .
+Laut einer Studie aus dem Jahr 2014 erwirtschafte Ankara ein Bruttoinlandsprodukt von 104,86 Milliarden US-Dollar in Kaufkraftparität .
+In der Rangliste der wirtschaftsstärksten Metropolregionen weltweit belegte die Stadt damit den 129.
+Platz .
+Das BIP pro Kopf liegt bei 21.076 US-Dollar ( KKP ) .
+Bildung Ankara ist Sitz mehrerer Universitäten , u. a. der Universität Ankara , der Bilkent-Universität , der Gazi-Universität , der Technischen Universität des Nahen Ostens ( ODTÜ ) , der Hacettepe-Universität , der Tobb-Universität für Wirtschaft und Hochtechnologie , der Ufuk-Universität , der Atılım-Universität , Çankaya-Universität und der Başkent-Universität .
+Verkehr Straßen und ÖPNV Datei : Ankara metro.png Die Qualität der Straßen ist unterschiedlich .
+Während sie im alten Stadtkern Ulus schlecht ist , werden die Straßen um Kızılay , den neuen Stadtkern , erneuert .
+Die achtspurige Ringautobahn O-20 trägt zur Entlastung des städtischen Verkehrs bei .
+Wie in anderen Großstädten gibt es zahlreiche Taxis .
+Wie in den meisten türkischen Städten wird ein beträchtlicher Teil des öffentlichen Nahverkehrs von Dolmuş übernommen .
+Der öffentliche Nahverkehr wird weitgehend mit Bussen abgewickelt .
+Es gibt mehrere Busbahnhöfe , u. a. das Ankara Şehirlerarası Otobüs Terminali .
+Die U-Bahn besteht 2014 aus vier Linien M1 , M2 , M3 und Ankaray . Eine weitere Linie ( M4 ) ist im Bau , eine Linie ist in langfristiger Planung .
+Daneben gibt es einen S-Bahn-Verkehr ( Banliyö Trenleri ) .
+Eine 3,2 Kilometer lange kuppelbare Umlaufseilbahn mit vier Stationen verbindet seit 2014 den Stadtteil Şentepe mit der Metrostation Yenimahalle . Die Stadtverwaltung hat sich entschieden , das System allen Nutzern kostenlos zur Verfügung zu stellen , somit sind auch keine Fahrscheine notwendig .
+Gebaut wurde die Seilbahn vom Südtiroler Unternehmen Leitner ropeways .
+Flughäfen Ankara besitzt mehrere militärische ( u. a.
+Güvercinlik Havalimanı , Etimesgut Havalimanı ) und einen internationalen zivilen Flughafen , den Esenboğa Airport .
+Er liegt 28 km nordöstlich der Stadt und wurde zwischen 2004 und Ende 2006 grundlegend erneuert .
+Gleichzeitig wurde der Flughafen über eine Schnellstraße an die Ringautobahn angeschlossen .
+Eisenbahn Datei : Ankara Train Station.JPG Ankara wurde durch die Anatolische Eisenbahn Ende des 19. Jahrhunderts mit Istanbul und über einen Abzweig mit Izmir verbunden .
+Später wurden Strecken über Kayseri in den Osten des Landes , zur Bagdadbahn Richtung Adana und über Karabük an die Schwarzmeerküste gebaut .
+Die Hochgeschwindigkeitsstrecke Ankara–İstanbul wurde Januar 2009 in Betrieb genommen .
+Die Hochgeschwindigkeitsstrecke Ankara–Konya ist seit dem 30. August 2011 in Betrieb .
+Hochgeschwindigkeitsstrecken nach Sivas , Kars und Izmir sind geplant und sollen bis 2015 fertiggestellt werden . Das TCDD Açık Hava Buharlı Lokomotif Müzesi ( Dampflok-Museum ) beinhaltet verschiedene historische Zugmaschinen .
+Bevölkerung Datei :D ikmen neighbourhood.jpg Ankara hatte vor 1923 eine Bevölkerungszahl von ca. 25.000 .
+Nachdem es den Status als Hauptstadt erhalten hatte , entwickelte es sich zu der Stadt mit der drittgrößten Bevölkerung nach Istanbul und Izmir und steht 2014 landesweit an zweiter Stelle .
+Es gehört zu den Städten mit dem stärksten Zuzug von Binnenmigranten .
+Die ganze Provinz zählt 5.045.085 Bewohner , Seit der letzten Verwaltungsreform 2014 umfasst die Großstadtgemeinde Ankara ( Ankara Büyükşehir Belediyesi ) das gesamte Gebiet der Provinz .
+Vor dieser Reform entfielen von den Einwohnern der Provinz 4.630.735 Bewohner auf die Großstadt Ankara . Auf Makroebene betrachtet sind in Ankara fast ein Drittel der Bewohner Zentralanatoliens ( 11.608.868 ) beheimatet . Die Stadtbevölkerung Ankaras lebt zu 97 % in städtischer , zu 3 % in dörflicher Umgebung .
+Im Zeitraum 1990–2000 wuchs die Stadtbevölkerung ausgehend von 2.583.963 um 21,48 % . Im Vergleich dazu betrugen die Wachstumsraten in Zentralanatolien in diesem Zeitraum 15,78 % und für die gesamte Türkei 18,28 % .
+Während in Ankara 1.585.970 Bewohner beim Heimateinwohnermeldeamt Ankara gemeldet sind , gibt es eine größere Gruppe , die noch in den ursprünglichen Heimatprovinzen gemeldet ist .
+Die größte Einwanderung kommt aus den Provinzen Çorum mit 378.451 , gefolgt von Yozgat 332.198 , Çankırı 236.406 , 196.296 Kırşehir , 180.595 Kırıkkale und 151.386 Sivas , dementsprechend größtenteils aus Zentralanatolien .
+Von außerhalb Zentralanatoliens kommen 103.319 Zuzüglern aus Erzurum , gefolgt von 81.830 aus Kars und 82.305 aus Bolu .
+Die geringsten Zuzüge verzeichnet Ankara aus Kırklareli , Hakkari und Yalova .
+Religion und Weltanschauungen Die Bewohner sind größtenteils muslimischen Glaubens .
+Die Stadt kam früh mit dem Christentum in Kontakt .
+Nach der nordgalatischen Hypothese hat der Apostel Paulus von Tarsus die Bewohner Ankaras im ersten Jahrhundert zum Übertritt zum Christentum aufgerufen ( Brief des Paulus an die Galater ) . Mit den Byzantinern wandelte sich der römische Augustustempel zu einer bedeutenden Kirche der Stadt .
+1520 betrug der Anteil der Nichtmuslime in der Stadt 10 % und erhöhte sich durch den Zuzug meist katholischer Armenier im Jahre 1830 auf 45 % . Im Zuge der ethnischen Spannungen im Vorfeld des Ersten Weltkrieges und der Deportation der Armenier während des Völkermords ist die christliche Gemeinde stark geschrumpft .
+Die Stadt besitzt einige modernere Kirchen ( protestantisch , katholisch , orthodox ) .
+Auch eine 100 Mitglieder umfassende jüdische Gemeinde mit einer Synagoge , der Havra , existiert .
+Persönlichkeiten Ankara ist Geburtsort zahlreicher prominenter Persönlichkeiten .
+Siehe Liste von Söhnen und Töchtern der Stadt Ankara
+Stadtbild Die verwinkelten , engen Gassen der Altstadt winden sich um einen steilen , von der Zitadelle gekrönten Felskegel .
+Südlich der Altstadt und des alten Stadtzentrums Ulus erstreckt sich die moderne Neustadt mit den neuen Zentren Kızılay und Kavaklıdere , deren Kennzeichen breite Boulevards , zahlreiche Regierungsgebäude und Botschaften sowie moderne Wohnviertel sind .
+Insbesondere im westlichen Teil der Stadt entstehen Neubausiedlungen , um dem wachsenden Bedarf an Wohnfläche zu entsprechen .
+Trotz dieser Anstrengungen gab es bis in die erste Dekade des 21. Jahrhunderts noch sehr viele Marginalsiedlungen ( Gecekondu ) .
+Ein großer Teil dieser Gecekondus wurde seit der Jahrtausendwende flächendeckend abgerissen , neu beplant und durch weitläufige , moderne Hochhaussiedlungen ersetzt .
+Die heutigen Strukturen erhielt Ankara im Wesentlichen durch den deutschen Städtebauer Hermann Jansen , dessen Planungen Ende der 1920er Jahre umgesetzt wurden .
+Im Stadtteil Hamamönü in der Stadtgemeinde Altındağ wurden ab 2009 historische Häuser im Stil des 19. Jahrhunderts restauriert und beherbergen nun Cafés , Galerien und Souvenirläden .
+In den letzten 15 Jahren wurde die Braunkohle als Heizmittel weitgehend vom umweltfreundlicheren Erdgas ersetzt .
+Dennoch nimmt aufgrund des stetigen Bevölkerungswachstums die Luftverschmutzung in Ankara stark zu , die alten Busse , Autos und das Fehlen einer umweltfreundlicheren Alternative tragen wesentlich dazu bei .
+Grünflächen Datei : Genclik Park 2012 03.JPG
+In den ersten städtebaulichen Plänen der jungen Republik war Ankara als grüne Stadt inmitten der kargen anatolischen Steppe geplant .
+Der zweite Stadtplaner Jansen plante sie in groben Zügen als anatolische Gartenstadt , so wurden große Grüngürtel angelegt , welche die Stadt in funktionelle Einheiten teilten .
+Eine größere Grünfläche im Westen der Stadt bildet die Waldfarm Atatürks , ein landwirtschaftlicher und forstwirtschaftlicher Demonstrationsbetrieb des Gazi , der die Bevölkerung bis in die 80er mit Rohmilch , Milchprodukten und lokalem Bier versorgte .
+Für die Bewohner der Stadt wurden damals dreistöckige Häuser mit Hintergärten angelegt , die heute noch in der Siedlung Bahçelievler in einer kleinen Zahl übriggeblieben sind .
+Mit der einsetzenden Landflucht ab den 1950ern wurden die Grünflächen Baugrund für Plattenbauten .
+Ein bekannter zentraler Park ist der Gençlik Parkı , der in der Bauzeit 1938–1943 im Stadtteil Ulus fertiggestellt wurde .
+Er wurde als Erholungspark eröffnet und änderte seinen Charakter ab den 1950er Jahren stärker in Richtung Unterhaltungspark .
+Nach einer Grundsanierung 2006 ist er mit abendlichen Lichteffekten und Musikshows ein Ort für flanierende Familien .
+Zu den größten Parks der Stadt gehört der Altınpark ( mit 50,8 ha ) im Stadtteil Altındağ .
+Er wurde auf einem ehemaligen Golfplatz errichtet und 1991 fertiggestellt und bietet neben Erholung auch Möglichkeiten zur sportlichen Betätigung ( wie Kartsport , Eisbahn ) .
+Hinzu kommen mehrere kleinere Parks , darunter der Kurtuluş Parkı , der Kuğulu Parkı , der Gökçek Parkı und der 50. Yıl Parkı .
+Der Wald der Technischen Universität im Süden der Stadt war eine größere halbwegs bewaldete Grünfläche , die jedoch zunehmend bebaut wird , was zu anhaltenden Protesten der Studierenden führt .
+Friedhöfe Zu den landesweit bedeutendsten Friedhöfen gehört der Türkische Staatsfriedhof im Stadtteil Yenimahalle .
+Dieser beherbergt in seiner 536.000 m - großen Fläche 61 Gräber ranghoher Offiziere und Generäle des türkischen Befreiungskriegs , Gräber von drei Staatspräsidenten und einem Ministerpräsidenten .
+Für das relativ moderne Projekt ( Bauzeit war 1981–1988 ) wurden die meisten Bestatteten dorthin umgebettet .
+Der ganze Friedhof ist mit Skulpturen durchzogen und beinhaltet ein Museum mit Habseligkeiten der Verstorbenen .
+Ein anderer Friedhof mit namhaften Bestatten ist der Städtische Friedhof Cebeci im Stadtteil Cebeci .
+Er wurde in der Republikzeit als moderner Friedhof durch den Architekten Martin Elsaesser geplant und ist im Sinne des Laizismus konfessionell gemischt .
+Durch Erweiterungen in der jüngeren Zeit hat er seine alte Struktur verloren .
+Er gilt mittlerweile als zweitgrößter Friedhof der Stadt .
+Der größte zivile Friedhof ist der Karşıyaka-Friedhof mit einer Fläche von 2,89 km - .
+Kultur und Sehenswürdigkeiten Römische Hinterlassenschaften Im Stadtteil Ulus , dem historischen Kern der Stadt , liegen die Caracalla-Thermen , eine römische Badeanlage aus dem 3. / 4.
+Jahrhundert .
+Von den Badegebäuden sind Grundmauern und die Ziegel der Hypokaust-Heizungsanlage erhalten .
+Auf dem Platz für sportliche Übungen , der Palästra , sind zahlreiche Stelen , Kapitelle und Inschriften aufgestellt , die auf dem Stadtgebiet gefunden wurden .
+Etwa 400 Meter östlich davon befindet sich die Ruine des Tempels der Roma und des Augustus , an dessen Wänden der zweisprachige griechisch / lateinische Rechenschaftsbericht des Kaisers Augustus angebracht ist .
+Nahe dabei steht die ebenfalls römische Juliansäule , deren genaue Herstellungszeit nicht bekannt ist .
+Anıtkabir Datei : Ankara Anitkabir1.JPG Auf dem zentralen Hügel Anıttepe befindet sich die Ruhestätte des Staatsgründers Mustafa Kemal Atatürk .
+Nach seinem Tod 1938 wurde ein internationaler Architekturwettbewerb ausgerufen mit der Aufgabe ihm ein passendes Grabmal zu setzen .
+Der Entwurf fiel auf ein geradlinig rationales , schnörkelloses und monumental gehaltenes Mausoleum mit zentraler Lage und Blick auf die Stadt .
+Die Anlage ist dreiteilig : Über einen schmalen Gang ( Löwenweg ) gelangt man auf den zeremoniellen Platz , der 15.000 Menschen aufnehmen kann .
+Das Mausoleum umfasst Habseligkeiten des Feldherren und Staatsmannes und ein Museum über den Unabhängigkeitskrieg .
+Es ist ein landesweit bekanntes Nationaldenkmal , das jedes Jahr mehrere Millionen Besucher verzeichnet ( 2015 : ca. 5 Millionen ) . Für ausländische Staatsgäste ist es ein protokollarischer Pflichtbesuch .
+Parlamente Datei : TBMM birinci 2.JPG Ankara umfasst drei Parlamentsgebäude .
+Das erste historische Parlament am Ulus-Platz war ein jungtürkisches Clubhaus , das von der neu formierten Nationalbewegung 1920 als Parlament benutzt wurde .
+Hier wurde während des Unabhängigkeitskrieges der Krieg gegen die vorrückenden Griechen und die Haltung zur besetzten Istanbuler Regierung debattiert .
+Heute ist es ein Museum ( Kurtuluş Savaşı Müzesi ) .
+Das zweite historische Parlamentsgebäude wurde aufgrund der engen Platzverhältnisse vom Architekten Vedat Tek entworfen und ist in direkter Nachbarschaft zum ersten Parlament .
+Es wurde von 1924 bis 1961 genutzt und ist heute ebenfalls ein Museum ( Cumhuriyet Müzesi ) .
+Das dritte und im Dienst stehende Parlament wurde 1938 von dem Sieger des Architekturwettbewerbs Clemens Holzmeister entworfen und 1961 fertiggestellt .
+Zitadelle Datei : Hacıbayram Ankara Castle.jpg Die Zitadelle von Ankara ist eine von den Hethitern errichtete , von den Galatern ausgebaute und schließlich bis zu den Osmanen weitergenutzte Befestigungsanlage inmitten der Altstadt Ankaras .
+Sie wird unterteilt in die äußere ( Dışkale ) , innere Burganlage ( İçkale ) und die Burg an sich ( Akkale ) .
+Moscheen Datei : KocatepeMosque.jpg Wahrzeichen und Blickfang der Stadt ist die Kocatepe-Moschee .
+Sie ist die größte der Stadt .
+Im Inneren der Moschee befinden sich Teehäuser , ein großer Supermarkt und ein Konferenzraum .
+Das Gotteshaus wurde erst 1987 fertiggestellt und ist ein Rückgriff auf die klassische osmanische Architektur Mimar Sinans .
+Die ebenfalls bekannte Maltepe-Moschee orientiert sich wie viele andere Moscheen an dem gleichen Stil .
+Eine tatsächlich von Mimar Sinan in Ankara erbaute historische Moschee aus dem 16 Jh. ist die Neue Moschee im Stadtteil Ulus .
+Als architektonische Neuheit gilt die 2008 fertiggestellte Doğramacızade-Ali-Sami-Paşa-Moschee , die der Gründervater vieler Institute İhsan Doğramacı zu Ehren seines Vaters erbauen ließ .
+Der als postmodern bezeichnete Architekturstil ist schlicht gehalten und die Moschee erlaubt konzeptionell bei speziellen Anlässen auch Nicht-Muslimen die Nutzung der Räume .
+Zu den ältesten Moscheen ( 13 Jh. ) der Stadt gehört die Aslanhane-Moschee .
+Der Name „ Aslanhane “ bedeutet „ Löwenhalle “ und ist den Löwenreliefs an der Außenfassade geschuldet .
+Der Gebetsraum wird im typischen seldschukischen Stil von hölzernen Säulen gestützt .
+Die Hacı-Bayram-Moschee wurde nach dem Dichter und Gründer des Bairami-Sufiordens , Hacı Bayram-i Veli benannt , dessen Grabmal sich direkt im Hintergarten befindet .
+Sie wurde 1428 fertiggestellt und besitzt ein Minarett .
+Unmittelbar angrenzend an die Moschee steht die Ruine des Augustustempels .
+Die Moschee steht inmitten eines Viertels mit restaurierten bzw. im osmanischen Stil neu- oder wiedererrichteten Gebäuden .
+Der Weg zur Moschee ist gesäumt von Läden für religiöse Literatur und Devotionalien .
+Museen Datei : Resim ve Heykel Müzesi Ankara.jpg Eines der international bedeutendsten archäologischen Museen der Türkei ist das Museum für anatolische Zivilisationen , das als Schwerpunkt Exponate der Epochen bis zum Beginn des ersten vorchristlichen Jahrhunderts und dabei besonders der Hethiter ausstellt .
+Mit der jüngeren Geschichte der Republik beschäftigen sich die beiden ehemaligen Parlamente , die in Museen umgewandelt wurden .
+Auch das Museum im Anıtkabir behandelt das Thema und zeigt neben Habseligkeiten des Staatsgründers auch Schlachten audiovisuell auf Panoramaleinwänden .
+Es beherbergt zudem Nationalgemälde und Porträts des Staatsgründers und der beteiligten Generalität .
+Auf dem Namazgah Hügel liegen zwei im ersten nationalen Stil erbaute Museen .
+Das Ethnografisches Museum Ankara ist ein 1930 erbautes Volkskundemuseum und stellt schwerpunktmäßig Exponate ab der seldschukischen Zeit aus : Koch- , Wohn- und Arbeitsumgebung und diverse Kunstformen der Nomaden und sesshaften Bewohner Anatoliens .
+Daneben liegt das Staatliche Kunst- und Skulpturenmuseum welches als Zentrale der Türk Ocağı und Halkevleri genutzt wurde und heute als Kunstmuseum dient .
+Das 2006 eröffnete Çengelhan Rahmi M. Koç Museum befindet sich in der ehemaligen Çengelhan-Karawanserei und ist namentlich dem Sohn des türkischen Wirtschaftspionier Vehbi Koç gewidmet .
+Das Industriemuseum beinhaltet Maschinen und Gerätschaften aus dem Zeitalter der beginnenden Industrialisierung ( Kommunikation , Navigation , Landwirtschaft ) .
+Daneben gibt es zwei Wissenschaftsmuseen in der Stadt , das Feza Gürsey Science Center in Altinpark und das Technologie- und Wissenschaftsmuseum der ODT-Universität ( ODTÜ Bilim ve Teknoloji Müzesi ) .
+Bühnen Datei : TurkishStateTheatresHeadOfficeInAnkara.JPG Die Opera Sahnesi ( Deutsch : Opernbühne ) ist das größte der insgesamt drei Opernhäuser in Ankara .
+Es gehört zu den Türkischen Staatstheatern ( Devlet Tiyatroları ) .
+Ankara Opera Sahnesi ( „ Opernbühne “ , auch bekannt als Büyük Tiyatro ) Leyla Gencer Sahnesi Operet Sahnesi Folgende Bühnen in Ankara gehören zu den Türkischen Staatstheatern : 125.
+Yıl Çayyolu Sahnesi , Büyük Tiyatro ( „ Große Bühne “ ) , Küçük Tiyatro ( „ Kleine Bühne “ ) , Şinasi Sahnesi , Akün Sahnesi , Altındağ Tiyatrosu , İrfan Şahinbaş Atölye Sahnesi , Oda Tiyatrosu ( Oda Tiyatrosu ) , Mahir Canova Sahnesi , Muhsin Ertuğrul Sahnesi .
+Des Weiteren befinden sich in Ankara fünf klassische Orchester : Präsidentielles Symphonieorchester Bilkent-Sinfonieorchester
+Hacettepe Senfoni Orkestrası Orkestra Akademik Başkent Kammerorchester der Hauptstadt ( Başkent Oda Orkestrası ) Datei : AnkaralıSeymenler.JPG
+Seymen Äquivalent zu den in Westanatolien lokalisierten Zeybeks gibt es auch in Inneranatolien und besonders in Ankara die sogenannten Seymen .
+Diese waren zu seldschukischen Zeiten bewaffnete Sicherheitskräfte .
+Heute sind sie in Vereinen organisiert und führen bei besonderen Anlässen in traditioneller Tracht , mit Turban und Krummsäbel in kleinen Gruppen ihre charakteristischen Tänze vor .
+Anlässe sind nationale Feiertage .
+Ein wichtiger lokaler Feiertag – und besonders für die Seymen – ist die Ankunft Mustafa Kemals in Ankara am 27. Dezember 1919 .
+An diesem Tag wurde Mustafa Kemal als Organisator des anatolischen Widerstands von einer großen Gruppen tanzender Seymen mit Zurna und Davul in Empfang genommen , welches bei diesem Fest folkloristisch nachgebildet wird .
+Sport Datei : Ankara Arena.JPG Zur Saison 2012/2013 spielt ein Fußballverein in der Süper Lig , der höchsten türkischen Spielklasse : Gençlerbirliği SK .
+Der Verein spielt im Leichtathletikstadion Ankara 19 Mayıs , das 21.250 Zuschauern Platz bietet .
+Hinter den İstanbuler Vereinen sind Vereine aus Ankara ( MKE Ankaragücü , Ankara Şekerspor ) , jedoch eher zweitrangig und somit international weitgehend unbekannt .
+Weitere Sportmöglichkeiten sind zum Beispiel Skifahren auf dem Elmadağ , dem Hausberg von Ankara , oder Schlittschuhlaufen im Eisstadion .
+Des Weiteren gibt es noch mit Türk Telekomspor einen Basketballerstligisten .
+Städtepartnerschaften Bildergalerie Sonstiges Ankara ist die Heimat der Türkisch Angora , einer Katzenrasse , die als älteste Langhaar-Rasse der Welt gilt .
+Literatur Andreas Birken : Die Provinzen des Osmanischen Reiches , Reichert , Wiesbaden 1976 , ISBN 3-920153-56-1 . Encyclopaedia of Islam , 2. Aufl. Leiden 1986 ff. , s. v. ANḲARA , ISBN 90-04-08114-3 Mostras , C. : Dictionaire géographique de l ’ Empire Ottoman , St. - Petersburg 1873 Clifford Edmund Bosworth : Historic Cities of the Islamic World , BRILL , 2007 Urs Peschlow : Ankara .
+Die bauarchäologischen Hinterlassenschaften aus römischer und byzantinischer Zeit .
+Mit einem Beitrag von Wolfram Brandes
+, Phoibos Verlag , Wien 2015 , ISBN 978-3-85161-132-8 Weblinks Offizielle Website der Großstadtkommune Ankara ( türkisch ) Einzelnachweise Sargon Erdem : Ankara in „ Islam Ansiklopedisi “ , Band 3 ; 1991 , S. 202 Franz Taeschner : Anḳara In : The Encyclopaedia of Islam . New Edition . Bd. 1 , Brill , Leiden , S. 509. Sargon Erdem : Ankara . In : Islam Ansiklopedisi . Bd. 3 1991 , S. 201–203 . Franz Taeschner , Akhī in : The Encyclopaedia of Islam . New Edition , Vol . 1 , Leiden / London 1960 , Seite 321/323 Oda Wischmeyer : Paulus : Leben – Umwelt – Werk , UTB , 2012 , S. 241 Ismail Hakkı Kadı : Ottoman and Dutch Merchants in the Eighteenth Century , BRILL , 2012 , S. 31 Şenda Kara : Leitbilder und Handlungsgrundlagen des modernen Städtebaus in der Türkei , LIT Verlag Münster , 2006 , Seite . 156 
+
+Datei : Ephesians 2,12 - Greek atheos.jpg Atheismus ( von ) bezeichnet die Abwesenheit oder Ablehnung des Glaubens an Gott bzw. Götter .
+Im Gegensatz dazu bezeichnet Theismus ( ) den Glauben an Götter , wobei der Monotheismus den Glauben an einen Gott und der Polytheismus den Glauben an mehrere Götter bezeichnet .
+Zum Atheismus im weiteren Sinne zählen einige auch den Agnostizismus ( agnostischer Atheismus ) , nach dem die Existenz von Gott bzw. Göttern ungeklärt oder nicht klärbar ist .
+Im engeren Sinne bezeichnet er jedoch die Überzeugung , dass es Gottheiten nicht gibt .
+Begriffsweite und - herkunft Die begriffliche Spannbreite von Atheismus umfasst einerseits die „ weiten “ Begriffsbedeutungen , die ein Dasein ohne Glauben an Gott , entsprechende Lebensweisen und diesbezügliche Begründungen einschließen ( auch als „ Nichttheismus “ begriffen ) , und andererseits „ enge “ bzw. „ starke “ Bedeutungen , die in Hinsicht auf Götterbehauptungen verneinend , gegebenenfalls kämpferisch oder mit Gegenbeweisen vertreten werden ( auch als „ Antitheismus “ bezeichnet ) .
+Im antiken Griechenland wurde der Atheismus-Begriff mit dem Alpha privativum gebildet ( A-theismus ) , er hat verschiedene altgriechische Varianten ( Substantiv : im Sinne von ‚ Gottlosigkeit ‘ , ‚ Gottesleugnung ‘ und ‚ Unglaube ‘ ) und er war in Asebie-Prozessen ein hinreichender Anklagepunkt .
+Die latinisierte Form ‚ Atheismus ‘ findet sich erstmals bei Cicero , seit Ende des 16. Jahrhunderts erscheint sie im deutschen Schrifttum ( frühneuhochdeutsch Atheisterey ) und sie gilt seit Beginn des 18. Jahrhunderts als eingedeutscht .
+In der Zeit der Aufklärung waren es zunächst Freidenker , Deisten , Pantheisten und Spinozisten , die von Philosophen und etablierten Kirchen als Atheisten bezeichnet und bezichtigt wurden . Ein Teil der Enzyklopädisten war dem Atheismus besonders verbunden .
+Als Kampfbegriff diente und dient ( Südstaaten der USA ) ‚ Atheist ‘ auch zur moralischen Diffamierung derjenigen , welche zwar den Theismus akzeptierten , aber in Einzelaspekten von der herrschenden Gotteslehre abwichen .
+Jedoch wird in der Regel als Atheist bezeichnet , wer es ausdrücklich verneint , an Gott oder Götter zu glauben .
+Agnostiker , die an keinen Gott glauben , werden vielfach zu den Atheisten im weiteren Sinne gezählt , obgleich nicht alle damit einverstanden sind .
+Agnostische Ansichten , nach welchen auch die Nichtexistenz Gottes nicht erkannt werden kann , sind hierbei nicht benannt . Der Agnostizismus vereint unterschiedliche Ansichten ; daher ist die Zuordnung des Agnostizismus zum Atheismus umstritten ( und umgekehrt ) .
+Umstritten ist auch die Zuordnung des Positivismus zum Atheismus .
+Der Philosoph Alfred Jules Ayer , Vertreter des logical positivism ( Logischer Empirismus ) , betont , dass seine Position zu Sätzen wie „ Gott existiert “ weder mit Atheismus noch mit Agnostizismus verwechselt werden sollte .
+Er halte solche Sätze für metaphysische Äußerungen , die weder wahr noch falsch seien .
+Charakteristisch für einen Atheisten sei hingegen die Ansicht , „ dass es zumindest wahrscheinlich ist , dass es keinen Gott gibt “ .
+Ob auch Positionen als „ Atheismus “ bezeichnet werden sollen , die keine Gottheit annehmen , jedoch nicht auf Religionslosigkeit reduzierbar sind , wie etwa im Jainismus oder Konfuzianismus , ist in der Literatur umstritten . Teils wird vorgeschlagen , die explizite Ablehnung theistischer Positionen als „ theoretischen “ , und die Lebenspraxis ( die sich vollzieht , „ als ob “ ein Numinoses nicht existierte ) als „ praktischen Atheismus “ zu bezeichnen .
+Seit dem 19. Jahrhundert wird der Begriff „ Atheismus “ in einem naturalistischen Sinne teilweise so eng geführt , dass er gegen alle supernaturalistischen Auffassungen gerichtet wird , die mit einem Glauben an übernatürliche Wesen , Kräfte oder Mächte göttlicher wie nichtgöttlicher Art verbunden sind ( Animismus , Spiritismus , mono- und polytheistische Religionen ) .
+Dies wird zu Beginn des 21. Jahrhunderts oft als „ Neuer Atheismus “ bezeichnet , wenn die Argumentation als naturwissenschaftlich ausgewiesen ist .
+Gesellschaftliche Aspekte Demographische Merkmale Umfragen zum Thema Atheismus werfen methodische Probleme auf , da es schwierig ist , eine einheitliche Abgrenzung zwischen Säkularisten , Humanisten , Nichttheisten , Agnostikern und spirituellen Personen vorzunehmen . Immer mehr verschwimmt die Grenze zwischen Gläubigen und Nichtgläubigen .
+Datei : Atheists Agnostics Zuckerman de . svg
+Datei : Europe No Belief enhanced.svg
+Das The World Factbook der CIA schätzte im Jahre 2010 : Atheisten 2,32 % , Nichtreligiöse 11,77 % , Christen 33,32 % ( darunter 16,99 % römisch-katholisch ) , Muslime 21,01 % .
+In seiner „ Bilanz des Unglaubens “ meint Georges Minois , es kursierten Unmengen an Zahlen , „ die allesamt falsch sind “ . Allenfalls könne man aus ihnen ersehen , dass mehr als ein Fünftel der Menschheit nicht mehr an einen Gott glaube . Minois präsentiert selbst Schätzungen für das Jahr 1993 – weltweit 1,2 Milliarden Agnostiker und Atheisten – sowie für das Jahr 2000 – etwa 1,1 Milliarden Agnostiker und 262 Millionen Atheisten , und zum Vergleich etwa 1,2 Milliarden Gläubige für den Islam und 1,1 Milliarden für die katholische Kirche .
+Laut dem Eurobarometer 2010 glaubten 20 % der Bürger der damals 27 EU-Staaten weder an Gott noch an eine spirituelle Kraft .
+Eine Mehrheit von 51 % glaubte an Gott und 26 % an „ eine Art von spiritueller Kraft “ ; 3 % äußerten sich nicht .
+Zwischen den einzelnen Ländern gab es große Unterschiede ; so war der Anteil der Gottesgläubigen in Malta mit 94 % und Rumänien mit 92 % am höchsten und mit 16 % in Tschechien und 18 % in Estland am geringsten .
+In Deutschland , Österreich und der Schweiz wurden je 44 % ermittelt .
+Die Anzahl der Einwohner , die angaben , weder an Gott , noch an eine spirituelle Kraft zu glauben , war im Jahr 2010 mit 40 % in Frankreich und 37 % in Tschechien am höchsten und betrug in Deutschland 27 % , in Österreich 12 % sowie 11 % in der Schweiz .
+Laut dem Eurobarometer 2005 glaubten mehr Frauen ( 58 % ) an Gott als Männer ( 45 % ) ; der Glaube an Gott korrelierte positiv mit dem Alter , politisch konservativer Einstellung und mangelnder Schulbildung .
+In den USA liegt die Zahl der Personen , die an Gott oder eine höhere Macht glauben , bei 91 % .
+Das Worldwide Independent Network und die Gallup International Association befragten im Zeitraum zwischen 2011 und 2012 fast 52.000 Personen aus 57 Ländern zu ihren religiösen Einstellungen .
+13 % der befragten Personen bezeichneten sich als „ überzeugte Atheisten “ , 23 % nannten sich „ nicht-religiös “ und 57 % gaben an , eine religiöse Person zu sein .
+Laut der Studie sind 15 % der Bevölkerung in Deutschland überzeugte Atheisten .
+China ( 47 % ) und Japan ( 31 % ) sind die Länder mit dem höchsten Anteil an überzeugten Atheisten .
+Zwischen 2005 und 2012 hat sich der Anteil religiöser Personen weltweit um 9 % verringert , während der Anteil von Atheisten um 3 % gestiegen ist .
+In manchen Ländern ist dieser Trend besonders ausgeprägt : In Vietnam , Irland und der Schweiz ging der Anteil der Personen , die sich selbst als religiös bezeichnen , zwischen 2005 und 2012 um 23 , 22 bzw. 21 % zurück .
+Der Anteil an Atheisten ist nach Erhebungen in den USA bei Wissenschaftlern besonders hoch : Nur sieben Prozent der Mitglieder der amerikanischen Akademie der Wissenschaften glauben an die Existenz eines personalen Gottes . Eine Umfrage unter Mitgliedern der American Association for the Advancement of Science von 2009 ergab , dass 51 % der amerikanischen Wissenschaftler an Gott oder eine höhere Macht glauben , wesentlich weniger als im allgemeinen Publikum .
+Der Anteil der atheistischen Wissenschaftler hat sich im Laufe des 20. Jahrhunderts nicht wesentlich verändert .
+So ergab eine Umfrage des Psychologen James H. Leuba im Jahr 1914 , dass 42 % der amerikanischen Wissenschaftler an einen persönlichen Gott glaubten und ebenso viele nicht .
+Im Jahre 1996 wiederholte der Geschichtswissenschaftler Edward J. Larson die Umfrage von Leuba mit den gleichen Fragen und der gleichen Anzahl Personen und kam auf 40 % gläubige und 45 % atheistische Wissenschaftler . Eine im November 2013 veröffentlichte Metaanalyse von 63 Einzelstudien kam zu dem Ergebnis , dass Atheismus bzw. ein Nicht-Glauben an Gott signifikant mit Intelligenz zusammenhängt ( Intelligenz wurde in den meisten Studien erfasst durch den g-Faktor ) .
+Mehrere Forschungen ergaben einen positiven Zusammenhang zwischen Religiosität und Geburtenziffer .
+So hatten im Jahr 2002 in Deutschland Menschen , die sich selbst als nicht religiös bezeichneten , mit durchschnittlich 1,4 Kindern deutlich weniger Kinder als Menschen , die sich als religiös bezeichneten ( durchschnittlich 1,9 Kinder ) . Das Institut der deutschen Wirtschaft kam bei einer Auswertung der weltweit erhobenen Daten des World Values Survey zu ähnlichen Ergebnissen .
+Politische Wechselwirkungen Im Lauf der Geschichte kamen Atheisten vielfach mit politischen Autoritäten in Konflikt .
+Die Äußerung atheistischer Ansichten wurde noch im Jahre 2013 in zahlreichen Ländern mit Freiheitsentzug bestraft , in 13 Ländern sogar mit dem Tod .
+In der Neuzeit wurden gesellschaftliche Bereiche einschließlich der Politik , des Rechts und der Religionsausübung zunehmend autonom .
+Die Trennung von Kirche und Staat wurde mit Hilfe aufklärender Bewegungen verfassungsrechtlich verankert und dann durch staatskirchenrechtliche Bestimmungen ausgeformt .
+Diese Trennung wird als atheistisch bezeichnet ( insbesondere im Laizismus ) .
+In Abgrenzung zu religiös-politischen oder auch staatsatheistischen Machthabern garantiert das rechtsstaatliche Prinzip eine weltanschauliche Neutralität in einer prozessual grundlegenden Weise .
+Rechtsstaatliche Verfassungsorgane sind in ihren Entscheidungen nicht nur von religiösen , sondern auch von sonstigen externen Einflüssen entsprechend entbunden und stattdessen vorrangig einer Verfassung verpflichtet , die in modernen Staaten auf Freiheitsklauseln basiert .
+Die entsprechend neutrale Rechtsbildung führte auch gegen politische Widerstände zu einer zunehmend rechtswirksamen Tolerierung atheistischer Positionen und Lebensgestaltungen in der modernen Welt .
+Heute enthalten die Verfassungen vieler demokratischer Staaten das Menschenrecht auf Religionsfreiheit und darin eingeschlossen das Recht , Atheist zu sein oder zu werden .
+Nicht in allen diesen Staaten gibt es eine strenge Trennung von Staat und Religion , zumal Religionen aus Kultur- und Selbstbestimmungsgründen unterschiedlich stark geschützt werden ( beispielsweise durch ein Recht auf Religionsunterricht ) .
+Hinzu kommt der Gottesbezug in Verfassungen .
+So beginnt die Präambel des Grundgesetzes für die Bundesrepublik Deutschland mit den Worten : „ Im Bewusstsein seiner Verantwortung vor Gott und den Menschen … “ . Die Präambel der Bundesverfassung der Schweizerischen Eidgenossenschaft beginnt mit den Worten : „ Im Namen Gottes des Allmächtigen ! “ Im Jahre 1998 scheiterte bei einer Totalrevision der Verfassung ein Vorstoß , diese Präambel zu streichen .
+Einige heutige Strafgesetzbücher enthalten Regelungen , die die Beschimpfung von Bekenntnissen , Religionsgesellschaften und Weltanschauungsvereinigungen als einen Straftatbestand ansehen .
+Atheistische Religions- , bzw. Kirchenkritiker wurden infolgedessen in der Vergangenheit nach öffentlichen Äußerungen wiederholt strafrechtlich verfolgt .
+Auf der anderen Seite war Atheismus Bestandteil der marxistisch-leninistischen Staatsdoktrin , zum Beispiel in der Sowjetunion und in der Deutschen Demokratischen Republik , so dass Formen der Religionsausübung in den staatlich gelenkten Erziehungseinrichtungen keinen Ort hatten und politisch bekämpft wurden .
+Die Entkirchlichung Ostdeutschlands wird von Richard Schröder als die wohl wirksamste Hinterlassenschaft des SED-Regimes angesehen .
+Seinen Angaben zufolge waren im Jahre 1950 noch 91,5 Prozent der DDR-Bürger Kirchenmitglieder , 1964 noch 67,4 Prozent und am Ende der DDR etwa 25 Prozent . Diese Entwicklung setzt sich auch nach der Wiedervereinigung fort , so ging der kirchlich gebundene Bevölkerungsanteil weiter zurück und liegt in Großstädten wie Magdeburg oder Halle mittlerweile nur noch bei rund 15 % .
+Die Mitgliederschaft der beiden größeren Kirchen in Ostdeutschland ist darüber hinaus in hohem Maße überaltert und wird daher weiterhin abnehmen .
+Die von staatlicher Seite als Fortschrittsdoktrin gelehrte , marxistisch grundierte atheistische Weltanschauung wird von Kritikern wie Herbert Schnädelbach als „ konfessioneller Atheismus “ und „ Staatsreligion “ bzw. „ Staatsatheismus “ bezeichnet . In Albanien wurde 1967 ( bis 1990 ) ein totales Religionsverbot ausgerufen , und das Land bezeichnete sich als „ erster atheistischer Staat der Welt “ . Im gesamten so genannten Ostblock wurde der Atheismus gefördert , während gelebte Religiosität zumindest argwöhnisch betrachtet wurde , oft auch mit Nachteilen verbunden war oder gar gezielt verfolgt wurde , wie etwa bei den Christenverfolgungen unter Stalin .
+NGOs zufolge werden auch heute noch religiöse Gruppen und Einzelpersonen in manchen sich selbst als „ atheistisch “ verstehenden Staaten wie Nordkorea verfolgt und oftmals inhaftiert , gefoltert und getötet .
+Der Atheismus wird aktiv gefördert , beispielsweise im Humanismus , im Existenzialismus und durch die Freidenkerbewegung .
+Zu großen Anteilen sind der Sozialismus , Kommunismus und Anarchismus atheistisch geprägte Weltanschauungen .
+In den beiden letzten Jahrzehnten des 20. Jahrhunderts , so Georges Minois in seiner Geschichte des Atheismus , habe der Eifer des antireligiösen Kampfes nachgelassen : Bedeutung im Wissenschaftskontext Eine Orientierung an naturwissenschaftlichen Erklärungsmodellen lässt für einige Wissenschaftler früh die „ Gotteshypothese “ als methodisch unzulässig erscheinen , da sie keine wissenschaftlich beobachtbaren Konsequenzen habe , mithin auch keine wissenschaftlich beschreibbaren Phänomene erkläre .
+Eine derartige Ausklammerung Gottes aus wissenschaftlicher Forschung wird als methodischer oder methodologischer Atheismus bezeichnet . Er impliziert allerdings keinen theoretischen Atheismus , behauptet also nicht , dass Gott nicht existiert .
+Daher wird manchmal präziser von „ methodischem Noninterventionismus “ gesprochen .
+Die Frage , ob wissenschaftliches Denken und die Annahme eines Gottes überhaupt dergestalt in Beziehung treten können , dass eine gegenseitige Bestätigung oder Widerlegung denkbar ist , wird unter Wissenschaftstheoretikern kontrovers beurteilt .
+Auch in populärwissenschaftlichen Schriften finden sich gegenteilige Annahmen .
+Einige , z. B.
+Stephen Jay Gould und John Polkinghorne , vertreten den Standpunkt , dass die Wissenschaft mit der Religion nicht in Konflikt stehe , da sich erstere mit Empirie , letztere hingegen mit Fragen letzter Begründung und mit moralischen Werten befasse .
+Andere , z. B.
+Richard Dawkins , Steven Weinberg und Norman Levitt , argumentieren , dass Theismus mit einer wissenschaftlichen Weltsicht grundsätzlich unvereinbar sei , da Wunder wie die Auferstehung Jesu Christi die Naturgesetze außer Kraft setzen müssten ; die Wissenschaft führe demnach zwangsläufig zu Atheismus , Deismus oder Pantheismus .
+Bis zur Mitte des 20. Jahrhunderts gab es noch mehrere wirkungsmächtige , intellektuell sogar hegemoniale „ wissenschaftliche Weltanschauungen “ , darunter den Marxismus in mehreren politischen Ausformungen , die Psychoanalyse oder den Neopositivismus , die erklärtermaßen atheistisch waren und den Religionen eine schädliche Wirkung zuschrieben .
+Atheismus und Moral Mit anderen vertrat Immanuel Kant die Auffassung , dass moralische Prinzipien auch ohne Rückgriff auf höhere Wesen in der menschlichen Vernunft bzw. in der Natur zu gründen seien .
+Recht und Moral gäben die Möglichkeit , Maximen von Freiheit und Handlungen unter allgemeinen ( Vernunft- ) Gesetzen bestehen zu lassen . Zumindest sollte hier ableitbar sein , dass die Beurteilungskriterien rational verhandelbar seien .
+Vor allem in kirchlichen Kreisen wird die Meinung vertreten , dass mit dem fehlenden Glauben an Gott die Verneinung moralischer Werte im Sinne eines Nihilismus einhergehe . So bezeichnet der evangelikale Religionswissenschaftler und Publizist Ravi Zacharias den Atheismus als „ jeden Wertes beraubt “ und bestreitet , dass es fundierte moralische Prinzipien ohne Rückgriff auf höhere Wesen geben könne .
+Der katholische Staatsrechtler und vormalige Verfassungsrichter Ernst-Wolfgang Böckenförde wird mit der Formel zitiert : „ Der freiheitliche , säkularisierte Staat lebt von Voraussetzungen , die er selbst nicht garantieren kann . “ Dieses sogenannte Böckenförde-Diktum wird teilweise so gedeutet , dass Demokratien auf religiöse Bindungen als Garanten gemeinsamer Grundwerte angewiesen seien .
+Gegen diese Deutung wendet sich Gerhard Czermak .
+Er meint , Böckenförde werde „ gründlich missverstanden , wenn nicht instrumentalisiert “ , sofern aus seinem Diktum abgeleitet werde , Empirische Ergebnisse zur Moral und ihre Interpretation Auch empirisch ist das Verhältnis von Religion und Moral nicht geklärt .
+Einige Untersuchungen legen nahe , dass persönliche Moral nicht von persönlicher Religiosität abhängig ist .
+So fanden z. B.
+Franzblau bei Atheisten größere Ehrlichkeit , und Ross bei Atheisten größere Hilfsbereitschaft gegenüber Armen .
+Gero von Randow entnimmt sozialpsychologischen Studien „ eine auffallend geringe Kriminalität unter Nichtgläubigen .
+Das sollte umgekehrt auch nicht zu ihren Gunsten ins Feld geführt werden , denn sie sind tendenziell sozial besser gestellt und gebildeter als die Gläubigen , jedenfalls im Westen ; wir haben es hier also nicht mit einem Religions- , sondern mit einem Klasseneffekt zu tun . “ Eine Trennung von Moral und Theismus stellt die Auffassung dar , die unter anderem John Leslie Mackie in seinem Buch Ethik und Richard Dawkins in seinem Buch Der Gotteswahn ausführen , nämlich dass Moral an den Prozess der biologischen Evolution gekoppelt und Ergebnis eines gesellschaftlich beeinflussten Entwicklungsprozesses sei .
+Hieraus könne folgen , dass die menschliche Moral auch dann Bestand habe , wenn Religionen in Verfall gerieten .
+Empirische Ergebnisse zur Sinnsuche Laut einer empirischen Studie ist Atheismus ( ebenso wie sich nicht einer Religionsgruppe zugehörig zu fühlen ) mit der Vorstellung verbunden , dass das Leben dann sinnvoll ist , wenn man ihm selbst Sinn gibt .
+Dagegen unterscheiden sich Atheisten und Theisten nicht hinsichtlich ihrer Neigung zu Fatalismus oder Nihilismus .
+Abgrenzungen zu religiösen Orientierungen Aus atheistischer Perspektive erscheint das Handeln aufgrund angeblich göttlicher Gebote fragwürdig , weil die Bewertung eines Verhaltens oder einer Handlung nicht von den Folgen für die Betroffenen abhängt , also auf die zwischenmenschliche Ebene zielt , sondern als ethisch wünschenswert hauptsächlich vermittels der extrinsischen Festsetzung eines transzendenten Wesens gilt .
+Ein Mord zum Beispiel wäre nach streng theistischer Auffassung nicht bereits wegen der Folgen für das Opfer eine schlechte , zu verurteilende Handlung , sondern auf der Grundlage göttlicher Gebote .
+„ Es erscheint als höchst problematisch , etwas so Notwendiges wie die Moral auf die Basis von so Dubiosem – wie es der religiöse Glaube ist – stellen zu wollen .
+Wie sollte auf diese Weise eine wirkliche Orientierung und Lebenskunde möglich sein ? “ , schreibt Gerhard Streminger . Bereits Platon hatte in seinem frühen Dialog „ Euthyphron “ mit dem sogenannten Euthyphron-Dilemma darauf hingewiesen , dass es generell unmöglich sei , das moralisch Gute im Rückgriff auf ein göttliches Prinzip zu begründen .
+Auch nach Kant kann die Verpflichtung eines Menschen zur Moralität prinzipiell nicht dadurch begründet werden , dass man auf die „ Idee eines andern Wesens über ihm “ , also auf einen Gott verweist .
+Dem Argument , ohne ein von einer göttlichen Instanz gegebenes , für jeden Menschen gleichermaßen verbindliches Gesetz sei es schwieriger , eine gemeinsame ethische Grundlage für eine Gesellschaft zu finden , halten manche Atheisten entgegen : Keine Religion könne überzeugend begründen , warum ihr Gesetz von einer göttlichen Instanz gegeben worden sein sollte und deshalb Allgemeinverbindlichkeit beanspruchen können sollte .
+Nicht einmal die Existenz irgendeiner göttlichen Instanz könne überzeugend begründet werden .
+So dürfe man davon ausgehen , dass die Gesetze der Religionen ebenso von Menschen gemacht seien wie alle anderen Gesetze und Verhaltensregeln : teilweise auf der Basis von Vernunft und Einsicht , teilweise auf der Basis der Interessen derjenigen , die über genug Macht verfügten , um ihre Vorstellungen durchzusetzen .
+Während einerseits Gesetze einer göttlichen Instanz als Hilfsmittel zur Stabilisierung des sozialen Miteinanders angesehen werden , vertreten manche Atheisten die Auffassung , dass der Anspruch der Religionen auf Allgemeinverbindlichkeit ihrer Gesetze es oftmals erschwert habe , eine gemeinsame ethische Grundlage für eine Gesellschaft zu finden .
+Nicht selten habe der Versuch , diese Allgemeinverbindlichkeit durchzusetzen , zu Verfolgungen , Vertreibungen oder gar Glaubenskriegen geführt .
+Umgekehrt wird auf Christenverfolgungen gemäß atheistischer Staatsdoktrin verwiesen .
+Atheisten halten eine religiöse Überzeugung für die Erarbeitung einer gemeinsamen ( moralisch- ) ethischen Grundlage vielfach eher für hinderlich : Viele Gläubige fühlten sich an göttliche Gesetze gebunden und seien vermutlich deshalb weniger bereit , ihre Vorstellungen in Zusammenarbeit mit anderen Menschen weiterzuentwickeln .
+„ Prallen Anhänger religiös fundierter Ethiken aneinander , so sind Konflikte in vernünftiger Weise kaum zu lösen , da alle sich von Gott geleitet fühlen ; alle glauben , dass die eigenen Gebote objektiv gegeben , eben gottgewollt seien “ , schreibt Gerhard Streminger . Einige Gläubige hingegen betrachten die ( moralisch- ) ethischen Vorstellungen , die ihre Religion mit verwandten Religionen gemeinsam hat , als gute Grundlage für Zusammenarbeit und Weiterentwicklung .
+Ein Problem mangelnder Bereitschaft zur Weiterentwicklung ethischer Vorstellungen kann aus atheistischer Sicht darin liegen , dass die Anpassung von Verhaltensregeln an neue gesellschaftliche Gegebenheiten verhindert wird .
+Für die ethische Beurteilung einer Scheidung zum Beispiel sei zu berücksichtigen , ob die Frau als Konsequenz daraus materieller Not und gesellschaftlicher Ächtung ausgesetzt wäre , oder ob sie materiell abgesichert und gesellschaftlich akzeptiert bliebe .
+Atheistisch-weltanschauliche Gruppierungen Während Glaubensvertreter den Atheisten vielfach die für ein funktionierendes gesellschaftliches Zusammenleben nötige ethische Fundierung absprechen , findet andererseits – hauptsächlich in der westlichen Welt – seit einigen Jahrzehnten eine lebhafte Auseinandersetzung darüber statt , ob nicht atheistischer Humanismus eine zeitgemäßere Grundlage für eine allgemeine Ethik bietet als die tradierten Religionen .
+Deutschsprachige Gruppierungen , Stiftungen und Dachverbände :
+Dachverband freier Weltanschauungsgemeinschaften ( DFW ) Giordano-Bruno-Stiftung ( gbs ) Humanistischer Verband Deutschlands ( HVD ) Koordinierungsrat säkularer Organisationen ( KORSO ) Richard Dawkins Foundation für Vernunft und Wissenschaft
+Im Ausland tätige Gruppierungen , Stiftungen und Dachverbände :
+American Atheists
+Council for Secular Humanism ( CSH ) Freedom From Religion Foundation ( FFRF ) Humanists UK , vormals British Humanist Association ( BHA )
+National Secular Society ( NSS ) Rationalist International
+Richard Dawkins Foundation for Reason and Science ( RDFRS oder RDF ) Unione degli Atei e degli Agnostici Razionalisti ( UAAR ) Internationale Bewegungen , Dachverbände und Komitees :
+Atheist Alliance International ( AAI ) Committee for Skeptical Inquiry ( CSI ) Internationale Humanistische und Ethische Union ( IHEU ) Religiöser Atheismus Die Frage , was an einer Haltung religiös sein könne , in der Gott offensichtlich keine Rolle spielt , behandelte Ronald Dworkin in seinen Einstein-Vorlesungen .
+Seine Antwort : „ Religion ist etwas Tieferes als Gott . “ „ Er verstand sich als religiöser Atheist , das heißt : Er glaubte zwar nicht an Gott , wohl aber an die sinnhafte Einheit des Kosmos und die Versöhnung von Glauben und Wissen . “ Während Theisten sie als von Gott geboten betrachten , argumentiert Dworkin , unsere ethischen Überzeugungen „ könnten wir nicht haben , ohne zu denken , dass sie objektiv wahr sind “ .
+Atheismus als religiöses Bekenntnis Einige Atheisten verstehen ihre Weltanschauung als religiöses Bekenntnis und streben auf dem Wege einer religionsrechtlichen Anerkennung als Religionsgemeinschaft eine Gleichberechtigung und staatliche Gleichbehandlung an . Als deutschsprachige Gruppierung dieses Typs kann die Atheistische Religionsgesellschaft in Österreich genannt werden .
+Freireligiöse Bewegung Laut Eigendarstellung der freireligiösen Bewegung gibt es unter den Freireligiösen auch Atheisten oder atheistisch-religiöse Positionen .
+Jüdischer und christlicher Atheismus Die Religionskritik der Bibel ist der Ausgangspunkt eines jüdischen und christlichen Atheismus .
+Das Judentum beschreibt Douglas Rushkoff , Professor für Kommunikationstheorie an der New York University , aufgrund der Bilderlosigkeit des biblischen Gottes als Ausweg aus der Religion ( Nothing Sacred : The Truth about Judaism , 2004 ) .
+In den 1960er Jahren bildete sich in den USA eine Gruppe von Theologen , welche unter dem Satz „ Gott ist tot “ einen christlichen Atheismus proklamierte .
+Vertreter dieser Richtung sind der Theologe Thomas J. Altizer ( The Gospel of christian atheism , 1966 ) , William Hamilton ( Radical Theology and the Death of God , 1966 ) , Paul van Buren ( The secular meaning of the Gospel , 1963 ) oder Gabriel Vahanian ( The death of God , 1961 ) .
+Der „ Tod Gottes “ , also die vermeintliche Unmöglichkeit , in der modernen Welt rational an einen Gott zu glauben , sei , so beispielsweise J. Altizer , eine gute Nachricht , da sie den Menschen von einem transzendenten Tyrannen befreit habe .
+Die säkulare Botschaft der Evangelien beziehe sich gemäß Paul van Buren allein auf den „ Befreier “ Jesus von Nazaret .
+Während der Glaube an einen ( jenseitigen ) Gott abgelehnt wird , steht bei den „ christlichen Atheisten “ die ethisch-moralische Botschaft Jesu , die rein auf das Diesseits bezogen wird , im Mittelpunkt .
+In der Zeit nach dem Zweiten Weltkrieg hat sich auch eine Verknüpfung von Atheismus und Christentum entwickelt , die sich explizit auf das Schweigen Gottes angesichts der Ermordung von Millionen von Juden durch deutsche Nationalsozialisten im Holocaust bezieht .
+Die deutsche Theologin Dorothee Sölle ist die bekannteste Vertreterin dieser Richtung .
+Beeinflusst wurden einige Theologen der „ Gott-ist-tot-Theologie “ auch durch die religionsphilosophischen Gedanken Ernst Blochs im dritten Band seines Hauptwerkes Das Prinzip Hoffnung .
+1968 hat Bloch Gedanken daraus zusammengefasst , präzisiert und erweitert in dem Buch Atheismus im Christentum , in dem sich der Satz findet : Dorothee Sölle , von Bloch beeinflusst , veröffentlichte ebenfalls 1968 ein Buch mit einem ganz ähnlichem Titel : Atheistisch an Gott glauben . Atheismus bedeutet bei Ernst Bloch wie auch bei Dorothee Sölle nicht den Verzicht auf Sinnhaftigkeit oder Transzendenz , sondern die Abkehr von einem allzu theistischen Gottesbild , der Vorstellung eines Gottes , der als allmächtiger , allwissender und allgegenwärtiger Gott Not und Leid bis hin zu Auschwitz zugelassen hat .
+In der Dekonstruktion und in der Nachfolge des Denkens von Emmanuel Levinas und Jacques Derrida fand sich ein weiterer Ansatz der Ausarbeitung eines christlichen Atheismus .
+Vertreter sind unter anderem Peter Rollins und Jean-Luc Nancy ( Dekonstruktion des Christentums 2008 ) .
+Kurzgefasst kann man darin die Vereinnahmung der Geste der Dekonstruktion sehen , in der der Sohn das Gesetz , die Arché des Vaters auflöst , indem er aber selbst vom Gesetz verurteilt wird .
+Damit werden messianische Ansätze des späten Derrida mit seinem Denken über die différance verbunden .
+Buddhismus Der Buddhismus kennt keinen Glauben an einen Schöpfergott .
+Manche buddhistische Schulen nehmen aber in ihrer Kosmologie die Existenz zahlreicher anderer Ebenen der Wirklichkeit an , auf denen sowohl besser- als auch schlechtergestellte Wesen existieren , von denen die höheren Wesen den hinduistischen Göttern ( Devas und Asuras ) entsprechen .
+Diese Götter sind allerdings wie alle Wesen selbst im Existenzkreislauf , Samsara , gefangen ; im Sinne der Wiedergeburtslehre kann jedes Wesen irgendwann auch als Deva geboren werden , wenn das entsprechende Karma ( in diesem Fall überaus große Freigiebigkeit bzw. Samadhi-Erfahrungen ) angesammelt wurde .
+Im Mahayana- oder nördlichen Buddhismus verehrt man darüber hinaus Wesen , die selbst Buddhas oder Bodhisattvas geworden sind .
+Durch den Respekt , den man diesen entgegenbringt , entsteht eine der notwendigen Grundlagen , selbst diesen Zustand zu erlangen .
+Daher werden im Buddhismus zahlreiche Statuen , Stupas und Tempel errichtet , die Objekte der Verehrung sind .
+Diese Wesen sind aber keine Götter , sondern Vorbilder .
+Im Theravada- oder südlichen Buddhismus ist das Ziel Arhatschaft , also Befreiung ohne Wiederkehr , sodass Arhats nur in der letzten Phase ihres letzten Lebens verehrt werden können .
+Daneben gibt es auch hier zahllose Stupas , Tempel , Buddhastatuen und Bildnisse früherer Arhats , zum Teil sogar von Bodhisattvas .
+Die Frage nach einem Schöpfergott wird als unfruchtbare metaphysische Spekulation zurückgewiesen und stattdessen die Ergründung der eigenen Erkenntnismöglichkeiten betont .
+Islam Datei : Apostasie - Todesstrafe.svg In islamisch geprägten Kulturen fallen Atheisten unter den Begriff Kāfir ( ‚ Ungläubiger ‘ , ‚ Gottesleugner ‘ ) . Muslimen wird nicht das Recht zugestanden , ihre Religion zu wechseln oder Atheisten zu werden .
+Der Koran nennt keine diesseitigen Strafen für den „ Abfall vom Islam “ , worunter auch die Zuwendung zum Atheismus fällt .
+Im islamischen Recht , der Scharia , ist diese jedoch auf Grundlage von Hadithen und Idschmāʿ mit der Todesstrafe zu ahnden .
+Im Sudan ( StGB aus dem Jahre 1991 , Art. 126 ) , Republik Jemen , Iran , Saudi-Arabien , Katar , Pakistan , Afghanistan , Somalia und in Mauretanien ( StGB aus dem Jahre 1984 , Art. 306 ) kann Abfall vom Islam noch heute mit dem Tode bestraft werden .
+Auch in Ländern , deren staatliche Rechtsordnung sich an der Scharia orientiert , die aber keine islamischen Gerichtshöfe mehr haben , kann der bekundete „ Abfall vom islamischen Glauben “ zivilrechtliche ( Erbrecht , Eherecht ) und strafrechtliche Konsequenzen haben .
+Pantheismus Im pantheistischen ( griechisch : Allgottlehre ) Gotteskonzept nimmt die Alleinheit des Universums die Schöpferrolle ein .
+Gott und Natur sind demnach gewissermaßen identisch .
+Da es im Pantheismus keinen persönlichen Gott gibt , wurde und wird der Pantheismus sowohl von Theisten als auch von Atheisten manchmal als ein hinter einer religiösen Sprache versteckter Atheismus betrachtet .
+Arthur Schopenhauer nannte den Pantheismus eine „ Euphemie für Atheismus “ . „ Pantheismus ist nur ein höflicher Atheismus “ , heißt es in einem Schopenhauer-Zitat von Ernst Haeckel . Der französische Philosoph Jean Guitton vertritt in seinem Werk die Überzeugung , dass er dem Atheismus die Verlegung des Gottesbegriffs in die Welt nachweisen könne und ordnet ihn daher generell dem Pantheismus zu . Der Pantheismus wird von seinen Anhängern als religionsphilosophische Lehre betrachtet und wurde in früheren Zeiten nicht dem Atheismus zugehörig betrachtet , was sich aber inzwischen geändert hat .
+Geschichtliche Entwicklung Atheismus ist „ so alt wie das menschliche Denken , so alt wie der Glaube , und der Konflikt zwischen beiden ist ein ständiges Merkmal der abendländischen Zivilisation “ , heißt es bei Georges Minois , der Atheismus sowohl ideen- als auch verhaltensgeschichtlich zu erfassen sucht .
+Für die frühen Hochkulturen ergibt sich allerdings die Schwierigkeit , dass etwa sakrale Gebäude und kultische Schriften zu den vorherrschenden Überlieferungszeugnissen immer schon gehörten , während die weniger auffälligen Zeugnisse von Skeptizismus , Nichtglauben und religiöser Gleichgültigkeit erst in jüngerer Zeit einer intensivierten Forschung unterzogen werden , die etwa auch den asiatischen Raum einschließt .
+Praktischer und theoretischer Atheismus hatten und haben aber je eigene und einander ergänzende Bedeutung : In Antike und Mittelalter waren sowohl das private als auch das öffentliche Leben in der Regel von religiösen Vorstellungen durchdrungen , wogegen Skepsis und Zweifel eher bei Minderheiten und in intellektuellen Kreisen anzutreffen waren .
+Während sich die kritischen Auseinandersetzungen innerhalb der römisch-katholischen Kirche im späten Mittelalter verstärkten und in der Reformation einen Höhepunkt fanden , erfuhr der Atheismus im Zeitalter der Aufklärung einen bedeutenden Aufschwung und durch die Französische Revolution eine starke gesellschaftliche Verbreitung .
+Dies führte zur Säkularisierung und vielfach zur Trennung von Kirche und Staat .
+Im 19. und 20. Jahrhundert wurden verschiedenste atheistische Positionen mit breitem theoretischem Fundament entwickelt , insbesondere im Marxismus , im Existentialismus und in der analytischen Philosophie .
+Zudem bestehen im philosophischen Materialismus und im philosophischen Naturalismus Verbindungslinien zum Atheismus .
+Süd- und Vorderasien Die frühesten belegbaren Formen des theoretischen Atheismus finden sich in den alten Hochkulturen Süd- und Vorderasiens .
+In Indien weisen einige der ältesten philosophischen Systeme atheistische Formen auf .
+Hierzu zählen der Jainismus , das Samkhya ( beide entstanden etwa im 6. Jahrhundert v. Chr. ) sowie das Vaisheshika und das Nyaya .
+Insbesondere die Tradition des Samkhya ist im indischen Denken bis heute lebendig geblieben ( vergleiche Atheismus in Indien ) .
+Klar materialistisch-atheistisch war die indische Schule der Charvaka , die zweifelsfrei seit dem 6. / 7.
+Jahrhundert n. Chr. als feste Strömung belegbar ist und mindestens bis ins 16. Jahrhundert existierte .
+Sie berief sich auf die heute verlorenen „ Barhaspati Sutras “ .
+Nach Meinung vieler Indologen war es jedoch kein atheistisches Werk , sondern eine gegen etablierte Religionen skeptische , aber ethische Schrift .
+Einzelne Skeptiker sind vom 5. Jahrhundert v. Chr. bis zum 6. Jahrhundert n. Chr. überliefert .
+Der Buddhismus , der im 5. Jahrhundert v. Chr. in Indien entstand , und der Daoismus , der im 4. Jahrhundert v. Chr. in China entstand , kennen keine Schöpfergottheit .
+In Teilen der Fachliteratur wird der Zervanismus der antiken Perser mit dem übergeordneten unpersönlichen Prinzip des Zurvan ( „ Zeit “ und Raum ) als eine Form des Atheismus angesehen .
+Materialistisch und vorwiegend atheistisch war die spätestens seit dem 5. Jahrhundert n. Chr. existierende Strömung der „ Zandiks “ oder „ Dahri “ .
+Ob die Hebräer einen theoretischen Atheismus kannten , ist umstritten .
+Jean Meslier sah in einigen Stellen des Alten Testaments Belege für die Existenz von Atheisten .
+So z. B.
+in Ps 10,3 : Diese Interpretation wird von den meisten Exegeten jedoch nicht geteilt .
+Ihrer Meinung nach würden an den besagten Stellen stets nur bestimmte Eigenschaften Gottes geleugnet , nie aber seine Existenz .
+Griechisch-römische Antike Vorsokratiker Datei :D emocritus2.jpg Die fragmentarisch überlieferten ontologischen Systeme der Vorsokratiker erklären die Strukturen der Wirklichkeit nicht durch mythische oder ätiologische Erzählungen , sondern durch Zurückführung auf ein oder mehrere Prinzipien .
+Bei beispielsweise Demokrit oder Epikur kommen hierfür nur materielle Prinzipien in Betracht , so dass ein transzendenter , insb .
+geistiger Gott weder verwendet wird , noch Ort oder Funktion in diesen Systemen bekommen könnte .
+Andererseits ergeben sich bisweilen Konflikte mit etabliertem religiösem Kult und etablierter Rede über die Götter , weil ontologischen Prinzipien ähnliche oder dieselben Eigenschaften zugeschrieben werden wie den Göttern , etwa , über Naturprozesse zu regieren , ewig zu sein oder Prinzip für Leben und Denken zu sein .
+Die frühesten Formen einer Kritik der etablierten Gottesvorstellungen beziehen sich vor allem auf unangemessen menschliche Vorstellungsweisen ( Anthropomorphismus ) .
+Göttern werden z. B.
+wankelmütige , jähzornige , eifersüchtige und egoistische Charakterzüge abgesprochen , wie sie in den Mythen Hesiods und Homers hervortreten .
+Beispiele hierfür sind Xenophanes , Heraklit und Protagoras .
+Xenophanes etwa erklärt die Göttervorstellungen und auch deren Verschiedenheit durch Projektion menschlicher Eigenschaften und formuliert polemisch : „ Stumpfnasig , schwarz : so seh ’ n Äthiopiens Menschen die Götter Blauäugig aber und blond : so seh ’ n ihre Götter die Thraker Aber die Rinder und Rosse und Löwen , hätten sie Hände Hände wie Menschen , zum Zeichnen , zum Malen , ein Bildwerk zu formen , Dann würden Rosse die Götter gleich Rossen , die Rinder gleich Rindern Malen , und deren Gestalten , die Formen der göttlichen Körper , Nach ihrem Bilde erschaffen : ein jedes nach seinem . “ Während derart anthropomorphe Gottesvorstellungen , so der Tenor dieser Kritik , nichts anderes sind als eben nur menschliche Vorstellungen , tritt dem als kritisches Korrektiv zunehmend die Vorstellung eines monotheistischen , transzendenten göttlichen oder quasi-göttlichen Prinzips gegenüber .
+Empedokles ( * zwischen 494 und 482 ; † zwischen 434 und 420 v. Chr. ) sah in Göttern auch Personifizierungen der vier Elemente .
+Kritias ( * 460 ; † 403 v. Chr. ) betrachtete die Religion als menschliche Erfindung , die der Aufrechterhaltung der moralischen Ordnung dienen sollte .
+Skeptizismus und Asebie-Prozesse Ein Abrücken oder Infragestellen der in der Polis kultisch verehrten Götter seitens skeptischer Philosophen oder naturwissenschaftlich orientierter Denker konnte zu Anklagen und Verurteilungen führen .
+Gottlosigkeit und Frevel an Göttern wurden im alten Athen als Asebeia teilweise auch strafrechtlich verfolgt .
+Eine erste Welle bekannter Asebie-Prozesse , bei denen politische Motive mitgewirkt haben dürften , richtete sich gegen Vertraute und Freunde des Perikles , darunter Aspasia und Anaxagoras .
+Der im 5. Jahrhundert v. Chr.
+namentlich von Sophisten geförderte Prozess der Infragestellung herkömmlicher Gottesbilder , auf den in den Asebieprozessen reagiert wurde , setzte sich unaufhaltsam fort .
+Auf Widerstand in dieser Form stieß auch der wegen seines religiösen Relativismus 415 v. Chr.
+aus Athen verbannte Protagoras , der sein Nichtwissen über die Existenz der Götter betonte und gleichzeitig erklärte , der Mensch sei das Maß aller Dinge .
+Skeptizistische und agnostische Positionen , wie sie die Sophisten und Sokrates ( * 469 ; † 399 v. Chr. ) vertraten , fanden eine zunehmende Verbreitung , und die Anklage wegen Gottlosigkeit gegen die „ Physiker “ wird gängige Praxis : „ Der Gelehrte , der in einem positivistischen Geist arbeitet , wird beschuldigt , das Geheimnis der Götter ergründen und das Heilige gewissermaßen ‚ zergliedern ‘ zu wollen . “ Einige der Angeklagten vertraten in den überlieferten Asebie-Prozessen nicht nur eine agnostische , sondern eine dezidiert atheistische Position ( Diagoras von Melos , Theodoros von Kyrene ) .
+Gegen die wegen ihrer Schönheit bewunderte Phryne ist ein Asebie-Prozess überliefert , demzufolge ihr die Aktmodell-Arbeit für eine Aphrodite-Statue als ein Frevel gegen die Götter ausgelegt wurde .
+Von einer geistesgeschichtlich bis heute nachhallenden Wirkung war der Prozess gegen Sokrates .
+Seine Glaubensskepsis ist im platonischen Dialog Phaidros zum Ausdruck gebracht : Es sei abwegig , etwas über die Mythen und die Götter zu sagen , da er noch nicht einmal die Zeit habe oder in der Lage sei , sich selbst zu erkennen .
+„ Lächerlich also kommt es mir vor , solange ich hierin noch unwissend bin , an andere Dinge zu denken . “
+Platon ist aber als Sokrates ’ Schüler nicht nur die wichtigste Überlieferungsquelle für dessen Denken und Philosophieren , sondern Minois zufolge der Erstverantwortliche für die Verfemung des Atheismus in den nachfolgenden zwei Jahrtausenden .
+In seinem Spätwerk Nomoi ( Gesetze ) bezieht er eine pantheistische Position , die sich von einem strengen Naturalismus abgegrenzt , weil dieser die nichtmateriellen Wirkungskräfte verkenne : Im zehnten Buch der Nomoi geht es Platon darum zu beweisen , dass es Götter gibt , dass sie sich auch um die Kleinigkeiten des Lebens kümmern , ohne aber bestechlich zu sein , und im Weiteren darum zu begründen , dass Atheisten je nach Grad der Gottesleugnung und Heuchelei mit abgestuften Sanktionen bis zur Todesstrafe zu belegen seien .
+Da es in Platons Lehre außerhalb der materiellen Welt eine höherwertige Welt der Ideen , der Archetypen , der Seelen und des Göttlichen gibt , gelten Atheisten , so Minois , fortan als von niederem Denken beherrscht und unfähig , sich zur Kontemplation der Ideen zu erheben .
+Der Einfluss platonischer Schulen auf die Unterdrückung des Atheismus ist umstritten .
+Als die Prozesse wegen Gottlosigkeit im Verlauf des 4. Jahrhunderts v. Chr. abnahmen , waren skeptische Einstellungen nicht etwa zurückgegangen , sondern unterdessen so verbreitet , dass die strafrechtliche Verfolgung immer weniger Wirkung zeigte .
+So konnte der Kyniker Diogenes ( * ca.
+400 ; † 325 v. Chr. ) seinen Spott über Götter , Mysterien , Vorsehung und Aberglauben in Athen verbreiten , ohne dass man ihm den Prozess machte .
+Hellenismus Datei : Epikur.jpg Während die Verehrung der anthropomorphen olympischen Götter auch im häuslichen Kult immer mehr an Bedeutung verlor , traten im Zuge des Zerfalls von Polis und herkömmlicher stadtstaatlicher Ordnung – auf dem Wege also zu den hellenistischen Großreichen und danach zum Römischen Reich – neben allerlei importierten Mysterienkulten und auswärtigen Gottheiten auch zunehmend vergöttlichte Herrscher , die auf diese Weise religiöse Bindungsbereitschaft zum eigenen Vorteil umlenkten .
+Weit entfernt von den alten Glaubensformen sind auch die an der Wende vom 4. zum 3. Jahrhundert v. Chr. entstehenden philosophischen Lehren des Epikureismus und der Stoa .
+Bei den Stoikern kommen pantheistische Vorstellungen zur Entfaltung , die das Göttliche mit der Allnatur verschmelzen und darin den Wirkungsort für die Menschen und für ihr ethisches Bezugssystem finden .
+Bei Epikur verschwinden die Götter in vom menschlichen Dasein gesonderten Welten und haben keinerlei Wirkungsmacht über die Menschen und ihr Treiben .
+Es handelt sich getreu dem rein materialistischen Weltbild Epikurs auch bei den Göttern um atomar konstituierte Wesen .
+Allerdings empfiehlt Epikur als der eigenen Seelenruhe dienlich , sich den staatlich vorgeschriebenen Kulten und religiösen Bräuchen flexibel anzupassen .
+Römische Antike Datei : Marc & #39 ; aurelio , da gabi , fine II secolo dc .. JPG Mit der römischen Expansion verloren die überlieferten lateinischen Götter an Bindungskraft und Bedeutung .
+Die Eroberung Griechenlands und des östlichen Mittelmeerbeckens durch die Römer brachte mit auswärtigen Religionen und Gottheiten spiritualistische und materialistische Denkschulen zuhauf nach Rom : so z. B.
+Kybele , Isis , Osiris und Serapis , dazu astrologische und magische Vorstellungen sowie auch platonische , kynische und skeptische , epikureische und stoische Lehren .
+Der von Lukrez in Rom hymnisch verbreitete Epikureismus , in dessen Zentrum ein asketisch unterlegtes Lust- und Glücksstreben steht , stellt sich mit der vollständigen Abscheidung der Götter als eine im Grunde konsequent atheistische Morallehre dar .
+Die Stoa wiederum , die in den herrschenden Kreisen der römischen Gesellschaft häufig angenommen wurde , vermittelt einen nur vage-verschwommenen Gottesbegriff und trennt in dem anzustrebenden Ideal des stoischen Weisen kaum noch zwischen Mensch und Gott .
+Ciceros Untersuchung über die Natur der Götter ( De natura deorum ) mündete in Skepsis : „ Bestimmt wird selbst diejenigen , die darüber etwas zu wissen glauben , die so große Uneinigkeit der gelehrtesten Männer in dieser wichtigen Frage zu gewissen Zweifeln zwingen . “
+Eine – freilich weniger reflektierte – agnostische Grundstimmung scheint in der frühen Römischen Kaiserzeit ( parallel zum Beginn des Frühchristentums ) auch in Volkskreisen verbreitet gewesen zu sein ; so legt der Schriftsteller Petronius in seinem satirischen Roman Satyricon ( in der Szene des Gastmahls des Trimalchio ) dem Protagonisten Ganymedes die Worte in den Mund : Der sich einstellenden Vielfalt weltanschaulich-religiöser Vorstellungen gegenüber stand die Bereitschaft , als Atheismus zu diskriminieren und zu kriminalisieren , was nicht zu den etablierten Staatskulten gehörte .
+Davon war in seinen Anfängen auch das Christentum betroffen .
+Denn dessen Anhänger lehnten es aus Glaubensgründen ab , an den religiösen Staatskulten teilzunehmen . In der Ablehnung insbesondere des Kaiserkults wurden sie nicht selten zu Märtyrern .
+Mittelalter und Reformation Ob es im Mittelalter Atheismus im Sinne einer Leugnung der Existenz eines Gottes gab , ist umstritten .
+Traditionell wird das „ christliche Mittelalter “ als Zeitalter angesehen , in dem Europa komplett durch das Christentum bestimmt war , mit der Ausnahme kleiner jüdischer und muslimischer Minderheiten .
+Die oft dürftige und fast durchgängig christlich geprägte Quellenlage erschwert eine eindeutige Zuordnung einzelner Denker oder Personengruppen zum Atheismus .
+Der Theologe Walter R. Dietz schreibt , die Bezeichnung Atheismus sei im Mittelalter nur verwendet worden für Leugnungen des dreifaltigen Gottesgedankens , etwa durch den Islam . Nach dem evangelischen Theologen Jan Milič Lochman trat Atheismus im Sinne von Gottesleugnung oder Gottlosigkeit in Europa erst seit dem 16. und 17. Jahrhundert auf . Dem französischen Historiker Georges Minois zufolge gab es im Mittelalter durchaus Atheismus , und zwar sowohl in seiner praktischen , wie auch zumindest ansatzweise in seiner theoretischen Form. Der Glaube habe das Mittelalter zwar beherrscht , der Atheismus habe aber im Leben und Denken einer Minderheit überdauert .
+Theoretischer Atheismus Seit dem 13. Jahrhundert ist eine zunehmende Kritik christlich-katholischer Glaubensinhalte zu beobachten .
+Eine wesentliche Rolle scheint hierbei die Wiederentdeckung aristotelischer Lehren und deren Interpretation durch arabische Philosophen gespielt zu haben . Wirkungsmächtig waren insbesondere der Aristotelismus und der Averroismus .
+Bedeutend war , dass Aristoteles , obwohl er teilweise als „ Heide “ bezeichnet wurde , doch als der Meister des logischen Denkens galt .
+Die aristotelische Philosophie widerspricht der christlichen Lehre insbesondere in zwei Punkten : Sie verneint die Schöpfung und die Unsterblichkeit der Seele . Daher wurde das Unterrichten seiner Physik und Metaphysik auch wiederholt durch päpstlichen Erlass untersagt .
+Dennoch erstritt sich Georges Minois zufolge die Vernunft vom 11. bis 13. Jahrhundert eine zunehmend größere Unabhängigkeit vom Glauben . Petrus Abaelardus forderte ein , dass der Glaube den Regeln der Vernunft nicht widersprechen dürfe .
+Boetius von Dacien trat für die strikte Trennung von rational erfassbarer Wahrheit und Glaubenswahrheiten ein .
+Siger von Brabant ging noch weiter und bestritt zahlreiche zentrale christliche Dogmen .
+Die christliche Autorität reagierte einerseits mit Zensur und Repression .
+Zudem gab es jedoch auch verstärkte Bemühungen , den Glauben durch Gottesbeweise zu untermauern .
+Wilhelm von Ockham erklärte alle Versuche , Glaubenssätze mit den Mitteln der Vernunft zu beweisen , für von vornherein zum Scheitern verurteilt .
+Praktischer Atheismus Im 12. Jahrhundert provozierten die Goliarden in ihren Liedern mit zum Teil bewusst provokanten atheistischen Positionen wie „ ich bin begieriger nach Wollust als nach dem ewigen Seelenheil “ . Eine skeptische Haltung in Bezug auf viele Glaubenssätze nahmen auch die englischen Lollarden ein . Auch einige der so genannten „ Blasphemiker “ könnten Atheisten gewesen sein .
+In dem mehreren Autoren zugeschriebenen Buch von den drei Betrügern sind Moses , Jesus Christus und Mohammed gemeint . Daneben lebten auch pantheistische Weltanschauungen in kleineren Glaubensgemeinschaften und unter Einzelpersonen fort .
+Sie sind zwar nicht dem Atheismus im engeren Sinne zuzuordnen , forderten aber wohl den christlichen Glauben heraus .
+Vertreter sind insbesondere die Pariser Theologen David von Dinant und Amalrich von Bena , sowie die Brüder und Schwestern des freien Geistes .
+Im Volk ist die Existenz von Ungläubigen in zahlreichen Berichten von Wundern bezeugt .
