diff --git a/tests/assert.sh b/tests/assert.sh
new file mode 100644
index 0000000..acceebf
--- /dev/null
+++ b/tests/assert.sh
@@ -0,0 +1,248 @@
+#!/usr/bin/env bash
+
+#####################################################################
+##
+## title: Assert Extension
+##
+## description:
+## Assert extension of shell (bash, ...)
+##   with the common assert functions
+## Function list based on:
+##   http://junit.sourceforge.net/javadoc/org/junit/Assert.html
+## Log methods : inspired by
+##	- https://natelandau.com/bash-scripting-utilities/
+## author: Mark Torok
+##
+## date: 07. Dec. 2016
+##
+## license: MIT
+##
+#####################################################################
+
+if command -v tput &>/dev/null && tty -s; then
+  RED=$(tput setaf 1)
+  GREEN=$(tput setaf 2)
+  MAGENTA=$(tput setaf 5)
+  NORMAL=$(tput sgr0)
+  BOLD=$(tput bold)
+else
+  RED=$(echo -en "\e[31m")
+  GREEN=$(echo -en "\e[32m")
+  MAGENTA=$(echo -en "\e[35m")
+  NORMAL=$(echo -en "\e[00m")
+  BOLD=$(echo -en "\e[01m")
+fi
+
+log_header() {
+  printf "\n${BOLD}${MAGENTA}==========  %s  ==========${NORMAL}\n" "$@" >&2
+}
+
+log_success() {
+  printf "${GREEN}✔ %s${NORMAL}\n" "$@" >&2
+}
+
+log_failure() {
+  printf "${RED}✖ %s${NORMAL}\n" "$@" >&2
+}
+
+
+assert_eq() {
+  local expected="$1"
+  local actual="$2"
+  local msg="${3-}"
+
+  if [ "$expected" == "$actual" ]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$expected == $actual :: $msg" || true
+    return 1
+  fi
+}
+
+assert_not_eq() {
+  local expected="$1"
+  local actual="$2"
+  local msg="${3-}"
+
+  if [ ! "$expected" == "$actual" ]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$expected != $actual :: $msg" || true
+    return 1
+  fi
+}
+
+assert_true() {
+  local actual="$1"
+  local msg="${3-}"
+
+  assert_eq true "$actual" "$msg"
+  return "$?"
+}
+
+assert_false() {
+  local actual="$1"
+  local msg="${3-}"
+
+  assert_eq false "$actual" "$msg"
+  return "$?"
+}
+
+assert_array_eq() {
+
+  declare -a expected=("${!1-}")
+  # echo "AAE ${expected[@]}"
+
+  declare -a actual=("${!2}")
+  # echo "AAE ${actual[@]}"
+
+  local msg="${3-}"
+
+  local return_code=0
+  if [ ! "${#expected[@]}" == "${#actual[@]}" ]; then
+    return_code=1
+  fi
+
+  local i
+  for (( i=1; i < ${#expected[@]} + 1; i+=1 )); do
+    if [ ! "${expected[$i-1]}" == "${actual[$i-1]}" ]; then
+      return_code=1
+      break
+    fi
+  done
+
+  if [ "$return_code" == 1 ]; then
+    [ "${#msg}" -gt 0 ] && log_failure "(${expected[*]}) != (${actual[*]}) :: $msg" || true
+  fi
+
+  return "$return_code"
+}
+
+assert_array_not_eq() {
+
+  declare -a expected=("${!1-}")
+  declare -a actual=("${!2}")
+
+  local msg="${3-}"
+
+  local return_code=1
+  if [ ! "${#expected[@]}" == "${#actual[@]}" ]; then
+    return_code=0
+  fi
+
+  local i
+  for (( i=1; i < ${#expected[@]} + 1; i+=1 )); do
+    if [ ! "${expected[$i-1]}" == "${actual[$i-1]}" ]; then
+      return_code=0
+      break
+    fi
+  done
+
+  if [ "$return_code" == 1 ]; then
+    [ "${#msg}" -gt 0 ] && log_failure "(${expected[*]}) == (${actual[*]}) :: $msg" || true
+  fi
+
+  return "$return_code"
+}
+
+assert_empty() {
+  local actual=$1
+  local msg="${2-}"
+
+  assert_eq "" "$actual" "$msg"
+  return "$?"
+}
+
+assert_not_empty() {
+  local actual=$1
+  local msg="${2-}"
+
+  assert_not_eq "" "$actual" "$msg"
+  return "$?"
+}
+
+assert_contain() {
+  local haystack="$1"
+  local needle="${2-}"
+  local msg="${3-}"
+
+  if [ -z "${needle:+x}" ]; then
+    return 0;
+  fi
+
+  if [ -z "${haystack##*$needle*}" ]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$haystack doesn't contain $needle :: $msg" || true
+    return 1
+  fi
+}
+
+assert_not_contain() {
+  local haystack="$1"
+  local needle="${2-}"
+  local msg="${3-}"
+
+  if [ -z "${needle:+x}" ]; then
+    return 0;
+  fi
+
+  if [ "${haystack##*$needle*}" ]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$haystack contains $needle :: $msg" || true
+    return 1
+  fi
+}
+
+assert_gt() {
+  local first="$1"
+  local second="$2"
+  local msg="${3-}"
+
+  if [[ "$first" -gt  "$second" ]]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$first > $second :: $msg" || true
+    return 1
+  fi
+}
+
+assert_ge() {
+  local first="$1"
+  local second="$2"
+  local msg="${3-}"
+
+  if [[ "$first" -ge  "$second" ]]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$first >= $second :: $msg" || true
+    return 1
+  fi
+}
+
+assert_lt() {
+  local first="$1"
+  local second="$2"
+  local msg="${3-}"
+
+  if [[ "$first" -lt  "$second" ]]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$first < $second :: $msg" || true
+    return 1
+  fi
+}
+
+assert_le() {
+  local first="$1"
+  local second="$2"
+  local msg="${3-}"
+
+  if [[ "$first" -le  "$second" ]]; then
+    return 0
+  else
+    [ "${#msg}" -gt 0 ] && log_failure "$first <= $second :: $msg" || true
+    return 1
+  fi
+}
diff --git a/tests/data/wpd19_10000.w2vinput b/tests/data/wpd19_10000.w2vinput
new file mode 100644
index 0000000..f1ab5ea
--- /dev/null
+++ b/tests/data/wpd19_10000.w2vinput
@@ -0,0 +1,10000 @@
+Alan Smithee steht als Pseudonym für einen fiktiven Regisseur der Filme verantwortet bei denen der eigentliche Regisseur seinen Namen nicht mit dem Werk in Verbindung gebracht haben möchte
+Von <num> bis <num> wurde es von der Directors Guild of America DGA für solche Situationen empfohlen seither ist es Thomas Lee Alan Smithee ist jedoch weiterhin in Gebrauch
+Alternative Schreibweisen sind unter anderem die Ursprungsvariante Allen Smithee sowie Alan Smythee und Adam Smithee
+Auch zwei teilweise asiatisch anmutende Schreibweisen Alan Smi Thee und Sumishii Aran gehören - so die Internet Movie Database - dazu
+Geschichte
+Entstehung
+Das Pseudonym entstand <num> infolge der Arbeiten am Western-Film Death of a Gunfighter deutscher Titel
+Frank Patch - Deine Stunden sind gezählt
+Regisseur Robert Totten und Hauptdarsteller Richard Widmark gerieten in einen Streit woraufhin Don Siegel als neuer Regisseur eingesetzt wurde
+Der Film trug nach Abschluss der Arbeiten noch deutlich Tottens Handschrift der auch mehr Drehtage als Siegel daran gearbeitet hatte weshalb dieser die Nennung seines Namens als Regisseur ablehnte
+Totten selbst lehnte aber ebenfalls ab
+Als Lösung wurde Allen Smithee als ein möglichst einzigartiger Name gewählt bei der späteren Variante Alan Smithee war das Anagramm The Alias Men vermutlich kein Entstehungsgrund
+In den zeitgenössischen Kritiken wurde der Regisseur u a von Roger Ebert mit den Worten gelobt
+Aufdeckung und Abkehr
+<num> kam die Parodie An Alan Smithee Film Burn Hollywood Burn deutscher Titel
+Fahr zur Hölle Hollywood
+in die Kinos was das Pseudonym einem größeren Publikum bekannt machte nicht zuletzt weil Arthur Hiller der eigentliche Regisseur des Films selbst seinen Namen zurückzog und analog zum Filmtitel das Pseudonym Alan Smithee benutzte
+Der Film gilt als einer der schlechtesten Filme der <num>er Jahre und gewann fünf Goldene Himbeeren
+Der Film
+Supernova
+ist der erste Post-Smithee-Film dort führte ein gewisser Thomas Lee alias Walter Hill die Regie
+Verwendung
+Die Verwendung dieses oder eines anderen Pseudonyms ist für Mitglieder der DGA streng reglementiert
+Ein Regisseur der für einen von ihm gedrehten Film seinen Namen nicht hergeben möchte hat nach Sichtung des fertigen Films drei Tage Zeit anzuzeigen dass er ein Pseudonym verwenden möchte
+Der Rat der DGA entscheidet binnen zwei Tagen über das Anliegen
+Erhebt die Produktionsfirma Einspruch entscheidet ein Komitee aus Mitgliedern der DGA und der Vereinigung der Film- und Fernsehproduzenten ob der Regisseur ein Pseudonym angeben darf
+Über die Beantragung muss der Regisseur Stillschweigen halten ebenso darf er den fertigen Film nicht öffentlich kritisieren wenn die DGA ihm die Verwendung eines Pseudonyms zugesteht Ein Antrag des Regisseurs auf Pseudonymisierung kann abgelehnt werden so durfte Tony Kaye den Namen Smithee bei dem Film
+American History X
+nicht einsetzen obwohl er den Antrag stellte
+Auch bei nicht-US-amerikanischen Produktionen wird der Name verwendet wie etwa beim Pilotfilm der Fernsehserie
+Schulmädchen
+<num> sendete die ARD am <num> und <num> August den zweiteiligen TV-Film Paparazzo
+Auch in diesem Werk erscheint anstatt des eigentlichen Regisseurs Stephan Wagner Alan Smithee im Abspann
+Regisseure die das Pseudonym benutzt haben
+Don Siegel und Robert Totten für
+Frank Patch - Deine Stunden sind gezählt
+David Lynch für die dreistündige Fernsehfassung von
+Der Wüstenplanet
+Chris Christensen The Omega Imperative
+Gianni Bozzacchi für I Love NY
+Stuart Rosenberg für Lets Get Harry
+Richard C Sarafian für
+Starfire
+Dennis Hopper für
+Catchfire
+Arthur Hiller für
+Fahr zur Hölle Hollywood
+Rick Rosenthal Die Vögel II - Die Rückkehr
+Kevin Yagher
+Hellraiser IV - Bloodline
+Der Pilotfilm der Serie
+MacGyver
+und die fünfte Folge der ersten Staffel führen einen Alan Smithee als Regisseur
+Auf der TV-Serien-Seite TV Rage wird Jerrold Freedman als Regisseur des Pilotfilms angegeben
+Der Regisseur der fünften Folge ist unbekannt
+Zu den Drehbuchautoren die das Pseudonym benutzt haben gehören Sam Raimi und Ivan Raimi die das Drehbuch zu Die total beknackte Nuß als Alan Smithee Jr und Alan Smithee Sr schrieben
+Auch in Computerspielen wird dieses Pseudonym angegeben Im Abspann des Ego-Shooters Marine Sharpshooter IV aus dem Jahr <num> wird als Art Director des Spiels Alan Smithee genannt
+<num> produzierte die New Yorker Performance-Kompanie Big Dance Theater Alan Smithee Directed this Play das im August des Jahres auch in Berlin bei Tanz im August aufgeführt wurde
+Literatur
+Jeremy Braddock Stephen Hock Hrsg Directed by Allen Smithee Foreword by Andrew Sarris
+University of Minnesota Press Minneapolis London <num> ISBN <num>-<num>-<num>-X
+Weblinks
+Artikel über Smithee von ABC Online englisch Der Mann der niemals lebte Spiegel Online einestages Alan Smithee lebt DRadio Wissen
+Einzelnachweise
+latimescom
+zuletzt geprüft am <num> April <num> Eigener Eintrag für
+in der IMDb
+in der Internet Movie Database Siehe zu diesen Regelungen Artikel <num> Abschnitt <num>-<num> des
+PDF <num> kB der DGA von <num> abgerufen am <num> April <num> httpeinestagesspiegeldeexternalShowTopicAlbumBackgrounda<num>l<num>l<num>FhtmlfeaturedEntry Alan Smithee ist schuld in Frankfurter Allgemeine Sonntagszeitung vom <num> August <num> Seite <num>
+Actinium ist ein radioaktives chemisches Element mit dem Elementsymbol Ac und der Ordnungszahl <num> Im Periodensystem der Elemente steht es in der <num> IUPAC-Gruppe der Scandiumgruppe
+Das Element ist ein Metall und gehört zur <num> Periode d-Block
+Es ist der Namensgeber der Gruppe der Actinoide der ihm folgenden <num> Elemente
+Geschichte
+DateiPeriodensystem Mendelejewsjpg
+Das Actinium wurde im Jahr <num> von dem französischen Chemiker André-Louis Debierne entdeckt der es aus Pechblende isolierte und ihm zunächst Ähnlichkeiten mit dem Titan
+oder dem Thorium
+zuschrieb seine Bezeichnung leitete er wegen der Radioaktivität von griechisch ἀκτίς aktís Strahl ab Friedrich Giesel entdeckte das Element unabhängig davon im Jahr <num> und beschrieb eine Ähnlichkeit zum Lanthan er gab ihm den Namen Emanium eine Bildung zu lateinisch emano ausfließen ebenfalls mit Bezug zur abgegebenen Strahlung Nachdem Actinium und Emanium im Jahre <num> als identisch erkannt worden waren wurde Debiernes Namensgebung der Vorzug gegeben da er es zuerst entdeckt hatte
+Die Geschichte der Entdeckung wurde in Publikationen von <num> und später im Jahr <num> immer noch als fraglich beschrieben
+Sie zeigen dass die Publikationen von <num> einerseits und die von <num> und <num> andererseits Widersprüche aufweisen
+Gewinnung und Darstellung
+Da in Uranerzen nur wenig Actinium vorhanden ist spielt diese Quelle keine Rolle für die Gewinnung
+Technisch wird das Isotop <num>Ac durch Bestrahlung von <num>Ra mit Neutronen in Kernreaktoren hergestellt
+Die Zeitangaben sind Halbwertszeiten
+Durch den schnellen Zerfall des Actiniums waren stets nur geringe Mengen verfügbar
+Die erste künstliche Herstellung von Actinium wurde im Argonne National Laboratory in Chicago durchgeführt
+Eigenschaften
+Physikalische Eigenschaften
+Das Metall ist silberweiß glänzend und relativ weich Aufgrund seiner starken Radioaktivität leuchtet Actinium im Dunkeln in einem hellblauen Licht
+Actinium ist das namensgebende Element der Actinoiden ähnlich wie Lanthan für die Lanthanoiden
+Die Gruppe der Elemente zeigt deutlichere Unterschiede als die Lanthanoide daher dauerte es bis <num> bis Glenn T Seaborg die wichtigsten Änderungen zum Periodensystem von Mendelejew vorschlagen konnte die Einführung der Actinoide
+Chemische Eigenschaften
+Es ist sehr reaktionsfähig und wird von Luft und Wasser angegriffen überzieht sich aber mit einer Schicht von Actiniumoxid wodurch es vor weiterer Oxidation geschützt ist Das Ac<num>-Ion ist farblos
+Das chemische Verhalten von Actinium ähnelt sehr dem Lanthan
+Actinium ist in allen zehn bekannten Verbindungen dreiwertig
+Isotope
+Bekannt sind <num> Isotope wovon nur zwei natürlich vorkommen
+Das langlebigste Isotop <num>Ac Halbwertszeit <num> Jahre hat zwei Zerfallskanäle es ist ein Alpha- und Beta-Strahler
+<num>Ac ist ein Zerfallsprodukt des Uranisotops <num>U und kommt zu einem kleinen Teil in Uranerzen vor
+Daraus lassen sich wägbare Mengen <num>Ac gewinnen die somit ein verhältnismäßig einfaches Studium dieses Elementes ermöglichen
+Da sich unter den radioaktiven Zerfallsprodukten einige Gammastrahler befinden sind aber aufwändige Strahlenschutzvorkehrungen nötig
+Verwendung
+Actinium wird zur Erzeugung von Neutronen eingesetzt die bei Aktivierungsanalysen eine Rolle spielen
+Außerdem wird es für die thermoionische Energieumwandlung genutzt
+Beim dualen Zerfall des <num>Ac geht der größte Teil unter Emission von Beta-Teilchen in das Thorium isotop <num>Th aber ca <num>
+zerfällt durch Alpha-Emission zu Francium <num>Fr
+Eine Lösung von <num>Ac ist daher als Quelle für das kurzlebige <num>Fr verwendbar
+Letzteres kann dann regelmäßig abgetrennt und untersucht werden
+Sicherheitshinweise
+Einstufungen nach der CLP-Verordnung liegen nicht vor weil diese nur die chemische Gefährlichkeit umfassen und eine völlig untergeordnete Rolle gegenüber den auf der Radioaktivität beruhenden Gefahren spielen
+Auch Letzteres gilt nur wenn es sich um eine dafür relevante Stoffmenge handelt
+Verbindungen
+Nur eine geringe Anzahl von Actiniumverbindungen ist bekannt
+Mit Ausnahme von AcPO<num> sind sie alle den entsprechenden Lanthanverbindungen ähnlich und enthalten Actinium in der Oxidationsstufe <num> Insbesondere unterscheiden sich die Gitterkonstanten der jeweiligen Lanthan- und Actinium-Verbindungen nur in wenigen Prozent
+Oxide
+ActiniumIII-oxid Ac<num>O<num> kann durch Erhitzen des Hydroxids bei <num> C oder des Oxalats bei <num> C im Vakuum erhalten werden
+Das Kristallgitter ist isotyp mit den Oxiden der meisten dreiwertigen Seltenerdmetalle
+Halogenide
+ActiniumIII-fluorid AcF<num> kann entweder in Lösung oder durch Feststoffreaktion dargestellt werden
+Im ersten Fall gibt man bei Raumtemperatur Flusssäure zu einer Ac<num>-Lösung und fällt das Produkt aus
+im anderen Fall wird Actinium-Metall mit Fluorwasserstoff bei <num> C in einer Platinapparatur behandelt
+ActiniumIII-chlorid AcCl<num> wird durch Umsetzung von Actiniumhydroxid oder -oxalat mit Tetrachlormethan bei Temperaturen oberhalb von <num> C erhalten
+Die Reaktion von Aluminiumbromid und ActiniumIII-oxid führt zum ActiniumIII-bromid AcBr<num> und Behandlung mit feuchtem Ammoniak bei <num> C führt zum Oxibromid AcOBr
+Weitere Verbindungen
+Gibt man Natriumdihydrogenphosphat NaH<num>PO<num> zu einer Lösung von Actinium in Salzsäure erhält man weiß gefärbtes Actiniumphosphat AcPO<num>
+<num> H<num>O ein Erhitzen von ActiniumIII-oxalat mit Schwefelwasserstoff bei <num> C für ein paar Minuten führt zu schwarzem ActiniumIII-sulfid Ac<num>S<num>
+Literatur
+Harold W Kirby Lester R Morss Actinium in Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements Springer Dordrecht <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> doi<num><num>-<num>-<num>-<num>_<num>
+Weblinks
+Einzelnachweise André-Louis Debierne Sur une nouvelle matière radio-active in
+Comptes rendus
+<num> <num> S <num>-<num> André-Louis Debierne Sur un nouvel élément radio-actif
+lactinium in
+Comptes rendus
+<num> <num> S <num>-<num>
+N A Figurowski Die Entdeckung der chemischen Elemente und der Ursprung ihrer Namen in deutscher Übersetzung von Leo KorniljewErnst Lemke Moskau <num> ISBN <num>-<num>-<num>-<num> S <num>Friedrich Oskar Giesel Ueber Radium und radioactive Stoffe in
+Berichte der Deutschen Chemischen Gesellschaft
+<num> <num> <num> S <num>-<num> doi<num>cber<num>Friedrich Oskar Giesel Ueber den Emanationskörper Emanium in
+Berichte der Deutschen Chemischen Gesellschaft
+<num> <num> <num> S <num>-<num> doi<num>cber<num>Friedrich Oskar Giesel Ueber Emanium in
+Berichte der Deutschen Chemischen Gesellschaft
+<num> <num> <num> S <num>-<num> doi<num>cber<num>H W Kirby The Discovery of Actinium in
+Isis
+<num> <num> <num> S <num>-<num> J P Adloff The centenary of a controversial discovery actinium in Radiochim Acta
+<num> <num> S <num> doi<num>ract<num><num>-<num> Frederick Seitz David Turnbull Solid state physics advances in research and applications Academic Press <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> Glenn T Seaborg The Transuranium Elements in
+Science
+<num> <num> Nr <num> S <num>-<num> doi<num>science<num><num> PMID <num>Joseph G Stites Murrell L Salutsky Bob D Stone Preparation of Actinium Metal in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num>J J Katz W M Manning Chemistry of the Actinide Elements in
+Annual Review of Nuclear Science
+<num> <num> S <num>-<num> doi<num>annurevns<num><num>Sherman Fried French Hagemann W H Zachariasen The Preparation and Identification of Some Pure Actinium Compounds in
+J Am Chem Soc
+<num> <num> S <num>-<num> doi<num>ja<num>a<num>
+DateiAng Lee - <num>eme Festival de Venise Mostra <num>jpg Ang Lee
+<num> Oktober <num> in Chaozhou Landkreis Pingtung Taiwan ist ein taiwanisch-US-amerikanischer Filmregisseur Drehbuchautor und Produzent
+Er ist als vielfach ausgezeichneter Regisseur bekannt für so unterschiedliche Filme wie
+Eat Drink Man Woman
+die Jane-Austen-Adaption
+Sinn und Sinnlichkeit
+und den Martial Arts-Film
+Tiger and Dragon
+Für seine Filme
+Brokeback Mountain
+<num> und
+Life of Pi Schiffbruch mit Tiger
+<num> wurde er jeweils mit dem Oscar in der Kategorie Beste Regie ausgezeichnet
+Leben
+Ang Lee wurde <num> in Taiwan geboren
+Seine Eltern Emigranten aus China lernten sich in Taiwan kennen Lee ist ihr ältester Sohn
+Die Großeltern väterlicher- und mütterlicherseits sind im Zuge der kommunistischen Revolution in China ums Leben gekommen
+Da sein Vater als Lehrer häufiger die Arbeitsstelle wechselte wuchs Ang Lee in verschiedenen Städten Taiwans auf
+Entgegen den Wünschen seiner Eltern wie sein Vater eine klassische akademische Laufbahn einzuschlagen interessierte sich Lee für das Schauspiel und absolvierte mit ihrem Einverständnis zunächst ein Theater- und Filmstudium in Taipeh
+Im Anschluss daran ging er <num> in die USA um an der Universität von Illinois in Urbana-Champaign Theaterwissenschaft und -regie zu studieren
+Nach dem Erwerb seines BA in Illinois verlegte er sich ganz auf das Studium der Film- und Theaterproduktion an der Universität von New York das er <num> mit einem Master abschloss
+Danach entschloss er sich mit seiner ebenfalls aus Taiwan stammenden Ehefrau zusammen in den USA zu bleiben
+Sein Interesse verschob sich trotz erster Erfahrungen mit dem Super-<num>-Film in Taiwan erst spät ganz auf Filmregie und -produktion - auch weil Lee seinen Berufswunsch seiner Familie und insbesondere seinem Vater gegenüber lange Zeit nicht eingestehen wollte Nach dem Studium konnte er zunächst keine eigenen Projekte umsetzen
+Erst ab <num> als er seinen ersten Langfilm fertigstellte zeichnete sich eine kontinuierliche Karriere als Regisseur ab
+Als seine bisher größte Erfolge - sowohl beim Publikum als auch bei der Kritik - gelten das Martial Arts-Drama
+Tiger and Dragon
+mit einer pan-asiatischen Starbesetzung und der Post-Western-Liebesfilm
+Brokeback Mountain
+mit Heath Ledger und Jake Gyllenhaal
+Für Letzteren bekam Lee <num> als erster asiatisch-stämmiger und nicht-weißer Regisseur den Oscar für die beste Regie
+Außerdem wurden Lees Filme neben vielen weiteren Preisen mit mittlerweile zwei Goldenen Bären der Berlinale und zwei Goldenen Löwen der Filmfestspiele von Venedig ausgezeichnet
+Lee ist seit <num> mit der Mikrobiologin Jane Lin verheiratet
+Sie leben in White Plains Westchester County im Bundesstaat New York
+Aus der Ehe stammen die Söhne Haan
+<num> und Mason
+<num>
+Ang Lee besitzt die US-amerikanische Staatsbürgerschaft
+Filmisches Werk
+Nach seinen ersten Filmerfahrungen in Taiwan setzte sich Lee erst wieder während seines Studiums in den USA ernsthaft mit dem Filmemachen auseinander
+Im Rahmen seines Studiums in New York drehte er einige Kurzfilme und wirkte unter anderem beim Abschlussdreh seines Studienkollegen Spike Lee als Regieassistent mit
+Sein eigener Abschlussfilm Fine Line gewann <num> zwei Preise beim renommierten Filmfest seiner Universität Erst <num> gelang es ihm nach dem Gewinn eines hochdotierten Drehbuchwettbewerbs in Taiwan den ersten einer Reihe von drei Filmen zu drehen die west-östliche Konflikte taiwanischer Familien zum Thema haben
+<num>-<num> Die Father-Knows-Best-Trilogie
+Diese ersten drei Langfilme die Lee realisieren konnte werden im Allgemeinen unter dem Begriff Father Knows Best gefasst Diese Bezeichnung geht auf die wiederkehrende Figur des chinesischen Familienoberhaupts gespielt jeweils vom taiwanischen Schauspieler Sihung Lung zurück
+Die drei Filme thematisieren wie später noch öfter bei Ang Lee familiäre Probleme die aus dem Konflikt zwischen Selbstbestimmung und Tradition zwischen Innen und Außen zwischen Ost und West sowie zwischen den Generationen herrühren
+Die Filme sind allesamt US-amerikanisch-taiwanische Koproduktionen
+Anders als bei allen bislang folgenden Projekten handelt es sich bei den ersten Filmen Lees nicht um Adaptionen sondern um Filme nach von ihm selbst geschriebenen Originaldrehbüchern
+Der erste Film
+Schiebende Hände
+<num> handelt vom Einzug eines chinesischen Vaters bei seinem erwachsenen Sohn und der US-amerikanischen Schwiegertochter in New York und den interkulturellen Problemen die in der neuen Wohngemeinschaft entstehen
+Dies war die erste Zusammenarbeit zwischen Lee und dem Drehbuchautor und Produzenten James Schamus - seitdem bildeten die beiden bei jedem Film Lees eine enge Arbeitsgemeinschaft
+Wie in den beiden folgenden Filmen schrieben sie auch gemeinsam das Drehbuch In allen weiteren Filmen Lees mit Ausnahme des Kurzfilms
+The Hire Chosen
+hat Schamus seither entscheidende Funktionen ausgeübt
+Auch die regelmäßige Zusammenarbeit mit dem Filmeditor Tim Squyres nahm in Lees Erstling ihren Anfang
+Mit Ausnahme des Erfolgsfilms Brokeback Mountain von <num> hat Squires jeden Film den Ang Lee gedreht hat geschnitten
+Nach dem Erfolg seines Erstlings konnte Lee als Nächstes
+Das Hochzeitsbankett
+<num> drehen eine Komödie über die fingierte Eheschließung eines homosexuellen Exil-Taiwaners in den USA
+Erneut taucht hier die Figur des strengen aber weisen Familienoberhaupts auf
+Hatte Schiebende Hände zunächst vor allem in Taiwan für Aufmerksamkeit und Preise gesorgt wurde mit dem zweiten Langfilm Lees auch Europa auf den aufstrebenden Regisseur aufmerksam Der Film erhielt bei der Berlinale <num> den Goldenen Bären als Bester fremdsprachiger Film und war zudem für einen Oscar nominiert
+Er gilt darüber hinaus als einer der profitabelsten Low-Budget-Filme des Jahres <num>
+Mit nur einer Million US-Dollar Produktionskosten erzielte er ein Einspielergebnis von über <num> Millionen US-Dollar
+Sihung Lung ist auch im letzten Teil der Trilogie
+Eat Drink Man Woman
+<num> die kongeniale Verkörperung des chinesischen Familienoberhaupts das Zentrum dieser Maskeraden in denen es darum geht ein altes Gesicht zu wahren und dann zu lernen es zu verlieren um ein neues lebenstauglicheres zu gewinnen Dieses Mal ist er der verwitwete Vater dreier Töchter die ihr Leben und ihre Lieben auf unterschiedliche Art angehen und dabei ebenfalls innerfamiliäre Konflikte klären müssen
+Eat Drink Man Woman wurde anders als seine Vorgänger in Taipeh gedreht
+Im Mittelpunkt des Films stehen der Titel deutet es an die Liebe und das Essen
+Ang Lee privat ein passionierter Koch legte hierbei besonders großen Wert auf die kulinarische Komponente als Stilmittel und konzipierte die Hauptfigur des älteren Witwers als berühmten Koch
+<num>-<num> Dreimal anglo-amerikanische Geschichte
+Mit dem Angebot der Produzentin Lindsay Doran die von der britischen Schauspielerin Emma Thompson verfasste Adaption des Romans
+Verstand und Gefühl
+von Jane Austen in Großbritannien zu drehen eröffnete sich Lee eine lange ersehnte neue Perspektive jenseits asiatisch geprägter Stoffe
+In einer neuen Trilogie setzt er sich mit unterschiedlichen Kulturen auseinander
+Sinn und Sinnlichkeit
+ist die Verfilmung des Romans der englischen Schriftstellerin Jane Austen
+Der Eissturm
+spielt in den USA der <num>er Jahre
+Ride with the Devil
+ist im Amerikanischen Bürgerkrieg angesiedelt
+<num>-heute Pendeln zwischen West und Ost
+Tiger and Dragon
+sowie
+Hulk
+sind sehr unterschiedliche Action-Filme
+Mit Tiger and Dragon gewann Lee zwei Golden Globes
+Das Werk wurde außerdem mit vier Academy Awards Oscars prämiert darunter der Trophäe für den besten fremdsprachigen Film
+Für diesen Film wurde er <num> auch mit einem Chlotrudis Award ausgezeichnet seinen zweiten Chlotrudis erhielt er <num> für Brokeback Mountain
+Für
+Brokeback Mountain
+wurde Lee mit einer Vielzahl von Filmpreisen geehrt darunter der Oscar für die beste Regie der Goldene Löwe der Filmfestspiele von Venedig sowie die Auszeichnung der Hollywood Foreign Press Association als bester Regisseur des Jahres
+<num> verfilmte er mit
+Gefahr und Begierde
+eine Kurzgeschichte von Eileen Chang
+Der Thriller spielt zur Zeit des Zweiten Weltkriegs in Shanghai und handelt von einer jungen chinesischen Agentin gespielt von Tang Wei die beauftragt wird einen hochrangigen Verräter Tony Leung Chiu Wai zu liquidieren
+Lees erste chinesischsprachige Spielfilmproduktion seit Tiger and Dragon war <num> im offiziellen Wettbewerb der <num> Filmfestspiele von Venedig vertreten und brachte ihm erneut den Goldenen Löwen ein
+Im selben Jahr wurde Gefahr und Begierde als offizieller taiwanischer Beitrag für die Nominierung um den besten fremdsprachigen Film bei der Oscar-Verleihung <num> ausgewählt später aber auf Empfehlung der Academy of Motion Picture Arts and Sciences wieder zurückgezogen und durch Chen Huai-Ens Lian xi qu
+ersetzt
+Ende Februar <num> wurde bekannt gegeben dass Lee die Jury der <num> Filmfestspiele von Venedig leiten werde Zwei Monate später erhielt er für seine Komödie Taking Woodstock eine Einladung in den Wettbewerb der <num> Internationalen Filmfestspiele von Cannes
+<num> wurde er in die Wettbewerbsjury des <num> Filmfestivals von Cannes berufen
+Stil
+Ang Lee ist ein international anerkannter und erfolgreicher Regisseur und gilt als einer der vielseitigsten Filmemacher der letzten Jahre
+Häufig behandelt Lee in seinen Filmen das Thema Familie auf eine Art und Weise die autobiographische Züge seines eigenen Lebens trägt
+Er lässt seine Umgebung ganz bewusst auf sich einwirken und bringt diese in seine Filme ein
+Kennzeichnend für die meisten seiner Filme ist eine wenig geradlinige Erzählstruktur die die Charaktere und die Geschichte aus verschiedenen Blickwinkeln darstellt
+Er verknüpft die Konflikte des menschlichen Lebens mit traditionellen und innovativen Stilelementen
+Für Ang Lee sind die klassisch-soliden Erzählstrukturen zu langweilig daher kombiniert er verschiedene Genres und Epochen
+Er selbst sagte einmal
+Filmografie
+DateiAng Lee <num>ème Festival de Venise Mostrajpg
+<num> Schiebende Hände Pushing Hands Tui shou
+<num> Das Hochzeitsbankett The Wedding Banquet Xi yan
+<num> Eat Drink Man Woman Yin shi nan nu
+<num> Sinn und Sinnlichkeit Sense and Sensibility
+<num> Der Eissturm The Icestorm
+<num> Wer mit dem Teufel reitet Ride with the Devil
+<num> Tiger and Dragon auch Crouching Tiger Hidden Dragon Wo hu cang long
+<num> The Hire Chosen Kurzwerbefilm für eine Automarke
+<num> Hulk
+<num> Brokeback Mountain
+<num> Gefahr und Begierde Sè jiè
+<num> Taking Woodstock
+<num> Life of Pi Schiffbruch mit Tiger
+<num> Die irre Heldentour des Billy Lynn Billy Lynns Long Halftime Walk
+<num> Gemini Man
+Auszeichnungen Auswahl
+Oscarverleihung
+<num> Auszeichnung in der Kategorie Bester fremdsprachiger Film für Tiger
+Dragon
+<num> Nominierung in der Kategorie
+Beste Regie
+für Tiger
+Dragon
+<num> Nominierung in der Kategorie
+Bester Film
+für Tiger
+Dragon
+<num> Auszeichnung in der Kategorie
+Beste Regie
+für Brokeback Mountain
+<num> Auszeichnung in der Kategorie
+Beste Regie
+für Life of Pi Schiffbruch mit Tiger
+<num> Nominierung in der Kategorie
+Bester Film
+für Life of Pi Schiffbruch mit Tiger
+Golden Globe Award
+<num> Nominierung in der Kategorie
+Beste Regie
+für Sinn und Sinnlichkeit
+<num> Auszeichnung in der Kategorie
+Beste Regie
+für Tiger
+Dragon
+<num> Auszeichnung in der Kategorie
+Beste Regie
+für Brokeback Mountain
+<num> Nominierung in der Kategorie
+Beste Regie
+für Life of Pi Schiffbruch mit Tiger
+Directors Guild of America Award
+<num> Nominierung in der Kategorie Beste Spielfilmregie für Sinn und Sinnlichkeit
+<num> Auszeichnung in der Kategorie Beste Spielfilmregie für Tiger
+Dragon
+<num> Auszeichnung in der Kategorie Beste Spielfilmregie für Brokeback Mountain
+<num> Nominierung in der Kategorie Beste Spielfilmregie für Life of Pi Schiffbruch mit Tiger
+Weitere Auszeichnungen
+<num> Goldener Bär der Berliner Filmfestspiele für Das Hochzeitsbankett
+<num> Golden Horse Beste Regie für Das Hochzeitsbankett
+<num> Goldener Bär der Berliner Filmfestspiele für Sinn und Sinnlichkeit
+<num> Bundesfilmpreis für den besten ausländischen Film mit Sinn und Sinnlichkeit
+<num> Golden Horse Bester Film für Tiger and Dragon
+<num> Hong Kong Film Award für Tiger and Dragon
+<num> Aufnahme in die American Academy of Arts and Sciences
+<num> Goldener Löwe des Filmfestivals in Venedig für Brokeback Mountain
+<num> Golden Horse Beste Regie für Gefahr und Begierde
+<num> Goldener Löwe des Filmfestivals in Venedig für Gefahr und Begierde
+Siehe auch
+Taiwanischer Film
+US-amerikanischer Film
+Literatur
+Tanja Hanhart Redaktorin Ang Lee und sein Kino
+Poesie im Grossformat
+In du <num> Feb
+<num> ISBN <num>-<num>-<num>-<num>-<num>
+Thomas Koebner Artikel Ang Lee In Ders
+Hrsg Filmregisseure
+Biographien Werkbeschreibungen Filmographien
+Mit <num> Abbildungen
+<num> aktualisierte und erweiterte Auflage
+Reclam Stuttgart <num> <num> Aufl <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
+Qin Hu Das Kino von Ang Lee - Von der chinesischen Philosophie Kunstauffassung und Kultur zu filmästhetischen Aspekten Gardez
+Verlag <num>
+Michael Pekler Andreas Ungerböck Ang Lee und seine Filme Schüren Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Isabell Gössele Das Kino des Ang Lee - Im Atem des verborgenen Drachen Tectum Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Weblinks
+Biografie auf film-zeitde
+Ang Lee Biografie bei WHOS WHO
+In
+Spiegel Online
+<num> Oktober <num> Interview
+Der Subtext des Western Interview auf criticde
+Ralph Geisenhanslüke
+In Zeit <num> Januar <num> Interview
+Andreas Kilb
+In FAZ <num> Oktober <num>
+Einzelnachweise
+Michael Pekler Andreas Ungerböck Ang Lee und seine Filme Schüren Marburg <num> Christoph Schneider Chronik von Leben und Werk In Ang Lee und sein Kino Poesie im Grossformat In du <num> Feb <num> S <num>-<num> Michael Pekler und Andreas Ungerböck merken dazu ironisch an dass man die Trilogie besser mit Father Thinks He Knows Best titulieren könne da die Patriarchen keineswegs für alles eine Lösung haben vgl Michael Pekler Andreas Ungerböck Ang Lee und seine Filme Schüren Marburg <num> S <num> Für Das Hochzeitsbankett zeichnete zusätzlich Neil Peng für Eat Drink Man Woman Hui-Ling Wang verantwortlich Isabell Gössele Das Kino des Ang Lee - Im Atem des verborgenen Drachen Tectum Marburg <num> S <num>Pekler Ungerböck <num> S <num> Christoph Schneider Chronik von Leben und Werk In Ang Lee und sein Kino Poesie im Grossformat In du <num> Feb <num> S <num>Pekler Ungerböck <num> S <num> f Douglas Tseng Shorter version of Lust to be shown here In The Straits Times Singapore <num> September <num> LIFE - LIFE BUZZ
+In
+fr-online
+<num> Februar <num> abgerufen am <num> Juni <num> Schiffbruch mit Zuschauer in
+FAZ
+<num> Dezember <num> S <num>
+Anschluss ist in der Soziologie ein Fachbegriff aus der Systemtheorie von Niklas Luhmann und bezeichnet die in einer sozialen Begegnung auf eine Selektion der anderen Seite folgende selbst gewählte Selektion
+Diese Selektionen beziehen sich aufeinander
+Die Anschlussfähigkeit ist die Kapazität von Systemen zu gewährleisten dass sich an die Selektionen eines Systems weitere anschließen können
+Alle sozialen Systeme reproduzieren sich über Kommunikation z B
+Wirtschaftssystem oder Politik oder Handlungen Medizin und Erziehungssystem
+Dies gelingt nur wenn die einzelnen Einheiten aneinander anschlussfähig sind was durch einen systemspezifischen Code geleistet wird der als zentrale Logik Leitunterscheidung aller Kommunikation zugrunde liegt und sie als systemzugehörig erkennbar macht
+Im Wirtschaftssystem beispielsweise sorgt der Code zahlennicht zahlen dafür dass die Kommunikationen sich auf sich selbst beziehen und sich selbst reproduzieren können also dass auf jede Zahlung eine neue erfolgt
+Dies funktioniert über das generalisierte Kommunikationsmedium Geld das die letzte Zahlung mit der jetzigen verknüpft
+Würde das Geld nicht mehr akzeptiert folgt der Zahlung keine weitere Zahlung mehr und das System hätte seine Anschlussfähigkeit verloren
+Die Anschlussfähigkeit innerhalb eines Systems wird als Selbstreferenz bezeichnet im Gegensatz zum fremdreferentiellen Bezug auf die Umwelt Welt andere Systeme
+Den Begriff hat Luhmann auf eine Anregung eines Bielefelder Kollegen des Philosophen Jürgen Frese entwickelt
+Frese zeigte in einem Sektionsreferat des Achten Deutschen Kongresses für Philosophie in Heidelberg <num> gedruckt <num> mit dem Titel Sprechen als Metapher für Handeln dass es fruchtbar ist von den dominanten Handlungsmodellen Arbeit und Konsum abzurücken und ergänzend Sprechen als Modell für Handeln zu nutzen
+Frese schreibt Die wichtigste Errungenschaft die die Sprachmetapher für die Aufhellung des nicht-sprachlichen Handelns einbringt ist ihre Leistung Reihenbildung erklärbar zu machen
+Fassen wir Satz und Handlung zum neutralen und an andere Philosopheme anschließbaren Begriff des Aktes zusammen so können wir
+sagen Der Sinn eines Aktes ist das als eine bestimmte Situation gegebene Ensemble der Möglichkeiten an diesen Akt weitere Akte anzuschließen d h
+der Sinn eines Aktes ist die Mannigfaltigkeit der Anschließbarkeiten die er eröffnet Diese Idee wurde von Luhmann aufgegriffen und im Rahmen seiner Systemtheorie weiterentwickelt
+Frese selbst baute sie im Rahmen seiner Lehre von den Formularen weiter aus
+Literatur
+Niklas Luhmann Soziale Systeme
+Grundriß einer allgemeinen Theorie
+Suhrkamp Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num>
+Jürgen Frese
+Sprechen als Metapher für Handeln In Hans-Georg Gadamer Das Problem der Sprache
+Achter Deutscher Kongress für Philosophie
+Heidelberg <num> Fink Verlag München <num> S <num>-<num>
+Jürgen Frese Prozesse im Handlungsfeld Klaus Boer Verlag München <num> ISBN <num>-<num>-<num>-<num>
+Einzelnachweise Frese <num> S <num>fFrese <num>
+Die Aussagenlogik ist ein Teilgebiet der Logik das sich mit Aussagen und deren Verknüpfung durch Junktoren befasst ausgehend von strukturlosen Elementaraussagen Atomen denen ein Wahrheitswert zugeordnet wird
+In der klassischen Aussagenlogik wird jeder Aussage genau einer der zwei Wahrheitswerte wahr und falsch zugeordnet
+Der Wahrheitswert einer zusammengesetzten Aussage lässt sich ohne zusätzliche Informationen aus den Wahrheitswerten ihrer Teilaussagen bestimmen
+Geschichte
+Historisch geht die Aussagenlogik zurück bis zu Aristoteles der erstmals aussagenlogische Grundsätze diskutierte nämlich in seiner Metaphysik den Satz vom Widerspruch und den Satz vom ausgeschlossenen Dritten und der in seiner ersten Analytik den indirekten Beweis thematisierte
+Die zweiwertige aussagenlogische Semantik entwickelten etwas später die megarischen Philosophen Diodoros Kronos und Philon
+Die Aussagensemantik und -axiomatik kombinierte der Stoiker Chrysippos von Soli der den ersten aussagenlogischen Kalkül formulierte
+Die Weiterentwicklung der Aussagenlogik der Stoa durch das Mittelalter wird oft übersehen Eine erste vollständige und entscheidbare Formalisierung für aussagenlogische Tautologien - allerdings noch nicht für das aussagenlogische Schließen - schuf George Boole <num> mit seinem algebraischen Logikkalkül
+Den ersten aussagenlogischen Kalkül mit Schlussregeln formulierte Gottlob Frege im Rahmen seiner Begriffsschrift <num>
+Er war die Vorlage für den Aussagenkalkül von Bertrand Russell <num> der sich später durchsetzte s u
+Abgrenzung zu anderen Logiken
+Da in der heutigen Mathematik die klassische Aussagenlogik maßgeblich wurde wird in diesem Artikel dieser moderne Haupttypus der Aussagenlogik behandelt
+Allgemein ist die klassische Logik durch zwei Eigenschaften charakterisiert
+Jede Aussage hat einen von genau zwei Wahrheitswerten meist falsch oder wahr Prinzip der Zweiwertigkeit oder Bivalenzprinzip
+Der Wahrheitswert jeder zusammengesetzten Aussage ist eindeutig durch die Wahrheitswerte ihrer Teilaussagen bestimmt Prinzip der Extensionalität oder Kompositionalität siehe Extensionalitätsprinzip
+Das Prinzip der Zweiwertigkeit wird oft mit dem Satz vom ausgeschlossenen Dritten verwechselt
+Die klassische Aussagenlogik ist jenes Gebiet der klassischen Logik das die innere Struktur von Sätzen Aussagen daraufhin untersucht aus welchen anderen Sätzen Teilsätzen sie zusammengesetzt sind und wie diese Teilsätze miteinander verknüpft sind
+Die innere Struktur von Sätzen die ihrerseits nicht in weitere Teilsätze zerlegt werden können wird von der Aussagenlogik nicht betrachtet
+Ein Beispiel Die Aussage Alle Katzen sind Hunde und die Erde ist eine Scheibe ist mit dem Bindewort und aus den beiden kürzeren Aussagen Alle Katzen sind Hunde und Die Erde ist eine Scheibe zusammengesetzt
+Diese beiden Aussagen lassen sich ihrerseits nicht mehr in weitere Aussagen zerlegen sind aus aussagenlogischer Sicht also elementar oder atomar
+Andere auf die Aussagenlogik aufbauende logische Systeme betrachten die innere Struktur solcher atomaren Aussagen ein wichtiges Beispiel ist die Prädikatenlogik
+In Abgrenzung zur klassischen Logik entstehen nichtklassische Logiksysteme wenn man das Prinzip der Zweiwertigkeit das Prinzip der Extensionalität oder sogar beide Prinzipien aufhebt
+Nichtklassische Logiken die durch die Aufhebung des Prinzips der Zweiwertigkeit entstehen heißen mehrwertige Logik
+Die Zahl der Wahrheitswerte in diesem Falle üblicher Pseudowahrheitswerte kann dabei endlich sein z B
+dreiwertige Logik ist aber oft auch unendlich z B
+Fuzzy-Logik
+Hingegen verwenden Logiken die durch die Aufhebung der Extensionalität entstehen Junktoren Konnektive bei denen sich der Wahrheitswert des zusammengesetzten Satzes nicht mehr eindeutig aus dem Wahrheitswert seiner Teile bestimmen lässt
+Ein Beispiel für nichtextensionale Logik ist die Modallogik die die einstelligen nichtextensionalen Operatoren es ist notwendig dass und es ist möglich dass einführt
+Logische Systeme stehen innerhalb der Logik nicht in einem Konkurrenzverhältnis um Wahrheit oder Richtigkeit
+Die Frage welches logische System für einen bestimmten Zweck genutzt werden soll ist eher eine pragmatische
+Oft werden logische Systeme und logische Fragestellungen mit außerlogischen Fragen verwechselt oder vermischt z B
+mit der metaphysischen Frage welches logische System richtig sei d h
+die Wirklichkeit beschreibe
+Zu dieser Frage gibt es unterschiedliche Standpunkte einschließlich des positivistischen Standpunkts dass diese Frage sinnlos sei
+Diese Fragen fallen aber in andere Gebiete z B
+Philosophie Wissenschaftstheorie und Sprachwissenschaft
+Wenn in diesem Artikel die klassische Aussagenlogik behandelt wird so ist das also nicht als metaphysische Festlegung zu verstehen oder gar als Behauptung dass alle Aussagen wahr oder falsch sind Es ist lediglich so dass die klassische Aussagenlogik einfach nur solche Aussagen behandelt die wahr oder falsch sind
+Das ist eine große formale Vereinfachung die dieses System relativ leicht erlernbar sein lässt
+Braucht man aus metaphysischen oder pragmatischen Gründen mehr als zwei Wahrheitswerte kann die klassische Aussagenlogik als Ausgangspunkt dienen um ein geeignetes logisches System aufzustellen
+Umgangssprachliche Einleitung
+Einfache Aussage Elementaraussage
+Eine Aussage A ist ein Satz der entweder wahr w wahr true <num> oder nicht wahr f falsch false <num> ist
+Das gilt sowohl für einfache als auch für verknüpfte Aussagen
+Halbwahrheiten gibt es nicht
+Eine Aussage kann sowohl der gewöhnlichen Sprache entstammen als auch der Sprache der Mathematik
+Eine Elementaraussage ist eine Aussage die keine aussagenlogischen Verknüpfungen nicht und oder wenn
+dann genau dann wenn enthält
+Beispiele für Elementaraussagen
+München ist <num> km von Hamburg entfernt
+<num> ist durch <num> teilbar
+Eintracht Frankfurt wird in der nächsten Saison deutscher Fußballmeister
+Alle Autos sind grün
+ist offensichtlich wahr
+dagegen ist falsch
+muss man zunächst prüfen bevor man entscheiden kann ob
+wahr oder falsch ist
+Ob
+wahr ist kann man derzeit nicht entscheiden
+Das wird sich erst am Ende der nächsten Fußballsaison herausstellen
+In der klassischen Aussagenlogik ist eine Aussage entweder wahr oder nicht wahr auch wenn man den Wahrheitsgehalt nicht kennt
+Das ist zum Beispiel bei den ungelösten mathematischen Problemen der Fall
+Anmerkung
+ist eine All-Aussage die Struktur solcher Aussagen ist Gegenstand der Prädikatenlogik
+Im Sinne der Aussagenlogik ist es eine Elementaraussage
+Verneinte Aussage - Negation
+Die Verneinung bzw Negation auch Satzverneinung äußere Verneinung kontradiktorisches Gegenteil einer Aussage A ist diejenige Aussage A die genau dann wahr ist wenn A falsch ist und die genau dann falsch ist wenn A wahr ist
+Einfacher Die Verneinung einer Aussage A dreht den Wahrheitswert von A in sein Gegenteil um
+Man erhält die Verneinung einer Aussage A immer dadurch dass man ihr die Formulierung Es ist nicht der Fall dass voranstellt
+Zwar lässt sich ein natürlichsprachlicher Satz auch verneinen indem man das Wort nicht oder eine andere negative Formulierung an geeigneter Stelle einfügt - es ist aber nicht immer ganz einfach zu erkennen welche Formulierung zu verwenden und an welcher Stelle einzufügen ist
+Formal schreibt man für nicht A in der gebräuchlichsten Notation Schreibweise A auf Englisch und in der Schaltalgebra auch NOT A gelegentlich auch A
+Wir verneinen die obigen Beispiele
+Es ist nicht der Fall dass München <num> km von Hamburg entfernt ist
+Es ist nicht der Fall dass <num> durch <num> teilbar ist
+Es ist nicht der Fall dass Eintracht Frankfurt in der nächsten Saison deutscher Fußballmeister wird
+Es ist nicht der Fall dass alle Autos grün sind
+Es kann durchaus auch grüne Autos geben aber es gibt mindestens ein Auto das nicht grün ist
+Allgemein gilt für die Verneinung
+Wenn eine Aussage
+wahr ist ist die Verneinung
+falsch
+Wenn eine Aussage
+falsch ist ist die Verneinung
+wahr
+Eine Aussage
+kann nicht gleichzeitig wahr und falsch sein
+Die Aussagen
+und
+können nicht gleichzeitig wahr sein
+Und-verknüpfte Aussagen - Konjunktion
+Eine Konjunktion ist eine aus zwei Aussagen zusammengesetzte Aussage die die Wahrheit all ihrer Teilaussagen behauptet
+Umgangssprachlich verbindet man zwei Aussagen A und B durch das Bindewort und zu einer Konjunktion A und B in der logischen Sprache verwendet man meist das Zeichen
+Schreibweise
+gelegentlich auch das kaufmännische Und den Ampersand
+Sprechweise A und B
+Schreibweise
+auf Englisch und in der Schaltalgebra auch A AND B
+Die Aussage
+ist immer dann wahr wenn sowohl A als auch B jeweils wahr sind
+Andernfalls ist
+falsch nämlich dann wenn entweder A oder B oder beide Aussagen falsch sind
+Beispiele für eine Und-Verknüpfung
+A <num> ist durch <num> teilbar B <num> ist eine Quadratzahl
+Diese Teilaussagen und ihre Negationen werden nun durch
+miteinander verknüpft
+<num> ist durch <num> teilbar und <num> ist eine Quadratzahl
+<num> ist nicht durch <num> teilbar und <num> ist eine Quadratzahl
+<num> ist durch <num> teilbar und <num> ist keine Quadratzahl
+<num> ist nicht durch <num> teilbar und <num> ist keine Quadratzahl
+Nur
+ist wahr weil
+wahr ist und auch
+wahr ist
+ist falsch weil
+falsch ist
+ist falsch weil
+falsch ist
+ist falsch weil sowohl
+als auch
+falsch ist
+Nichtausschließendes Oder - Disjunktion
+Eine Disjunktion ist eine zusammengesetzte Aussage die behauptet dass mindestens eine ihrer Teilaussagen wahr ist
+Die Disjunktion in diesem Sinn wird auch nichtausschließendes Oder genannt
+Aber Achtung Die Bezeichnung Disjunktion wurde und wird oft auch für das ausschließende Oder entweder
+oder verwendet - man denke an das Konzept der disjunkten Mengen
+Einige Autoren verwenden daher für das Nichtausschließende Oder den Begriff Adjunktion Das Formelzeichen
+stammt von dem lateinischen Wort vel was auf deutsch oder bedeutet
+Sprechweise A oder B genauer A oder B oder beide häufig in juristischen oder medizinischen Texten A undoder B
+Schreibweise
+auf Englisch und in der Schaltalgebra auch A OR B
+Die Aussage
+ist immer dann wahr wenn mindestens eine der Teilaussagen A oder B wahr ist bzw wenn beide Teilaussagen wahr sind
+Andernfalls ist
+falsch nämlich dann wenn sowohl A als auch B falsch sind
+Beispiel für eine Oder-Verknüpfung
+A <num> ist durch <num> teilbar
+B <num> ist eine Quadratzahl
+Diese Teilaussagen und ihre Negationen werden nun durch
+miteinander verknüpft
+<num> ist durch <num> teilbar oder <num> ist eine Quadratzahl
+<num> ist nicht durch <num> teilbar oder <num> ist eine Quadratzahl
+<num> ist durch <num> teilbar oder <num> ist keine Quadratzahl
+<num> ist nicht durch <num> teilbar oder <num> ist keine Quadratzahl
+ist wahr weil sowohl
+als auch
+wahr sind
+ist wahr weil
+wahr ist
+ist wahr weil
+wahr ist Nur
+ist falsch weil sowohl
+als auch
+falsch sind
+Materiale Implikation
+Die materiale Implikation auch Konditional oder Subjunktion genannt drückt die hinreichende Bedingung aus Sie sagt dass die Wahrheit des einen Satzes eine hinreichende Bedingung für die Wahrheit des anderen Satzes ist
+Man schreibt
+oder auch
+und liest
+A ist eine hinreichende Bedingung für B
+Schon wenn A dann B
+A setzt voraus dass B
+B ist eine notwendige Bedingung für A Dass B genau dann eine notwendige Bedingung für A ist wenn A eine hinreichende Bedingung für B ist ist eine auf den ersten Blick überraschende und vielleicht kontraintuitive jedoch zutreffende Feststellung
+Das Unterkapitel Hinreichende und notwendige Bedingung bemüht sich diesen Zusammenhang sichtbarer zu machen
+A impliziert B
+Nur wenn B dann A
+oder auch nur
+Wenn A dann B
+In einem Konditional nennt man A das Antezedens B das Konsequens oder Sukzedens
+Beispiele
+Dass es regnet ist eine hinreichende Bedingung dafür dass die Straße nass ist
+Schon wenn es regnet ist die Straße nass
+Wenn es regnet ist die Straße nass
+Nur wenn die Straße nass ist kann es regnen
+Wenn Person x einen Wagen der Marke y hat hat x ein Auto
+Wenn eine Zahl n durch <num> teilbar ist dann ist die Zahl n durch <num> teilbar
+Die Lesart wenn
+dann ist insofern problematisch als mit dem natürlichsprachlichen wenn
+dann vor allem inhaltliche Zusammenhänge wie Kausalität oder zeitliche Nähe ausgedrückt werden
+All das macht die materiale Implikation nicht sie nennt nur den formalen Zusammenhang Dass es regnet ist eine hinreichende Bedingung dafür dass die Straße nass ist Zur Frage warum das eine hinreichende Bedingung ist - ob auf Grund eines kausalen Zusammenhangs oder auch nur rein zufällig - nimmt die materiale Implikation nicht Stellung
+Als Umkehrschluss bezeichnet man den Schluss von
+auf
+Für die Beispiele bedeutet das
+Wenn die Straße nicht nass ist regnet es nicht
+Wenn Person x kein Auto hat dann hat x keinen Wagen der Marke y
+Wenn die Zahl n nicht durch <num> teilbar ist dann ist n nicht durch <num> teilbar
+Umgangssprachlich lässt man sich gelegentlich zu weiteren - falschen - Aussagen verleiten
+Weil es nicht regnete kann die Straße nicht nass sein Diese Folgerung ist falsch da die Straße auch aus anderen Gründen nass werden kann Rohrbruch Übung der Feuerwehr
+x hat keinen Wagen der Marke y also hat x kein Auto Falsch denn er könnte ja einen Wagen der Marke z haben
+n ist nicht durch <num> teilbar also ist n auch nicht durch <num> teilbar Auch diese Folgerung ist falsch
+Die Zahl <num> ist nicht durch <num> teilbar und sehr wohl durch <num>
+Das bedeutet Wenn die Folgerung
+wahr ist dann erhält man aus der Aussage A keine Aussage über B B kann wahr oder falsch sein
+Ex falso sequitur quodlibet - Aus Falschem folgt Beliebiges
+Die Implikation ist ein wichtiges Mittel in der Mathematik
+Die meisten mathematischen Beweise verwenden das Konzept der Implikation
+Bikonditional
+Das Bikonditional oft auch objektsprachliche Äquivalenz oder materiale Äquivalenz genannt drückt die hinreichende und notwendige Bedingung aus sagt also dass eine Aussage A genau dann zutrifft wenn eine Aussage B zutrifft
+Man schreibt
+und liest
+A ist genau dann der Fall wenn B der Fall ist
+A genau dann wenn B
+A ist äquivalent zu B
+A ist dann und nur dann der Fall wenn B der Fall ist
+Auch beim Bikonditional wird eine rein formale Aussage getroffen die nichts über einen allfälligen inhaltlichen Zusammenhang von A und B aussagt
+Statt
+zu sagen kann man auch sagen dass A eine hinreichende Bedingung für B und dass B eine hinreichende Bedingung für A ist also
+Tatsächlich sind diese beiden Aussagen logisch äquivalent
+Beispiel
+Die natürliche Zahl n ist genau dann durch <num> teilbar wenn n durch <num> und durch <num> teilbar ist Wenn n durch <num> teilbar ist dann folgt daraus dass n durch <num> und durch <num> teilbar ist
+Umgekehrt gilt aber auch Wenn n durch <num> und durch <num> teilbar ist dann ist n durch <num> teilbar
+Heute ist genau dann Dienstag wenn morgen Mittwoch ist
+Das Bikonditional als zusammengesetzte Aussage innerhalb der logischen Sprache siehe Objektsprache wird oft mit dem Konzept der logischen Äquivalenz verwechselt oder vermischt
+Die logische Äquivalenz ist eine metasprachliche meist natürlichsprachlich formulierte Eigenschaft zweier Aussagen der logischen Sprache
+Ein Zusammenhang zwischen logischer Äquivalenz und Bikonditional besteht nur insofern als das Metatheorem gilt dass ein Bikonditional
+genau dann eine Tautologie ist wenn die beiden Aussagen A und B logisch äquivalent sind
+Ausschließendes Oder
+Das ausschließende Oder Kontravalenz oder Antivalenz entweder A oder B besagt dass genau eine der beiden von ihm verknüpften Aussagen wahr ist
+Entsprechend ist ein ausschließendes Oder nicht nur dann falsch wenn sowohl A als auch B falsch sind sondern auch wenn beide wahr sind
+Einige Autoren verwenden für das Ausschließende Oder den Begriff Alternative
+Obwohl das ausschließende Oder ein Konzept ist mit dem man in der natürlichen Sprache immer wieder zu tun hat wird es in den meisten logischen Sprachen nicht als eigenständiger Junktor eingeführt
+Stattdessen wird das ausschließende Oder zum Beispiel als verneintes Bikonditional ausgedrückt also als
+Große Bedeutung genießt das ausschließende Oder hingegen in der Schaltalgebra wo es meist als XOR eXclusive OR aufgeschrieben wird
+Verneinung einer verknüpften Aussage De Morgansche Gesetze
+Verneinung einer Konjunktion
+Die Verneinung der Konjunktion A und B in der logischen Schreibweise
+lautet Es ist nicht der Fall dass A und B zutreffen in der logischen Schreibweise
+Diese ist logisch äquivalent mit der Aussage A ist nicht der Fall oder B ist nicht der Fall oder beides in logischer Schreibweise
+Ein Beispiel
+Wenn man die Aussage
+Es regnet und die Erde ist eine Scheibe
+verneinen möchte dann kann man entweder sagen
+Es ist nicht der Fall dass es regnet und die Erde eine Scheibe ist
+oder man sagt
+Es regnet nicht oder die Erde ist keine Scheibe oder beides
+In der Schaltalgebra wird sehr oft der Junktor NAND verwendet wobei A NAND B denselben Wahrheitswertverlauf hat wie der Ausdruck
+Verneinung einer Disjunktion
+Die Verneinung der Disjunktion A oder B oder beides in der logischen Schreibweise
+lautet Es ist nicht der Fall dass A oder B zutrifft in logischer Schreibweise
+Diese ist logisch äquivalent mit der Aussage A ist nicht der Fall und B ist nicht der Fall in logischer Schreibweise
+Ein Beispiel
+Wenn man die Aussage
+Die Erde ist eine Scheibe oder die Erde ist ein Würfel
+verneinen möchte so sagt man
+Es ist nicht der Fall dass die Erde eine Scheibe ist oder dass die Erde ein Würfel ist
+Nach dem Gesetz von De Morgan kann man nun aber auch sagen
+Die Erde ist keine Scheibe und die Erde ist kein Würfel
+oder in schönerem Deutsch
+Die Erde ist weder eine Scheibe noch ein Würfel
+In der Schaltalgebra wird das Konnektiv NOR verwendet das denselben Wahrheitswertverlauf hat wie die Aussage
+Hinreichende und notwendige Bedingung
+Dieser Abschnitt soll den zunächst oft als kontraintuitiv empfundenen Zusammenhang zwischen hinreichender und notwendiger Bedingung wie er im Abschnitt über die materiale Implikation angesprochen wurde wiederaufgreifen und näher ausführen
+Betrachten wir noch einmal die materiale Implikation
+Man sagt A ist hinreichend für B Schon wenn A der Fall ist ist auch B der Fall
+Umgekehrt kann man aber auch sagen B ist notwendig für A Ohne B kann A nicht erfüllt sein
+Wie kommt dieser Zusammenhang zustande
+Wir wissen dass die Wahrheit von A die Wahrheit von B nach sich zieht denn A ist ja hinreichende Bedingung für B Somit ist es einfach nicht möglich dass A eintritt ohne dass B damit ebenfalls eintreten würde B ist also gezwungenermaßen der Fall wenn A der Fall ist
+B ist notwendig für A
+Dieser Zusammenhang ist in Wahrheit also ziemlich einfach Hauptgrund dafür dass er anfangs oft als kontraintuitiv empfunden wird ist wahrscheinlich die Schwierigkeit zwischen den vielen Bedeutungen des umgangssprachlichen wenn
+dann einerseits und der rein formalen hinreichenden und notwendigen Bedingung andererseits strikt zu trennen
+Mit dem umgangssprachlichen wenn
+dann möchte man fast immer einen inhaltlichen kausalen oder auch temporalen Zusammenhang zwischen Antecedens und Konsequens ausdrücken Regen verursacht Straßennässe Zuerst fällt der Regen erst nachher wird die Straße nass Wenn man die hinreichende Bedingung in diesem Sinn missversteht dann ist es klar dass die in umgekehrter Reihenfolge formulierte notwendige Bedingung Nur wenn die Straße nass ist regnet es seltsam aussieht Regen verursacht doch Straßennässe
+Wie kann daraus je gefolgert werden dass Straßennässe Regen verursacht
+All dies sagt die materiale Implikation aber nicht aus
+A ist eine hinreichende Bedingung für B meint schlicht dass wenn die Aussage A wahr ist auch die Aussage B wahr ist - zeitlos und zusammenhanglos nicht etwa später oder weil
+Analog sagt die notwendige Bedingung B ist eine notwendige Bedingung für A lediglich das aus dass B wahr ist sofern A es ist
+Genau das ist aber die Definition des Konditionals A
+B
+Formaler Zugang
+Einleitung
+Spätestens beim lauten Lesen von Sätzen wie
+Die Aussage
+ist genau dann wahr wenn die Aussagen A und B wahr sind
+wird der selbstbewusste Laie verlangen dass ihm erklärt wird was das soll
+Die Antwort des Logikers Es soll versucht werden Sicherheit in die Regeln des logischen Schließens zu bringen
+Seit den Sophisten ist dem Abendland klar dass scheinbar zwingende Schlüsse zu offensichtlich absurden Ergebnissen führen können
+Immer wieder wurden Paradoxien formuliert und von großen Denkern als Herausforderung empfunden
+Logiker versuchen deshalb die Regeln des Argumentierens so streng wie möglich zu fassen
+Das einleitende Beispiel macht klar dass dazu eine Trennung der Sprachebenen unerlässlich ist Die formale Aussage AB soll dadurch erklärt werden dass auf einer metasprachlichen Ebene über die Aussage A wie auch über die Aussage B geredet wird
+Ein Versuch dies durchzuführen besteht darin die Aussagenlogik als formales System konkret als Kalkül eine bestimmte Art eines formalen Systems zu definieren
+Die Begriffe wahr und falsch kommen in diesem System zunächst überhaupt nicht vor
+Stattdessen werden Axiome gesetzt die einfach als Zeichenketten angesehen werden aus denen weitere ableitbare Zeichenketten aufgrund von bestimmten Schlussregeln hergeleitet werden
+Das Ziel dabei ist einerseits dass in einem formalen System nur Zeichenketten Sätze hergeleitet werden können die bei einer plausiblen Interpretation auch wahr sind
+Andererseits sollen alle Sätze die als wahr interpretierbar sind auch hergeleitet werden können
+Das erste ist die Forderung nach Korrektheit das zweite die nach Vollständigkeit des formalen Systems beide Eigenschaften sind unter Kalkül Der Begriff Kalkül in der Logik beschrieben
+Für die klassische Aussagenlogik mit der wir es hier zu tun haben gibt es Kalküle formale Systeme die sowohl korrekt als auch vollständig sind
+Für komplexere logische Systeme z B
+Mengenlehre ist es aber unmöglich einen vollständigen Kalkül aufzustellen der auch korrekt ist - diese Erkenntnis wurde <num> von Kurt Gödel bewiesen Gödelscher Unvollständigkeitssatz
+Syntax
+Es gibt viele verschiedene Möglichkeiten die Syntax Grammatik einer logischen Sprache formal zu definieren meist geschieht das im Rahmen eines Kalküls
+Die folgende Definition ist daher nur als Beispiel dafür zu verstehen wie ein Kalkül für die klassische Aussagenlogik aussehen kann
+Weitere Beispiele für konkrete Kalküle finden sich unter Baumkalkül Begriffsschrift Systeme natürlichen Schließens Sequenzenkalkül oder Resolutionskalkül
+Ein weiterer axiomatischer Kalkül ist als Beispiel im Artikel Hilbert-Kalkül angegeben ein graphischer Kalkül im Artikel Existential Graphs
+Bausteine der aussagenlogischen Sprache
+Als Bausteine der aussagenlogischen Sprache sollen Satzbuchstaben atomare Formeln Satzkonstanten Junktoren und Gliederungszeichen verwendet werden
+Satzbuchstaben sollen die Zeichen P<num> P<num> P<num>
+sein
+Junktoren sollen die Zeichen
+und
+sein
+Als Gliederungszeichen sollen die runden Klammern dienen
+Formal lässt sich das z B
+auf folgende Weise ausdrücken
+Sei V die abzählbar unendliche Menge der atomaren Formeln Satzbuchstaben
+V
+Pn
+n
+N <num> N <num> Menge der natürlichen Zahlen inkl <num> d h
+V
+P<num> P<num> P<num> P<num>
+Sei J die Menge der Junktoren und Gliederungszeichen
+J
+Das
+Alphabet
+der logischen Sprache sei die Menge V
+J also die Vereinigungsmenge von atomaren Formeln Junktoren und Gliederungszeichen
+Formationsregeln
+Die Formationsregeln legen fest wie man aus den Bausteinen der aussagenlogischen Sprache Sätze Formeln bilden kann
+Hier sollen aussagenlogische Formeln als Worte über dem Alphabet der logischen Sprache also über V
+J wie folgt induktiv definiert werden
+Alle atomaren Formeln F
+V d h
+alle Satzbuchstaben sind Formeln
+Ist F eine Formel so ist auch F eine FormelDiese Formel heißt
+Negation
+von F
+Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
+G eine FormelDiese Formel heißt
+Konjunktion
+von F und G
+Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
+G eine FormelDiese Formel heißt
+Disjunktion
+von F und G
+Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
+G eine FormelDiese Formel heißt
+materiale Implikation
+oder Konditional von F und G
+Sind F und G zwei nicht notwendigerweise unterschiedliche Formeln so ist auch F
+G eine FormelDiese Formel heißt
+Bikonditional
+von F und G
+Nichts anderes ist eine aussagenlogische Formel
+Schlussregeln
+Schlussregeln sind allgemein Transformationsregeln Umformungsregeln die auf bestehende Formeln angewandt werden und aus ihnen neue Formeln erzeugen
+Wenn man einen Kalkül für ein logisches System aufstellt dann wählt man die Transformationsregeln so dass sie aus bestehenden Formeln solche Formeln erzeugen die aus den Ausgangsformeln semantisch folgen - deshalb die Bezeichnung Schlussregel eine Schlussfolgerung ziehen
+Innerhalb der Syntax sind die Schlussregeln allerdings rein formale Transformationsregeln denen für sich keinerlei inhaltliche Bedeutung zukommt
+An konkreten Schlussregeln sollen hier nur zwei angegeben werden Der Modus ponendo ponens und die Substitutionsregel
+Modus ponendo ponens
+Aus einem Satz der Form
+und einem Satz der Form
+darf man auf einen Satz der Form
+schließen dabei sind
+und
+Platzhalter für beliebige Formeln
+Zum Beispiel darf man nach dieser Schlussregel aus Wenn Regen die Straße benetzt dann ist der Straßenbelag regennass und aus Regen benetzt die Straße schließen auf Der Straßenbelag ist regennass
+Substitutionsregel Ersetzungsregel
+In einem Satz dürfen alle Vorkommnisse eines beliebigen Atoms z B
+P durch einen beliebig komplexen Satz z B
+ersetzt werden
+Es müssen dabei aber auch wirklich alle Vorkommnisse des gewählten Atoms ersetzt werden und sie müssen auch wirklich alle durch denselben Satz ersetzt werden
+Zum Beispiel darf mittels der Substitutionsregel aus
+auf
+geschlossen werden
+Man sagt P werde durch
+ersetzt bzw
+werde für P substituiert eingesetzt
+Axiome
+Axiome sind ausgezeichnete im Sinn von hervorgehobene Formeln der aussagenlogischen Sprache
+Die Auszeichnung besteht darin dass sie innerhalb eines Beweises oder einer Herleitung siehe unten ohne weitere Rechtfertigung verwendet werden
+Pragmatisch wählt man solche Formeln als Axiome die semantisch gesehen Tautologien sind also immer zutreffen und die dabei helfen Beweise zu verkürzen
+Innerhalb der Syntax sind die Axiome allerdings rein formale Objekte denen keinerlei inhaltliche Bedeutung oder Rechtfertigung zukommt
+Axiome sind im Allgemeinen optional d h
+ein Kalkül kann auch ganz ohne Axiome auskommen wenn er ausreichend viele bzw mächtige Schlussregeln hat
+Axiomfreie Kalküle sind zum Beispiel die Systeme natürlichen Schließens oder Baumkalküle
+Hier soll exemplarisch ein axiomatischer Kalkül gezeigt werden und zwar Russells Aussagenkalkül aus seiner Typentheorie <num> den er <num> in die Principia Mathematica übernahm Dieser Kalkül umfasst die folgenden Axiome von denen das vierte redundant d h
+nicht unbedingt erforderlich weil aus den anderen Axiomen herleitbar ist
+Um aus diesen Axiomen auch solche gültigen Sätze herleiten zu können die andere als die in den Axiomen vorkommende Junktoren enthalten werden diese durch folgende Festlegung auf die vorhandenen Junktoren zurückgeführt
+Alternativ zu - wie hier - konkreten Axiomen kann man auch Axiomenschemata angeben in welchem Fall man auch ohne Substitutionsregel auskommt
+Interpretiert man die obigen Axiome als Axiomenschemata dann stünde z B
+das erste Axiomenschema
+für unendlich viele Axiome nämlich alle Ersetzungsinstanzen dieses Schemas
+Herleitung und Beweis
+Eine Herleitung ist eine Liste von aufsteigend nummerierten Sätzen die mit einer oder mehreren Annahmen den Prämissen der Herleitung oder Axiomen beginnt
+Alle auf diese folgenden Sätze sind entweder ebenfalls Axiome bei manchen Kalkülen sind auch weitere Annahmen zulässig oder sind aus einer oder mehreren der vorangehenden Zeilen durch Anwendung von Schlussregeln entstanden
+Der letzte Satz in der Liste ist die Konklusion der Herleitung
+Eine Herleitung ohne Prämissen heißt Beweis
+Oft werden aber die Wörter Herleitung und Beweis synonym gebraucht
+Wenn es gelingt aus einer Menge von Annahmen Prämissen Δ eine Konklusion P herzuleiten dann schreibt man auch
+Gelingt es einen Satz P ohne die Verwendung von Annahmen herzuleiten zu beweisen dann schreibt man auch
+In diesem Fall wird P Theorem genannt
+Das Zeichen
+geht auf die Begriffsschrift zurück jenes Werk in dem Gottlob Frege <num> die erste Formalisierung der Prädikatenlogik angegeben hat
+In der klassischen Aussagenlogik wählt man die Schlussregeln so dass sich mit ihrer Hilfe alle gültigen Argumente und nur gültige Argumente herleiten lassen die Frage der Gültigkeit wird im folgenden Abschnitt Semantik behandelt
+Semantik
+Außerhalb der Logik bezeichnet Semantik ein Forschungsgebiet das sich mit der Bedeutung von Sprache und deren Teilen befasst
+Oft wird auch das Wort Semantik gleichbedeutend mit dem Wort Bedeutung verwendet
+Auch innerhalb der Logik geht es bei Semantik um Bedeutung Darum nämlich den Ausdrücken einer formalen Sprache - zum Beispiel der hier behandelten Sprache der Aussagenlogik - eine Bedeutung zuzuordnen
+In der Logik wird auch das meist sehr formal unternommen
+Im Zentrum der formalen Semantik steht eine Auswertungsfunktion andere Bezeichnungen lauten Bewertungsfunktion Denotationsfunktion Wahrheitswertefunktion die den Formeln der logischen Sprache eine Bedeutung zuordnet
+Formal gesprochen ist die Auswertungsfunktion eine Abbildung von der Menge der Formeln der Sprache in die Menge der Wahrheitswerte
+Oft wird die Auswertungsfunktion mit dem Großbuchstaben V bezeichnet
+In der klassischen Aussagenlogik ist die Auswertungsfunktion sehr einfach Das Prinzip der Zweiwertigkeit fordert dass sie für jede zu bewertende Formel genau einen von genau zwei Wahrheitswerten liefern muss und das Prinzip der Extensionalität fordert dass die Bewertungsfunktion beim Bewerten eines komplexen Satzes nur die Bewertung von dessen Teilsätzen berücksichtigen muss
+Jedem Atom also jedem Satzbuchstaben Atom wird durch Festsetzung ein Wahrheitswert zugeordnet
+Man sagt Die Atome werden interpretiert
+Es wird also z B
+festgelegt dass P<num> wahr ist dass P<num> falsch ist und dass P<num> ebenfalls falsch ist
+Damit ist der Bewertung der Bausteine der logischen Sprache Genüge getan
+Formal ist eine solche Bewertung - Interpretation genannt und oft mit dem Kleinbuchstaben v bezeichnet - eine Funktion im mathematischen Sinn d h
+eine Abbildung von der Menge der Atome in die Menge der Wahrheitswerte
+Wenn die Auswertungsfunktion V auf ein Atom angewandt wird d h
+wenn sie ein Atom bewerten soll liefert sie die Interpretation dieses Atoms im Sinn des obigen Absatzes
+Mit anderen Worten sie liefert den Wert den die Bewertung v dem Atom zuordnet
+Um die zusammengesetzten Formeln bewerten zu können muss für jeden Junktor definiert werden welchen Wahrheitswert die Bewertungsfunktion für die unterschiedlichen Wahrheitswertkombinationen liefert den seine Argumente annehmen können
+In der klassischen Aussagenlogik geschieht das meist mittels Wahrheitstabellen weil es nur überschaubar wenige Möglichkeiten gibt
+Der einstellige Junktor
+die Negation ist in der klassischen Aussagenlogik so definiert dass er den Wahrheitswert seines Arguments ins Gegenteil umkehrt also verneint Ist die Bewertung einer Formel X wahr dann liefert die Bewertungsfunktion für X falsch wird aber X falsch bewertet dann liefert die Bewertungsfunktion für X wahr
+Die Wahrheitstabelle sieht folgendermaßen aus
+Die Wahrheitswertverläufe der verwendeten zweistelligen Konnektive sind in der klassischen Aussagenlogik wie folgt definiert
+Allgemein gibt es für die klassische Aussagenlogik vier einstellige und sechzehn zweistellige Junktoren
+Die hier behandelte logische Sprache beschränkt sich nur deshalb auf die Junktoren
+und
+weil diese am gebräuchlichsten sind und weil sie auch inhaltlich noch am ehesten aus der Alltagssprache bekannt sind
+Aus formaler Sicht ist die einzige Bedingung die man bei der Wahl von Junktoren erfüllen möchte die dass sich mit den gewählten Junktoren auch alle anderen theoretisch möglichen Junktoren ausdrücken lassen man sagt Dass die Menge der gewählten Junktoren funktional vollständig ist
+Diese Anforderung ist bei der hier getroffenen Wahl erfüllt
+Näheres zur Frage wie viele und welche Junktoren es gibt und wie viele Junktoren man benötigt um funktionale Vollständigkeit zu erreichen ist im Kapitel Junktor beschrieben
+Semantische Gültigkeit Tautologien
+Semantische Gültigkeit ist eine Eigenschaft von Formeln oder von Argumenten
+Ein Argument ist die Behauptung dass aus einigen Aussagen - den Prämissen - eine bestimmte Aussage - die Konklusion - folgt
+Eine Formel der aussagenlogischen Sprache heißt genau dann semantisch gültig wenn die Formel unter allen Interpretationen - d h
+unter allen Zuordnungen von Wahrheitswerten zu den in ihr vorkommenden Atomen - wahr ist wenn sie sozusagen allgemeingültig ist mit anderen Worten Wenn die Wahrheitstabelle für diese Aussage in jeder Zeile das Ergebnis wahr zeigt
+Man nennt semantisch gültige Formeln auch Tautologien und schreibt wenn
+eine Tautologie ist formal wie folgt
+Ein Argument heißt genau dann semantisch gültig wenn unter der Voraussetzung dass alle Prämissen wahr sind auch die Konklusion wahr ist
+In der Formulierung von Gottfried Wilhelm Leibniz Aus Wahrem folgt nur Wahres Diese Definition muss natürlich ebenfalls formal gefasst werden und das geschieht wie folgt Ein Argument ist genau dann semantisch gültig wenn alle Zuordnungen von Wahrheitswerten zu den in Prämissen und Konklusion vorkommenden Atomen unter denen die Bewertungsfunktion für alle Prämissen den Wert wahr liefert auch für die Konklusion den Wert wahr liefert
+Um auszudrücken dass aus einer Menge
+von Formeln der Prämissenmenge eine Formel
+die Konklusion semantisch folgt schreibt man formal wie folgt
+Beachte die graphische Ähnlichkeit und die inhaltliche Verschiedenheit zwischen
+Kapitel Herleitung und Beweis und
+Siehe Semantische Folgerung Die erste Formulierung -
+- drückt die syntaktische Gültigkeit des Arguments aus sagt also dass aus den Formeln in
+mit den Schlussregeln des gewählten Kalküls die Formel
+hergeleitet werden kann
+hingegen behauptet die semantische Gültigkeit die in der klassischen Aussagenlogik wie in den vorangegangenen Absätzen als das Leibnizsche Aus Wahrem folgt nur Wahres definiert ist
+Wichtige semantische Eigenschaften Erfüllbarkeit Widerlegbarkeit und Unerfüllbarkeit
+Neben der Eigenschaft der Gültigkeit Allgemeingültigkeit gibt es einige andere wichtige Eigenschaften Erfüllbarkeit Widerlegbarkeit und Unerfüllbarkeit
+Im Gegensatz zur Gültigkeit die Eigenschaft von Formeln oder von Argumenten sein kann sind Erfüllbarkeit Widerlegbarkeit und Unerfüllbarkeit Eigenschaften von Sätzen oder von Satzmengen
+Eine Formel heißt erfüllbar wenn es mindestens eine Interpretation der in ihr vorkommenden Atome Satzbuchstaben gibt unter der die Formel wahr ist
+Eine Formel heißt widerlegbar wenn es mindestens eine Interpretation der in ihr vorkommenden Atome gibt unter der die Formel falsch ist
+Eine Formel heißt unerfüllbar wenn sie unter allen Interpretationen der in ihr vorkommenden Satzbuchstaben falsch ist
+Eine Formelmenge heißt erfüllbar wenn alle in ihr enthaltenen Formeln erfüllbar sind
+Die Frage ob eine Formel oder eine Formelmenge eine der genannten Eigenschaften hat ist ebenso wie die Frage ob eine Formel allgemeingültig d h
+eine Tautologie ist für allgemeine Formeln nicht effizient lösbar Zwar ist die Wahrheitstafel ein Entscheidungsverfahren für jede dieser Fragen doch umfasst eine Wahrheitstafel für eine Aussage bzw eine Aussagemenge in n Atomen
+Zeilen das Wahrheitstafelverfahren ist nichts anderes als ein Brute-Force-Verfahren
+Jede dieser Fragestellungen kann auf die Frage zurückgeführt werden ob eine bestimmte Formel erfüllbar ist
+Eine Formel
+ist genau dann eine Tautologie wenn
+unerfüllbar ist
+Eine Formel
+ist genau dann widerlegbar wenn
+erfüllbar ist
+Die Frage ob eine Aussage erfüllbar ist wird Erfüllbarkeitsproblem oder SAT-Problem nach dem englischen Wort für Erfüllbarkeit satisfiability genannt
+Das SAT-Problem spielt eine wichtige Rolle in der theoretischen Informatik und Komplexitätstheorie
+Das Erfüllbarkeitsproblem für allgemeine beliebige Formeln ist NP-vollständig d h
+unter der Voraussetzung dass P ungleich NP nicht in polynomialer Laufzeit lösbar
+Für bestimmte echte Teilmengen der Formeln der aussagenlogischen Sprache ist das SAT-Problem dennoch schneller d h
+in polynomial beschränkter Rechenzeit lösbar
+Eine solche Teilmenge sind die Horn-Formeln das sind Konjunktionen von Disjunktionen deren Disjunkte verneinte oder unverneinte Atome sind wobei innerhalb einer solchen Disjunktion allerdings höchstens ein Atom unverneint sein darf
+Algebraische Sicht
+Wenn man die Semantik betrachtet die hier für die klassische Aussagenlogik aufgestellt wurde dann erkennt man gewisse Gesetzmäßigkeiten
+Wird z B
+die Auswertungsfunktion auf eine Aussage der Form X
+W angewendet wobei W eine beliebige wahre Aussage sein soll dann stellt man fest dass die Auswertungsfunktion für X
+W immer den Wahrheitswert wahr liefert wenn VXwahr ist das heißt VXWVX Von der Struktur her gleichwertige Gesetzmäßigkeiten gelten auch in anderen Semantiken auch in solchen die für ganz andere nichtlogische Systeme aufgestellt werden
+Für die Arithmetik gilt z B dass die dortige Bewertungsfunktion hier VArithmetik genannt für einen Ausdruck der Form X
+Y immer den Wert von X liefert sofern der Wert von Y null ist VArithmetikXYVArithmetikX wenn VArithmetikY
+null ist
+Eine formale Wissenschaft die solche strukturellen Gesetzmäßigkeiten untersucht ist die abstrakte Algebra meist Teilgebiet der Mathematik aber auch der Informatik
+In der abstrakten Algebra wird zum Beispiel untersucht für welche Verknüpfungen es ein neutrales Element gibt d h
+ein Element N das für eine Verknüpfung op dazu führt dass für beliebiges X gilt X op N
+X So würde man aus algebraischer Sicht sagen dass es für die klassische aussagenlogische Konjunktion genau ein neutrales Element gibt nämlich wahr und dass es für die Addition in der Arithmetik ebenfalls genau ein neutrales Element gibt nämlich die Zahl Null
+Nur am Rande sei erwähnt dass es auch für andere Junktoren neutrale Elemente gibt das neutrale Element für die Disjunktion ist falsch VX
+F
+VX wenn VFfalsch ist
+Die formale Algebra betrachtet formale Semantiken rein nach ihren strukturellen Eigenschaften
+Sind diese identisch dann besteht zwischen ihnen aus algebraischer Sicht kein Unterschied
+Aus algebraischer Sicht genauer Aus Sicht der formalen Algebra ist die Semantik für die klassische Aussagenlogik eine zweiwertige Boolesche Algebra
+Andere formale Systeme deren Semantiken jeweils eine Boolesche Algebra bilden sind die Schaltalgebra und die elementare Mengenlehre
+Aus algebraischer Sicht besteht daher zwischen diesen Disziplinen kein Unterschied
+Normalformen
+Jede aussagenlogische Formel lässt sich in eine äquivalente Formel in konjunktiver Normalform und eine äquivalente Formel in disjunktiver Normalform umformen
+Metatheorie
+In der Metatheorie werden die Eigenschaften von logischen Systemen untersucht Das logische System ist in der Metatheorie der Untersuchungsgegenstand
+Eine metatheoretische Fragestellung ist zum Beispiel die ob in einem Kalkül ein Widerspruch hergeleitet werden kann
+Der vorliegende Abschnitt soll einige wichtige metatheoretische Fragestellungen aus dem Blickwinkel der Aussagenlogik betrachten
+Konsistenz
+Ein Kalkül wird genau dann konsistent genannt wenn es unmöglich ist mit Hilfe seiner Axiome und Regeln einen Widerspruch herzuleiten d h
+eine Aussage der Form P
+P z B
+Hugo ist groß und Hugo ist nicht groß Für einen Kalkül der in der Aussagenlogik verwendet werden soll ist das eine Mindestanforderung
+Ist es in einem Kalkül möglich einen Widerspruch herzuleiten dann wird der Kalkül inkonsistent genannt
+Es gibt formale Systeme in denen solch ein Widerspruch hergeleitet werden kann die aber durchaus sinnvoll sind
+Für solche Systeme wird ein anderer Konsistenzbegriff verwendet Ein Kalkül ist konsistent wenn in ihm nicht alle Formeln herleitbar sind siehe parakonsistente Logik
+Es lässt sich leicht zeigen dass für die klassische Logik die beiden Konsistenzbegriffe zusammenfallen In der klassischen Logik lässt sich aus einem Widerspruch jeder beliebige Satz herleiten dieser Sachverhalt wird Ex falso quodlibet genannt d h
+wenn ein klassischer Kalkül auch nur einen Widerspruch herleiten könnte also im ersten Sinn inkonsistent wäre dann könnte er jede Aussage herleiten wäre also im zweiten Sinn inkonsistent
+Wenn umgekehrt ein Kalkül inkonsistent im zweiten Sinn ist also in ihm jede Aussage herleitbar ist dann ist insbesondere auch jeder Widerspruch herleitbar und ist er auch inkonsistent im ersten Sinn
+Korrektheit
+Ein Kalkül heißt genau dann korrekt semantisch korrekt wenn in ihm nur solche Formeln hergeleitet werden können die auch semantisch gültig sind
+Für die klassische Aussagenlogik bedeutet das einfacher Ein Kalkül ist genau dann korrekt wenn in ihm nur Tautologien bewiesen und nur gültige Argumente hergeleitet werden können
+Ist es in einem aussagenlogischen Kalkül möglich mindestens ein ungültiges Argument herzuleiten oder mindestens eine Formel zu beweisen die keine Tautologie ist dann ist der Kalkül inkorrekt
+Vollständigkeit
+Vollständig semantisch vollständig heißt ein Kalkül genau dann wenn in ihm alle semantisch gültigen Formeln hergeleitet werden können für die klassische Aussagenlogik Wenn in ihm alle Tautologien hergeleitet werden können
+Adäquatheit
+Ein Kalkül heißt genau dann im Hinblick auf eine spezielle Semantik adäquat wenn er semantisch korrekt und semantisch vollständig ist
+Ein metatheoretisches Resultat ist zum Beispiel die Feststellung dass alle korrekten Kalküle auch konsistent sind
+Ein anderes metatheoretisches Resultat ist die Feststellung dass ein konsistenter Kalkül nicht automatisch korrekt sein muss Es ist ohne weiteres möglich einen Kalkül aufzustellen in dem zwar kein Widerspruch hergeleitet werden kann in dem aber z B
+die nicht allgemeingültige Aussage der Form A
+B hergeleitet werden kann
+Ein solcher Kalkül wäre aus ersterem Grund konsistent aus letzterem Grund aber nicht korrekt
+Ein weiteres sehr einfaches Resultat ist die Feststellung dass ein vollständiger Kalkül nicht automatisch auch korrekt oder nur konsistent sein muss
+Das einfachste Beispiel wäre ein Kalkül in dem jede Formel der aussagenlogischen Sprache herleitbar ist
+Da jede Formel herleitbar ist sind alle Tautologien herleitbar die ja Formeln sind Das macht den Kalkül vollständig
+Da aber jede Formel herleitbar ist ist insbesondere auch die Formel P<num>
+P<num> und die Formel A
+B herleitbar Ersteres macht den Kalkül inkonsistent letzteres inkorrekt
+Das Ideal das ein Kalkül erfüllen sollte ist Korrektheit und Vollständigkeit Wenn das der Fall ist dann ist er der ideale Kalkül für ein logisches System weil er alle semantisch gültigen Sätze und nur diese herleiten kann
+So sind die beiden Fragen ob ein konkreter Kalkül korrekt undoder vollständig ist und ob es für ein bestimmtes logisches System überhaupt möglich ist einen korrekten und vollständigen Kalkül anzugeben zwei besonders wichtige metatheoretische Fragestellungen
+Abgrenzung und Philosophie
+Die klassische Aussagenlogik wie sie hier ausgeführt wurde ist ein formales logisches System
+Als solches ist sie eines unter vielen die aus formaler Sicht gleichwertig nebeneinander stehen und die ganz bestimmte Eigenschaften haben Die meisten sind konsistent die meisten sind korrekt etliche sind vollständig und einige sind sogar entscheidbar
+Aus formaler Sicht stehen die logischen Systeme in keinem Konkurrenzverhalten hinsichtlich Wahrheit oder Richtigkeit
+Von formalen innerlogischen Fragen klar unterschieden sind außerlogische Fragen Solche nach der Nützlichkeit Anwendbarkeit einzelner Systeme für einen bestimmten Zweck und solche nach dem philosophischen speziell metaphysischen Status einzelner Systeme
+Die Nützlichkeitserwägung ist die einfachere bezüglich deren Meinungsunterschiede weniger tiefgehend bzw weniger schwerwiegend sind
+Klassische Aussagenlogik zum Beispiel bewährt sich in der Beschreibung elektronischer Schaltungen Schaltalgebra oder zur Formulierung und Vereinfachung logischer Ausdrücke in Programmiersprachen
+Prädikatenlogik wird gerne angewandt wenn es darum geht Faktenwissen zu formalisieren und automatisiert Schlüsse daraus zu ziehen wie das unter anderem im Rahmen der Programmiersprache Prolog geschieht
+Fuzzy-Logiken nonmonotone mehrwertige und auch parakonsistente Logiken sind hochwillkommen wenn es darum geht mit Wissensbeständen umzugehen in denen Aussagen mit unterschiedlich starkem Gewissheitsgrad oder gar einander widersprechende Aussagen abgelegt werden sollen und dennoch sinnvolle Schlüsse aus dem Gesamtbestand gezogen werden sollen
+Auch wenn es je nach Anwendungsfall sehr große Meinungsunterschiede geben kann welches logisches System besser geeignet ist ist die Natur des Problems für alle Beteiligten unmittelbar und in gleicher Weise greifbar
+Einzelwissenschaftliche Überlegungen und Fragestellungen spielen sich überwiegend in diesem Bereich ab
+Noch kontroverser als solche pragmatischen Überlegungen sind Fragestellungen philosophischer und metaphysischer Natur
+Geradezu paradigmatisch ist die Frage welches logische System richtig ist wobei richtig hier gemeint ist als Welches logische System nicht nur einen Teilaspekt der Wirklichkeit modellhaft vereinfacht sondern die Wirklichkeit das Sein als Ganzes adäquat beschreibt
+Zu dieser Fragestellung gibt es viele unterschiedliche Meinungen einschließlich der vom philosophischen Positivismus eingeführten Meinung dass die Fragestellung als Ganzes sinnlos ist
+In den Bereich metaphysischer Fragestellungen fällt auch die Frage ob es so etwas wie ein metaphysisches Prinzip der Zweiwertigkeit gebe ob also Aussagen über die Wirklichkeit durchgehend ins Schema wahrfalsch passen oder nicht
+Diese Frage ist unabhängig von der Frage ob die Beschäftigung mit zwei- oder mehrwertigen Logiken praktisch sinnvoll ist Selbst wenn ein metaphysisches Prinzip der Zweiwertigkeit herrscht könnte man anwendungspraktisch mehrwertige Logiken nützen etwa dazu epistemische Sachverhalte zu fassen zum Beispiel aus Aussagen zu schließen die zwar metaphysisch wahr oder falsch sind von denen aber nicht oder noch nicht bekannt ist welches von beidem der Fall ist
+Umgekehrt kann man auch dann wenn ein solches metaphysisches Prinzip nicht gilt zweiwertige Logik wegen ihrer Einfachheit für solche Anwendungen bevorzugen bei denen nur mit solchen Sätzen umgegangen werden muss die tatsächlich wahr oder falsch sind
+Die Frage nach einem metaphysischen Prinzip der Zweiwertigkeit ist wie die meisten metaphysischen Fragen nicht endgültig zufriedenstellend beantwortet
+Ein früher Einwand gegen ein solches Prinzip den Aristoteles zur Diskussion stellte war das Thema der Aussagen über zukünftige Sachverhalte Morgen wird es regnen Wenn Aussagen über Zukünftiges schon heute wahr oder falsch wären so wird argumentiert dann müsse die Zukunft bis ins letzte Detail vorbestimmt sein
+Ein anderer Einwand der vorgebracht wird ist dass es Aussagen gibt deren Wahrheit praktisch oder theoretisch nicht festgestellt werden kann - zum Beispiel lässt sich die Wahrheit von Der Rasen vor dem Weißen Haus bestand am <num> Februar <num> aus genau <num><num> Grashalmen einfach nicht feststellen
+Befürworter eines metaphysischen Zweiwertigkeitsprinzips berufen sich oft auf das Verhalten von Metatheoretikern also von Mathematikern oder Logikern die Aussagen über formale Systeme treffen Egal wie mehrwertig oder nichtklassisch das untersuchte System ist die dabei getroffenen Metavermutungen Metabehauptungen und Metafeststellungen sind immer zweiwertig Ein Kalkül auch ein parakonsistenter oder nonmonotoner wird immer als entweder konsistent oder inkonsistent betrachtet und ein logisches System ist immer entweder korrekt oder inkorrekt vollständig oder nicht vollständig entscheidbar oder unentscheidbar niemals ein bisschen von beidem
+Befürworter deuten das als Hinweis darauf dass es in der Wirklichkeit tatsächlich eine strenge Unterscheidung nach wahr und falsch gebe oder dass es zumindest sinnvoll ist eine solche anzunehmen
+Eine andere philosophische Fragestellung ist die nach dem metaphysischen Status des Untersuchungsgegenstands der Logik also danach was logische Systeme Kalküle Wahrheitswerte eigentlich sind
+Der platonische Standpunkt besteht darin dass die in der Logik verwendeten Zeichen und Konstrukte eine außerlogische Bedeutung haben dass sie Namen für real existierende wenn auch natürlich nicht-physikalische Gegenstände sind
+In diesem Sinn gäbe es so etwas wie das Wahre und das Falsche abstrakte Gegenstände die von den Zeichen wahr und falsch benannt werden
+Der Gegenpol zum Platonismus wäre der Nominalismus der Existenz nur den Zeichen zuspricht die in der Logik manipuliert werden
+Gegenstand der Logik sind Zeichen und die Tätigkeit der Logiker ist die Manipulation von Zeichen
+Die Zeichen bezeichnen aber nichts so etwas wie das Wahre oder das Falsche gibt es also nicht
+Im Grundlagenstreit der Mathematik entspräche der nominalistischen Position die formalistische Richtung
+Eine Mittelstellung nähme der philosophische Konstruktivismus ein demzufolge die Zeichen zwar keine unabhängig existierenden Gegenstände bezeichnen durch den Umgang mit den Zeichen aber Gegenstände konstruiert werden
+Literatur
+Jon Barwise John Etchemendy The Language of First Order Logic
+CSLI Lecture Notes Bd <num>
+<num> Auflage revised and expanded
+Center for the Study of Language and Information Stanford CA <num> ISBN <num>-<num>-<num>-<num>
+Ansgar Beckermann Einführung in die Logik <num> neu bearbeitete und erweiterte Auflage
+de Gruyter Berlin u a <num> ISBN <num>-<num>-<num>-<num>
+Karel Berka Lothar Kreiser Logik-Texte
+Kommentierte Auswahl zur Geschichte der modernen Logik
+<num> gegenüber der <num> erweiterte durchgesehene Auflage
+Akademie-Verlag Berlin <num>
+Wolfgang Detel Grundkurs Philosophie Band <num> Logik
+Universal-Bibliothek Nr <num>
+Reclam Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Wilfrid Hodges Logic Penguin Books Harmondsworth <num> ISBN <num>-<num>-<num>-<num> <num> Auflage
+ebenda <num> ISBN <num>-<num>-<num>-<num>
+Rüdiger Inhetveen Logik
+Eine dialog-orientierte Einführung
+Eagle Bd <num>
+Edition am Gutenbergplatz Leipzig <num> ISBN <num>-<num>-<num>-<num>
+E J Lemmon Beginning Logic Nelson London <num> <num> Auflage
+Chapman
+Hall London <num> ISBN <num>-<num>-<num>-<num>
+Wesley C Salmon Logik
+Universal-Bibliothek Nr <num>
+Reclam Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Weblinks
+Vorlesungsmitschnitt Mathematik I Uni Tübingen
+Die ersten zwei Stunden handeln ausführlich von Wahrheitstabellen
+Christian Spannagel Aussagen- und Prädikatenlogik
+Vorlesungsreihe <num>
+Einzelnachweise
+Karl Dürr Aussagenlogik im Mittelalter In Erkenntnis Bd <num> Nr <num> <num><num>
+S <num>-<num> doi<num>BF<num> Achtung Verwechslungsgefahr Das ist kein Obermengenzeichen sondern das Kurven- Bogen- oder Hufeisenzeichen Peano-Russellsche Schreibweise - siehe Beitrag zur Implikation das Teilmengenzeichen welches gleich aussieht müsste sich auf die andere Seite öffnen Zur prädikatenlogischen Entsprechung siehe Prädikatenlogik erster Stufe SymboleE Grädel <num> S <num> f Zur prädikatenlogischen Entsprechung siehe Prädikatenlogik erster Stufe TermeVergleiche E Grädel <num> S <num> Bertrand Russell Mathematical logic as based on the theory of types In American Journal of Mathematics <num> <num> S <num> <num>-<num> PDF
+<num> MB
+Principia Mathematica
+Band I S <num>f
+Anthony Minghella CBE
+<num> Januar <num> auf der Isle of Wight Großbritannien
+<num> März <num> in London war ein britischer Filmregisseur Filmproduzent Drehbuchautor Dramatiker Hörspielautor Theater- und Opernregisseur
+Leben
+Minghella war der Sohn italienisch-schottischer Eltern die auf der Isle of Wight eine Fabrik für Eiscreme betrieben
+Nach seinem Schulabschluss studierte er an der Universität Hull wo er eine Zeit lang als Dozent tätig war
+<num> drehte er einen ersten Kurzfilm
+Seit <num> war er als Autor und Story Editor tätig
+Er wurde mit Theaterstücken Rundfunkhörspielen der Fernsehserie Inspector Morse und vielen Drehbüchern für Film und Fernsehen bekannt
+Er entwickelte die Drehbücher für die <num> erfolgreich ausgestrahlte Fernsehserie The Storyteller von Muppets-Erfinder Jim Henson
+Auch als Produzent war er erfolgreich darunter für die Filme
+Der stille Amerikaner
+Die Dolmetscherin
+und
+Der Vorleser
+für den er <num> posthum für den Oscar Kategorie Bester Film nominiert wurde
+Gemeinsam mit seinem Freund und Kollegen Sydney Pollack gründete er die Produktionsfirma Mirage Enterprises
+Der Regisseur Minghella galt als ein guter Schauspielerführer Unter seiner Regie brachten es zahlreiche Darsteller zu Oscar-Nominierungen zwei Schauspielerinnen erhielten die Auszeichnung als Beste Nebendarstellerin Juliette Binoche Der englische Patient und Renée Zellweger Unterwegs nach Cold Mountain
+Gegen Ende seines Lebens kehrte Minghella zu seinen Anfängen im Radio und auf der Bühne zurück <num> wurde sein Hörspiel Eyes Down Looking mit Jude Law zu Ehren von Samuel Beckett auf BBC Radio <num> ausgestrahlt ein Jahr zuvor hatte seine Inszenierung der Puccini-Oper Madame Butterfly in der English National Opera in London Premiere und wurde auch in der Nationaloper von Vilnius und in der Metropolitan Opera in New York gezeigt
+Am Ende des Films
+Abbitte
+von Joe Wright <num> hat er einen Kurzauftritt als Talkshow-Moderator neben Vanessa Redgrave
+Seine letzte Arbeit als Drehbuchautor war das Skript für den Musical-Film
+Nine
+gemeinsam mit Michael Tolkin
+Zu seinen letzten Regiearbeiten zählt der Pilotfilm zur Krimiserie Eine Detektivin für Botswana
+Originaltitel
+den die BBC fünf Tage nach seinem Tod erstmals ausstrahlte
+Minghella war mit der aus Hongkong stammenden Choreographin Produzentin und Schauspielerin Carolyn Choa
+Wie verrückt und aus tiefstem Herzen
+verheiratet
+Der Ehe entstammen zwei Kinder die in der Filmbranche tätig sind Tochter Hannah Minghella in der Produktion und Sohn Max Minghella als Schauspieler
+Agora - Die Säulen des Himmels
+Die Tante Edana Minghella und der Onkel Dominic Minghella u a
+für die deutsche Fernsehserie
+Doktor Martin
+sind Drehbuchautoren
+Minghella starb im Alter von <num> Jahren in einem Londoner Krankenhaus an inneren Blutungen infolge der Operation eines Tonsillen karzinoms und eines Karzinoms im Nacken
+Auszeichnungen
+<num> erhielt Minghella den Londoner Kritikerpreis als meistversprechender junger Dramatiker <num> den Kritikerpreis für sein Stück Made in Bangkok als bestes Stück der Saison
+<num> erhielt er für
+Der englische Patient
+den Oscar in der Rubrik
+Beste Regie
+<num> eine Oscar-Nominierung in der Kategorie Bestes adaptiertes Drehbuch für
+Der talentierte Mr Ripley
+bei dem er auch Regie führte
+<num> wurde Minghella zum Commander of the British Empire CBE ernannt
+Von <num> bis <num> war er Präsident des British Film Institute
+Seit <num> trägt das Anthony Minghella Theatre auf der Isle of Wight seinen Namen
+Filmografie als Regisseur Auswahl
+<num> Wie verrückt und aus tiefstem Herzen Truly Madly Deeply
+<num> Mr
+Wonderful
+<num> Der englische Patient The English Patient
+<num> Der talentierte Mr Ripley The Talented Mr Ripley
+<num> Unterwegs nach Cold Mountain Cold Mountain
+<num> Breaking and Entering - Einbruch amp Diebstahl Breaking and Entering
+<num> New York I Love You Szene
+Weblinks
+BBC <num> März <num> englisch
+Image<num> degree rulesvgDiese Illustration zeigt die Achse zwischen den beiden Personen und den <num>-Bogen auf dem Kameras platziert werden können grün
+enn zwischen dem grünen und dem roten Bogen geschnitten wird tauschen die Personen auf dem Bildschirm scheinbar Position und Blickrichtung
+Ein Achsensprung ist ein Filmschnitt mit dem die Beziehungsachse der Figuren oder Gruppen übersprungen wird
+Blickachsen oder Beziehungsachsen zwischen den Akteuren untereinander oder dem Point of Interest des Protagonisten bilden eine gedachte Linie
+Auf die Leinwand projiziert stellt diese Linie eine links-rechts- und oben-unten-Beziehung zwischen den Akteuren dar
+Mit Achsensprung bezeichnet man einen Schnitt bei dem sich dieses Verhältnis umkehrt
+Es wird zwischen Seitenachsensprung und dem Höhenachsensprung unterschieden
+Letzterer wird als weniger desorientierend vom Zuschauer empfunden da die Leinwand weniger hoch als breit ist
+Ein Achsensprung kann beim Zuschauer Desorientierung verursachen da die Anordnung und Blickrichtung der Akteure im Frame sich relativ zum Zuschauer zu verändern scheint
+Aktionsachse Handlungsachse ist die gedachte Linie in deren Richtung sich die Handlung oder das Inertialsystem der Filmwelt bewegt
+Bei einer Autofahrt zum Beispiel ist die Aktionsachse so stark dass die Beziehungsachsen an Bedeutung verlieren
+Die Orientierung bleibt trotz eventuellem Achsensprung bewahrt
+Wenn man aus der Fahrerseite filmt bewegt sich die Landschaft scheinbar von rechts nach links filmt man aus der Beifahrerseite bewegt sie sich scheinbar von links nach rechts
+Diese Änderung der Bewegungsrichtung ist aber nicht irritierend
+Analog werden zwei Autos die bei einer Parallelmontage in die gleiche Richtung fahren oft von links nach rechts weil das unserer Leserichtung entspricht als einander verfolgend wahrgenommen wenn eines jedoch von links nach rechts und das andere von rechts nach links fährt erwartet der Zuschauer einen Zusammenstoß
+Im Continuity Editing des klassischen Hollywoodkinos wird der Achsensprung als Fehler betrachtet und dementsprechend vermieden
+Der Grundsatz Achsensprünge zu vermeiden wird <num>-Grad-Regel genannt
+Bewusster Achsensprung
+In manchen Fällen kann ein bewusster Achsensprung auch Stilmittel sein um beispielsweise Verwirrung oder einen Kippmoment zu symbolisieren Stanley Kubrick wird in diesem Zusammenhang häufig genannt
+In Werbespots werden Achsensprünge oft verwendet um einen rasanten Effekt zu bewirken
+Bekannt ist auch eine Szene aus
+Herr der Ringe
+in welcher Sméagol mit sich selbst spricht
+Da er mit den Schnitten wechselnd von der einen zur anderen Seite spricht Achsensprung entsteht der Eindruck zweier gleich aussehender Personen womit der gespaltene Charakter der Figur unterstrichen wird
+Achsenwechsel
+Im Gegensatz zum Achsensprung handelt es sich hierbei um eine Bewegung der Kamera Steadicam oder einer Dollyfahrt über die Achse oder um eine Änderung der Bewegungsachse bzw der Blickrichtung der Figuren wodurch eine neue Achse definiert wird
+Der Achsenwechsel wird vom Zuschauer nicht als störend wahrgenommen weil sich die Bewegung fließend vollzieht
+Diese Bewegung wird mitunter auch als Crab bezeichnet
+Außerdem kann ein Zwischenschnitt in eine Totale eine Achsenüberschreitung möglich machen da so die räumliche Anordnung der Akteure für den Zuschauer deutlich wird oder der Zwischenschnitt auf einen Closeup da sich der Betrachter danach wieder neu räumlich orientiert
+Achsen im Film
+Die Handlungsachse gibt die Hauptrichtung der Handlung an
+Meist ist sie die Verbindung der Akteure bei einer Fußballübertragung die Verbindung der Tore
+Die Blickachse gibt die Blickrichtung und den Blickwinkel Verhältnis zwischen der Höhen- und Seitenachse der Figuren an
+Bei Gesprächen ist darauf zu achten dass sich die Figuren anschauen was bedeutet dass wenn eine Figur in einem Bild nach links oben schaut der Gesprächspartner im anderen Bild Gegenschuss nach rechts unten schaut
+Diese Richtungen und die beiden Winkel sollten nicht verändert werden solange sich die reale Blickrichtung bzw der Standpunkt der Figuren nicht ändert
+Die Kameraachse ist die Blickrichtung der Kamera
+Bei einer subjektiven Perspektive Point of View ist sie mit der Blickachse identisch
+Weblinks
+Erklärvideo zu Achsensprung
+DateiAlfred Hitchcock by Jack Mitchelljpg
+Sir Alfred Joseph Hitchcock KBE
+<num> August <num> in Leytonstone England
+<num> April <num> in Los Angeles Kalifornien war ein britischer Filmregisseur Drehbuchautor Filmproduzent und Filmeditor
+Er siedelte <num> in die USA über und nahm am <num> April <num> zusätzlich die amerikanische Staatsbürgerschaft an
+Hitchcock gilt hinsichtlich seines Stils bis heute als einer der einflussreichsten Filmregisseure
+Er etablierte die Begriffe Suspense und MacGuffin
+Sein Genre war der Thriller charakteristisch seine Verbindung von Spannung mit Humor
+Die wiederkehrenden Motive seiner Filme waren Angst Schuld und Identitätsverlust
+Mehrfach variierte er das Thema des unschuldig Verfolgten
+Hitchcock legte großen Wert auf die künstlerische Kontrolle über das Werk des Autors
+Sein Gesamtwerk umfasst <num> Spielfilme und gehört - gemessen am Publikumserfolg sowie der Rezeption durch Kritik und Wissenschaft - zu den bedeutendsten der Filmgeschichte
+Auch dank seiner bewussten Selbstvermarktung zählt Hitchcock heute zu den bekanntesten zeitgeschichtlichen Persönlichkeiten
+Er ist dem Autorenfilm zuzurechnen
+Am <num> Januar <num> wurde er von Königin Elisabeth II zum Knight Commander des Order of the British Empire ernannt
+Leben und Werk
+Kindheit Jugend und Ausbildung
+Alfred Hitchcock war der jüngste Sohn des Gemüsehändlers William Hitchcock <num>-<num> und dessen Ehefrau Emma Jane Whelan <num>-<num> Durch den Altersunterschied von sieben beziehungsweise neun Jahren zu seinen Geschwistern durch seine römisch-katholische Erziehung in einem von der anglikanischen Kirche geprägten Land und nicht zuletzt durch sein Äußeres - er war klein und schon als Kind korpulent - hatte er eine einsame Kindheit
+Zwischen <num> und <num> war er Schüler des St-Ignatius-College einer Londoner Jesuiten-Schule Er verließ das College mit knapp <num> Jahren und besuchte stattdessen Abendkurse auf der Londoner Universität diverse Handwerkskurse und später wenige Monate lang die School of Engineering and Navigation
+Zudem belegte er Kurse in technischem Zeichnen sowie in Kunstgeschichte
+an der Londoner Kunstakademie
+Seine Freizeit verbrachte er großteils mit dem Lesen von Fahrplänen und dem Studium von Stadtplänen und Landkarten
+Mit fortschreitendem Alter flüchtete er sich in Romane besuchte Theatervorstellungen und ging oft ins Kino
+Außerdem verfolgte er Mordprozesse im Gerichtshof Old Bailey und besuchte gerne das Black Museum von Scotland Yard
+Der Tod des Vaters Ende <num> zu dem er kein enges Verhältnis hatte band Hitchcock noch enger an seine Mutter
+<num> nahm er eine Stelle als technischer Angestellter bei der WT
+Henley Telegraph Company
+an die elektrische Leitungen herstellte
+Wegen seines zeichnerischen Talents wurde er bald in die Werbeabteilung versetzt
+Unter seinem bis zuletzt gebrauchten Spitznamen Hitch veröffentlichte er in der Betriebszeitschrift seine ersten gruseligen Kurzgeschichten
+Anstellung beim Film
+Im Frühjahr <num> hörte Hitchcock von der Neugründung eines Studios der amerikanischen Produktionsgesellschaft Paramount Famous Players-Lasky im Londoner Stadtbezirk Islington
+Er bewarb sich mit einer Mappe mit Illustrationen und wurde als Zeichner von Zwischentiteln angestellt
+In den Jahren <num> und <num> zeichnete er die Titel für mindestens zwölf Filme
+Nebenbei entwarf er Kostüme Dekorationen und Szenenbilder
+Auch durch Überarbeitungen von Drehbüchern machte er auf sich aufmerksam
+Bei zwei Filmen arbeitete er mit George Fitzmaurice zusammen dessen genaue Produktionsplanung ihn sehr beeinflusste
+<num> bekam Hitchcock Gelegenheit sich als Regisseur zu versuchen
+Mit dem Autor Seymour Hicks stellte er die letzten Filmszenen von Always Tell Your Wife fertig nachdem der ursprüngliche Regisseur gefeuert worden war
+Bald darauf konnte er einen eigenen Film drehen Number <num> in einigen Quellen Mrs
+Peabody
+der jedoch unvollendet blieb da Famous Players-Lasky im Laufe der Dreharbeiten das Studio wegen finanzieller Schwierigkeiten schließen musste
+Das leerstehende Gelände wurde an unabhängige Produzenten vermietet darunter auch an Michael Balcon der das Studio <num> schließlich erwarb
+Er stellte Hitchcock als Regieassistent ein sowie auf dessen Empfehlung die Filmeditorin Alma Reville
+Die beiden kannten sich seit <num> seitdem sie gelegentlich an denselben Filmen gearbeitet hatten
+Bis <num> entstanden fünf Filme bei denen Hitchcock dem Regisseur Graham Cutts assistierte und zu Cutts wachsendem Unmut mehr und mehr künstlerischen Einfluss gewann
+Neben dem Drehbuch kümmerte er sich auch um die Bauten das Szenenbild die Besetzung die Kostüme sowie die Ausstattung und nahm so mit der Zeit die Aufgaben eines Produktionsleiters wahr
+Hitchcocks letzte Zusammenarbeit mit Graham Cutts führte ihn <num><num> nach Deutschland
+Der unter der Beteiligung der deutschen UFA produzierte Film
+Die Prinzessin und der Geiger
+entstand in den Babelsberger Filmstudios - damals den modernsten der Welt
+Dabei hatte Hitchcock die Möglichkeit Friedrich Wilhelm Murnau bei den Arbeiten an
+Der letzte Mann
+zu beobachten von diesem beeindruckt übernahm er einige Techniken Murnaus für die Szenenbilder seiner aktuellen Produktion Durch diesen und weitere Besuche konnte Hitchcock fließend Deutsch sprechen später sprach er zum Beispiel einige Trailer seiner Filme selbst
+Zurück in England übertrug ihm Michael Balcon <num> die Regie für einen eigenen Film
+Das Projekt führte den jungen Hitchcock wieder nach Deutschland
+Nur die Münchner Lichtspielkunst Emelka fand sich bereit den Film des unbekannten Regie-Debütanten mitzuproduzieren
+Für das Melodram
+Irrgarten der Leidenschaft
+<num> verpflichtete Balcon kostspielige Stars aus Hollywood
+Alma Reville mittlerweile Hitchcocks Verlobte war als Regieassistentin und Editorin Mitglied des sehr kleinen Filmteams
+Balcon war mit Hitchcocks ambitionierter Arbeit zufrieden und vertraute ihm eine weitere deutsch-englische Koproduktion an
+Der Bergadler
+wurde noch im selben Jahr diesmal in Tirol gedreht
+Doch beide Filme die <num> beziehungsweise <num> in Deutschland in den Kinos anliefen wurden in England zunächst nicht veröffentlicht
+Der englische Verleiher und Geldgeber C M
+Woolf war im Gegensatz zu Balcon nicht von Hitchcocks betont expressionistischem Stil überzeugt
+Der Bergadler ist der einzige von Hitchcocks Filmen der nicht mehr erhalten ist
+Karriere in England
+Leben und Arbeit in England
+Mit dem <num> gedrehten Film
+Der Mieter
+um einen einzelgängerischen Pensionsgast der verdächtigt wird ein Serienmörder zu sein hatte Hitchcock sein Thema gefunden Doch nicht zuletzt wegen dessen expressionistischer Bildgestaltung lehnte es Woolf abermals ab den Film zu veröffentlichen
+Balcon zog daraufhin den jungen Ivor Montagu hinzu der Erfahrung mit Filmüberarbeitungen hatte mit Hitchcock zusammen wurden einige Änderungen vorgenommen
+Der überragende Erfolg bei einer Pressevorführung ebnete dann den Weg zur Veröffentlichung seiner ersten beiden Filme Der Mieter kam <num> in kurzer Abfolge mit Irrgarten der Leidenschaft und Der Bergadler in die Kinos und bedeutete für Hitchcock den Durchbruch als Regisseur
+Für Balcons Gainsborough Pictures drehte Hitchcock <num> noch die zwei Melodramen
+Abwärts
+und
+Easy Virtue
+Beiden Filmen war kein Erfolg beschieden
+Bereits zuvor hatte er beschlossen bei deutlich höherem Gehalt zu der neu gegründeten Firma British International Pictures BIP des Produzenten John Maxwell zu wechseln
+Dort entstand mit dem Boxerdrama
+Der Weltmeister
+sein erster Film nach einem Originaldrehbuch
+Die Presse reagierte äußerst positiv
+Obwohl die drei folgenden Stummfilme
+The Farmers Wife Champagne
+und
+Der Mann von der Insel Man
+abgesehen von einzelnen Szenen als Fingerübungen gelten hatte sich Hitchcock in Großbritannien innerhalb kurzer Zeit einen Namen gemacht Die junge britische Filmindustrie sehr darauf bedacht sich von der amerikanischen abzuheben war nur allzu gerne bereit ihn als kommenden Regiestar zu feiern
+Im Dezember <num> heirateten Alfred Hitchcock und Alma Reville die für die Hochzeit zum katholischen Glauben konvertierte
+<num> wurde ihre gemeinsame Tochter Patricia geboren
+Beruflich blieb Alma bis zum Schluss seine engste Mitarbeiterin und Beraterin
+Das Aufkommen des Tonfilms hielten viele Regisseure für das Ende ihrer Kunstform
+Hitchcock hingegen nutzte das Potential der neuen Technik
+Erpressung
+<num> wurde ursprünglich als Stummfilm produziert
+Die Produzenten erlaubten Hitchcock jedoch eine Filmrolle mit Tonmaterial nachzudrehen
+Er versah daraufhin einzelne Schlüsselszenen mit wirkungsvollen Toneffekten und gesprochenem Dialog wobei die tschechische Schauspielerin Anny Ondra die ihre Rolle stumm spielen musste von der englischen Schauspielerin Joan Barry simultan synchronisiert wurde
+Erpressung war der erste britische Tonfilm und wurde ein großer Erfolg
+Hitchcock nutzte seine gewonnene Popularität und gründete mit der Hitchcock Baker Productions Ltd eine Gesellschaft zur Vermarktung seiner Person
+Auf Geheiß seines Studios drehte er
+Juno and the Paycock
+<num> sowie einige Szenen für die Musikrevue
+Elstree Calling
+Mit
+Mord - Sir John greift ein
+fand er wieder zu seinem Thema und auch nach Deutschland zurück In Berlin stellte er die deutsche Sprachversion des Films unter dem Titel
+Mary
+her Es folgten drei Filme von denen Hitchcock nur die Komödie
+Endlich sind wir reich
+wirklich interessierte In dem zusammen mit seiner Frau und Val Valentine verfassten Drehbuch verarbeitete er unter anderem die Erfahrungen seiner noch jungen Ehe
+Den ihm aufgezwungenen Thriller
+Nummer siebzehn
+beschloss Hitchcock aus Protest zu sabotieren und zu einer wirren albernen Parodie zu machen
+Die turbulente Verbindung zwischen Humor und Spannung lässt Nummer siebzehn aus heutiger Sicht als einen Vorläufer späterer Klassiker des Genres erscheinen
+Hitchcocks Vertrag mit der British International Pictures endete nach sechs Jahren mit einem Einsatz als Produzent Lord Cambers Ladies
+Die Zusammenarbeit hatte zunehmend unter dem Konflikt zwischen Hitchcocks Streben nach künstlerischer Kontrolle und den Vorschriften des Studios gelitten
+Doch auch den folgenden Film
+Waltzes from Vienna
+ein Musical ohne Musik Hitchcock für den unabhängigen Produzenten Tom Arnold drehte er betont lustlos Ich hasse dieses Zeug
+Melodrama ist das einzige was ich wirklich kann
+Englische Meisterwerke
+Unmittelbar nach Waltzes from Vienna nahm er die fruchtbare Zusammenarbeit mit dem Produzenten Michael Balcon wieder auf
+Als erster Film für die Gaumont British entstand der Thriller
+Der Mann der zuviel wußte
+<num>
+Das Drehbuch erarbeitete Hitchcock im Wesentlichen mit seiner Frau Alma und dem Drehbuchautor Charles Bennett
+Der Film wurde sowohl von der Kritik als auch vom Publikum enthusiastisch aufgenommen
+Der humorvolle Spionagethriller
+Die <num> Stufen
+<num> Drehbuch Charles Bennett gilt als Blaupause späterer Verfolgungsthriller
+Eine turbulente Szene folgt auf die nächste es gibt keine Übergänge und kaum Zeit für den Zuschauer über die manches Mal fehlende Logik nachzudenken
+Hitchcock ordnete nach eigenem Bekunden alles dem Tempo unter
+Der überragende Erfolg des Films sollte ihm recht geben
+Es folgten
+Geheimagent
+<num> und
+Sabotage
+<num> die insbesondere in Hitchcocks eigener späterer Bewertung gegenüber den beiden Vorgängerfilmen abfielen
+Doch die psychologisch vielschichtige Behandlung des Themas Schuld weist bereits auf spätere Werke hin
+Nach Sabotage endete abrupt die zweite erfolgreiche Phase der Zusammenarbeit mit Michael Balcon als die Produktionsfirma Gaumont British von deren Besitzern geschlossen und Balcon entlassen wurde
+Die beiden folgenden Filme drehte Hitchcock daher wieder für die Gainsborough Pictures - diesmal allerdings ohne seinen ehemaligen Förderer
+Jung und unschuldig
+<num> war eine weitere unbeschwerte Variation der Geschichte vom unschuldig Verfolgten
+Der gefeierte Thriller
+Eine Dame verschwindet
+<num> spielt überwiegend in einem fahrenden Zug
+Die Dreharbeiten fanden jedoch ausschließlich in einem kleinen Londoner Studio statt was dank technisch anspruchsvoller Rückprojektionen möglich wurde
+Hitchcock festigte mit diesen sechs Filmen seine Ausnahmestellung innerhalb des britischen Kinos
+Ende der <num>er Jahre beauftragte er die Selznick-Joyce-Agentur deren Mitinhaber Myron Selznick der ältere Bruder des Hollywood-Moguls David O Selznick war seine Interessen wahrzunehmen Hitchcock dessen Ruf mittlerweile bis nach Hollywood gelangt war unterzeichnete schließlich <num> einen Vertrag für die Produktionsgesellschaft von David O Selznick der damals gerade mit der Vorproduktion zu
+Vom Winde verweht
+beschäftigt war
+In Gedanken bereits in Hollywood drehte Hitchcock in England noch einen letzten Film für die Produktionsfirma des nach England emigrierten deutschen Produzenten Erich Pommer
+Doch der Kostümfilm Riff-Piraten
+wurde von der Presse durchweg verrissen
+Hollywood und der Zweite Weltkrieg
+In seinen ersten Jahren in Hollywood stieß Hitchcock auf unerwartete Schwierigkeiten
+David O Selznick übte starke Kontrolle über die Filme seines Studios aus und achtete darauf dass sich der freiheitsliebende Hitchcock möglichst eng an die literarische Vorlage seines ersten Hollywoodfilmes hielt
+Trotz dieser Spannungen wurde
+Rebecca
+für den britischen Regisseur ein erfolgreicher Einstand in Hollywood Das psychologisch dichte und düster-romantische Melodram war <num> elfmal für den Oscar nominiert und gewann schließlich zwei der Trophäen Kamera und Produktion
+In den nächsten Jahren machte Selznick sein Geld mit Hitchcock indem er ihn für beträchtliche Summen an andere Studios auslieh
+Der Krieg in Europa weitete sich aus als der unabhängige Produzent Walter Wanger Hitchcock für ein aktuelles Kriegsdrama engagierte
+Der Auslandskorrespondent
+blieb Hitchcocks Naturell entsprechend jedoch ein weitgehend unpolitischer Spionagethriller
+Nur der nachgedrehte Schlussmonolog gerichtet an die noch neutralen USA wirkte aufrüttelnd
+Kurz nach Fertigstellung des Films wurde England von Deutschland bombardiert
+Der rechtzeitig ausgewanderte Hitchcock musste sich daraufhin scharfe Kritik von ehemaligen britischen Kollegen allen voran Michael Balcon gefallen lassen
+Mit
+Verdacht
+<num> RKO der ersten Zusammenarbeit mit Cary Grant und
+Saboteure
+<num> Universal blieb Hitchcock bei seinen klassischen Themen
+Zwischen diesen Produktionen drehte er für ihn und andere ungewohnt seine einzige Screwball-Komödie
+Obwohl damals durchaus positiv aufgenommen zeigte er sich mit
+Mr
+und Mrs Smith
+<num> RKO nicht zufrieden
+Weit mehr am Herzen lag ihm die Arbeit an dem Drama
+Im Schatten des Zweifels
+<num> Universal
+Hitchcocks Filme gelten allgemein als stark von seinem Charakter geprägt
+Dieses Familienmelodram wird als einer seiner persönlichsten Filme bezeichnet In allen Hauptfiguren spiegeln sich demnach Eigenschaften und Ängste Hitchcocks
+Als während der Dreharbeiten Hitchcocks Mutter in London starb verstärkte dies die autobiografischen Tendenzen
+Wie viele britische Regisseure leistete Hitchcock seine Beiträge für die Kriegspropaganda und drehte unter anderem Kurzfilme zur Unterstützung der französischen Résistance
+Auch in seine nächste Hollywood-Produktion arbeitete er stark propagandistische Töne ein doch sein stets bewusst irritierender Umgang mit Klischees sorgte diesmal für Kontroversen In einem kleinen Rettungsboot sehen sich englische und amerikanische Schiffbrüchige einem intellektuell überlegenen Nazi gegenüber
+Dennoch wurde der formalistisch strenge Psychothriller
+Das Rettungsboot
+<num> <num>th Century Fox dreimal für den Oscar nominiert Drehbuch Kamera und Regie
+Psychologie wichtige Komponente seines Werks stand im Mittelpunkt von
+Ich kämpfe um dich
+<num> der nach langer Zeit wieder für Selznick entstand
+Dieser war vom Thema Psychoanalyse schnell begeistert und ließ Hitchcock ungewohnt viel freie Hand doch kürzte er den Film nach der ersten Probevorführung um rund zwanzig Minuten
+Die erfolgreiche Zusammenarbeit mit Ingrid Bergman in der Hauptrolle wurde in der folgenden Produktion
+Berüchtigt
+<num> fortgesetzt die Selznick allerdings wieder an RKO verkaufte
+Die Geschichte um eine Spionin Bergman die aus Pflichtgefühl von ihrem Liebhaber Cary Grant gedrängt wird mit dem Feind zu schlafen bot für Hitchcocks Obsessionen eine breite Projektionsfläche
+Mit dem Gerichtsdrama
+Der Fall Paradin
+<num> lief der Vertrag Hitchcocks mit Selznick aus
+Selznick behielt bei der Stoffauswahl angefangen bei dieser relativ chaotisch verlaufenden Produktion die Oberhand
+Dass Hitchcock währenddessen Vorbereitungen für seine eigene Produktionsfirma traf verstärkte die Spannungen zwischen den machtbewussten Männern
+Dennoch bot Selznick Hitchcock - erfolglos - eine Vertragsverlängerung an
+Unabhängigkeit
+DateiAlfred Hitchcock NYWTSjpg Bereits im April <num> rund zwei Jahre bevor der Vertrag mit Selznick auslaufen sollte gründete Hitchcock mit dem befreundeten Kinokettenbesitzer Sidney Bernstein die Produktionsfirma Transatlantic Pictures für die er seinen ersten Farbfilm inszenierte
+Cocktail für eine Leiche
+<num> mit James Stewart in einer der Hauptrollen
+Der Film blieb jedoch vor allem wegen eines anderen Hitchcock-Experiments in Erinnerung jede Einstellung des kammerspielartigen Films dauert so lange wie es das Filmmaterial in der Kamera erlaubte also rund zehn Minuten
+Durch geschickte Übergänge sollte so der Eindruck entstehen dass sich die Geschichte in Echtzeit und von nur einer Kamera gefilmt ereignete
+Sklavin des Herzens
+<num> ein für Hitchcock untypischer melodramatischer Kostümfilm war vor allem ein Vehikel für Ingrid Bergman
+Trotz der Starbesetzung und der technischen Raffinessen wurde er kommerziell ein ähnlicher Misserfolg wie Cocktail für eine Leiche - Transatlantic ging daraufhin in Konkurs
+Nachdem sein Berater und Agent Myron Selznick <num> gestorben war wurden Hitchcocks Interessen von mehreren anderen Personen wahrgenommen bevor er <num> mit Lew Wasserman zusammentraf
+Wasserman war seit <num> Präsident der weltgrößten Künstleragentur Music Corporation of America MCA der sich Hitchcock <num> anschloss
+Es begann eine enge wie äußerst lohnende Zusammenarbeit
+Warner Brothers
+Hitchcock schloss mit Warner Bros einen lukrativen Vertrag über vier Filme ab bei denen er als Regisseur und Produzent angefangen bei der Stoffauswahl völlig freie Hand hatte Der erste dieser Filme war der Thriller
+Die rote Lola
+<num> mit Marlene Dietrich der im Londoner Theatermilieu spielte
+Eines seiner Lieblingsmotive stellte er auf den Kopf am Ende entpuppt sich der unschuldig Verfolgte als der wahre Mörder
+Hitchcock drehte in seiner Heimat spürte allerdings wieder die alten Ressentiments die nach seiner Auswanderung entstanden waren
+Der Film selbst war nicht sonderlich erfolgreich
+Im April <num> begann Hitchcock regelmäßige Kolloquien an den Universitäten von Kalifornien und Südkalifornien abzuhalten in denen unter anderem Previews seiner aktuellen Filme gezeigt wurden
+Diese Tradition sollte er die kommenden <num> Jahre beibehalten
+Der Fremde im Zug
+<num> nach einem Roman von Patricia Highsmith brachte schließlich nach fünf Jahren Flaute wieder einen überragenden Erfolg
+Mit diesem Film begann die dreizehnjährige Zusammenarbeit mit dem Kameramann Robert Burks
+Wie schon in Die rote Lola spielte Hitchcocks Tochter Patricia eine Nebenrolle
+<num> folgte mit
+Ich beichte
+der eindeutigste filmische Bezug auf Hitchcocks starke katholische Prägung
+Obwohl von der Kritik geschätzt floppte der Film an den Kinokassen was Hitchcock vor allem der Humorlosigkeit des Publikums anlastete
+Als Anfang der <num>er Jahre das Fernsehen Einzug in die Wohnzimmer hielt versuchte die Kinoindustrie mit neuen technischen Verfahren wie dem Breitbildformat Cinemascope oder dem <num>D-Verfahren den Zuschauerschwund aufzuhalten
+So drängte Warner Bros
+Hitchcock seinen nächsten Film in <num>D zu drehen
+Über diese Entscheidung die zur Einschränkung der Bewegungsfreiheit der Kamera führte war Hitchcock nicht glücklich er setzte auch nur wenige explizite <num>-D-Effekte ein
+Bei Anruf Mord
+<num> ist die Verfilmung eines damals sehr populären Theaterstücks von Frederick Knott der auch das Drehbuch schrieb
+Mit Hauptdarstellerin Grace Kelly drehte Hitchcock im Anschluss noch zwei weitere Filme ehe sie sich aus dem Filmgeschäft zurückzog
+Paramount
+Die Erfahrung mit dem aufgezwungenen <num>D-Verfahren zeigte Hitchcock die Grenzen bei Warner Brothers
+Er schloss daher <num> einen Vertrag mit Paramount ab der ihm völlige künstlerische Freiheit garantierte
+<num> begann die für Hitchcock erfolgreichste Zeit mit
+Das Fenster zum Hof
+Neben Grace Kelly ist ein weiteres Mal James Stewart zu sehen
+Die Hauptfigur sitzt während des gesamten Films im Rollstuhl und beobachtet durch ein Teleobjektiv das Geschehen in den gegenüberliegenden Wohnungen - sozusagen stellvertretend für den Zuschauer aber auch stellvertretend für Hitchcock selbst der in diesem Film den voyeuristischen Aspekt des Filmemachens aufzeigt
+Über den Dächern von Nizza
+<num> ist ein leichter romantischer Thriller in dem neben Grace Kelly - nach zwei Jahren Filmpause - wieder Cary Grant spielte
+Wohl um dem Glamour dieses an der Côte dAzur angesiedelten Films etwas entgegenzusetzen drehte Hitchcock noch im selben Jahr die kostengünstig produzierte schwarze Komödie
+Immer Ärger mit Harry in der Shirley MacLaine neben John Forsythe ihren ersten Filmauftritt hatte
+Edmund Gwenn der bereits in früheren Hitchcock-Filmen mitgewirkt hatte spielte fast achtzigjährig eine seiner wenigen Hauptrollen
+Obwohl Hitchcock in vielen seiner Filme schwarzen Humor untergebracht hat ist es eine der wenigen echten Komödien von ihm
+<num> nahm Hitchcock - rund fünf Jahre nach seiner Frau - die amerikanische Staatsbürgerschaft an
+Im selben Jahr begann er mit Doris Day und James Stewart die Dreharbeiten zu
+Der Mann der zuviel wußte
+<num> dem einzigen Remake eines seiner Filme in seiner Karriere
+Ebenfalls <num> startete die wöchentliche Fernsehserie
+Alfred Hitchcock Presents
+ab <num> The Alfred Hitchcock Hour
+Hitchcock war Produzent trat in vielen Folgen als Moderator auf und inszenierte insgesamt <num> Folgen
+Auch für die Fernsehserien
+Suspicion
+und
+Startime
+nahm er für je eine Folge im Regiestuhl Platz
+Nach zehn Jahren beendete er seine Fernseharbeit an der er zunehmend das Interesse verloren hatte
+Hinzu kam dass die Produktion den Auftraggebern zu teuer wurde und die Zeit von Serien mit jeweils abgeschlossenen Folgen sogenannten Anthologies zu Ende ging
+Mit
+Der falsche Mann
+wurde er <num> einem seiner Grundprinzipien der strikten Trennung von Leben und Fiktion untreu
+In dem Schwarzweißfilm mit Henry Fonda und Vera Miles wird an authentischen Schauplätzen die auf Tatsachen beruhende Geschichte eines zu unrecht Verurteilten erzählt
+Der Film entstand noch einmal für Warner Bros da Hitchcock dem Studio bei seinem Ausscheiden noch einen Film ohne Regiegage zugesagt hatte
+Allerdings war Der falsche Mann der viele Stilelemente des Film noir und ein trostloses Ende aufweist kommerziell ein Flop
+Höhepunkt und Wende
+<num> drehte Hitchcock seinen letzten Film für Paramount
+Vertigo - Aus dem Reich der Toten
+<num> veröffentlicht
+Das Drehbuch entstand in gemeinsamer intensiver Arbeit von Hitchcock und Samuel A Taylor
+In wenige seiner Filmfiguren projizierte Hitchcock wohl so viel von seiner eigenen Persönlichkeit wie in den von James Stewart verkörperten Scottie Ferguson der versucht eine Frau nach seinen Vorstellungen umzuformen
+Zu seiner Entstehungszeit nicht besonders erfolgreich zählt der Film inzwischen - ähnlich wie der folgende
+Der unsichtbare Dritte
+- zu den bedeutendsten Werken Hitchcocks Hitchcock und sein Drehbuchautor Ernest Lehman konzipierten Der unsichtbare Dritte <num> MGM als eine Abfolge von Abenteuern in denen ein Unschuldiger Cary Grant in seinem letzten Hitchcock-Film um seine Reputation und sein Leben kämpft
+Die elegante Leichtigkeit der Erzählung beeinflusste viele nachfolgende Abenteuer- und Agentenfilme was sich u a in den James-Bond-Filmen der darauf folgenden Jahre zeigt
+Für Hitchcock selbst blieb es für lange Zeit der letzte vorwiegend heitere Film
+Das im Anschluss vorbereitete Projekt mit Audrey Hepburn in der Hauptrolle wurde durch Hitchcock gestoppt als Hepburn wegen einer geplanten Vergewaltigungsszene absagte Mit seiner bewusst kostengünstigen Produktion
+Psycho
+<num> folgte Hitchcocks wohl bekanntester Film Die in einer Woche Dreharbeit entstandene Duschszene zählt heute zu seinen meistanalysierten Filmszenen
+Ungewöhnlich war auch der Tod einer Hauptfigur nach nur einem Drittel des Films
+Die zeitgenössischen Kritiken fielen unerwartet barsch aus doch das Publikum machte Psycho zu Hitchcocks größtem kommerziellen Erfolg
+Nachdem zwei angedachte Projekte scheiterten - unter anderem weil Walt Disney dem Psycho-Regisseur die Dreherlaubnis in Disneyland verweigerte - nahm Hitchcock seinen nächsten Film erst Mitte <num> in Angriff
+Die Vögel
+<num> ein weiterer Horrorfilm der nicht zuletzt durch seine Dramaturgie und die eingesetzte Tricktechnik - etwa den Sodium Vapor Process - stilbildend wirkte
+Der deutsche Komponist Oskar Sala setzte statt Filmmusik elektronisch erzeugte Geräusche ein
+Seine Hauptdarstellerin Tippi Hedren hatte Hitchcock im Werbefernsehen entdeckt
+Obwohl sie keine Filmerfahrung besaß nahm er sie für die nächsten sieben Jahre unter Vertrag
+Die Vögel entstand für Universal die kurz zuvor teilweise von MCA übernommen worden waren und für die Hitchcock von nun an alle seine Filme drehen sollte
+Lew Wasserman bis zu diesem Zeitpunkt Agent Hitchcocks wurde Präsident von Universal und gab seine Agententätigkeit auf
+Hitchcock selbst trat seine Rechte an Psycho und seiner Fernsehserie ab und wurde im Gegenzug der drittgrößte Aktionär von MCA
+Nach Die Vögel gibt es in Hitchcocks Werk einen Bruch
+Die folgenden drei Filme der <num>er Jahre blieben künstlerisch und kommerziell hinter den vorangegangenen Erfolgen zurück
+Konflikte mit seiner Hauptdarstellerin Tippi Hedren prägten die Dreharbeiten so weit dass er das Gelingen seines nächsten Films
+Marnie
+<num> bewusst zu sabotieren schien Das Psychogramm einer verstörten traumatisierten Frau bedient sich psychologischer Erklärungsmodelle die überholt und undifferenziert wirken und enthält für Hitchcock untypisch viele handwerkliche Fehler
+Dieser erste künstlerische und kommerzielle Misserfolg seit rund fünfzehn Jahren war in mehrfacher Hinsicht ein Wendepunkt in Hitchcocks Karriere
+Tippi Hedren war die letzte typische Hitchcock-Blondine Marnie der letzte Film den Hitchcocks langjähriger Kameramann Robert Burks drehte Kurz nach Abschluss der Dreharbeiten verstarb zudem Hitchcocks Filmeditor George Tomasini mit dem er zehn Jahre lang zusammengearbeitet hatte
+Das Spätwerk
+Erfolge und eine Rückkehr in die Heimat
+Filmproduktionen wurden immer aufwendiger der Erfolg an der Kinokasse immer wichtiger
+Diverse Projekte die Hitchcock reizten und die er mehr oder weniger intensiv plante kamen so aus Angst der Produzenten nicht zustande - etwa Mary Rose die geplante Verfilmung eines skurrilen Theaterstücks Mit RRRR einem Drehbuch mit zahlreichen Verwicklungen über eine italienische Ganoven-Familie in New York wollte er Jahre nach Der unsichtbare Dritte wieder einen komischen Thriller drehen und damit alle Nachahmer Charade
+Topkapi
+und andere übertreffen
+Das weit fortgeschrittene Projekt scheiterte schließlich an unüberbrückbaren sprachlichen und kulturellen Problemen mit den italienischen Mitarbeitern
+Am <num> März <num> erhielt Hitchcock für seinen historischen Beitrag zum amerikanischen Kino den Milestone Award der Producers Guild Of America - die erste von vielen Ehrungen für sein Lebenswerk
+Mit
+Der zerrissene Vorhang
+<num> kehrte Hitchcock schließlich zum Genre des Spionagefilms zurück in dem er bereits in den <num>er Jahren in England große Erfolge gefeiert hatte
+Die Premiere dieses <num> Hitchcock-Filmes sollte von einer groß angelegten Marketingkampagne begleitet werden
+Nicht nur aus diesem Grund setzte Universal die aktuellen Stars Paul Newman und Julie Andrews gegen Hitchcocks Widerstand als Hauptdarsteller durch
+Überdies kam es zum Bruch mit dem Komponisten Bernard Herrmann als dieser nicht die von Universal gewünschte auch für den Schallplattenverkauf geeignete Unterhaltungsmusik vorlegte
+Auch an anderen wichtigen Positionen seines Stabes musste Hitchcock auf vertraute Mitarbeiter verzichten
+Der zerrissene Vorhang fällt handwerklich und dramaturgisch gegenüber Hitchcocks letzten Filmen einschließlich Marnie deutlich ab und wurde von der Kritik durchweg verrissen
+Universal forderte von ihm zeitgemäßere Themen ein
+Als das von ihm und Howard Fast detailliert ausgearbeitete Drehbuch über einen homosexuellen Frauenmörder abgelehnt wurde zog er sich für ein Jahr ins Privatleben zurück Anfang <num> entschloss er sich unter dem Druck der langen Pause seit dem letzten Film und der noch längeren Zeitspanne seit dem letzten Erfolg den Spionageroman
+Topas
+von Leon Uris zu verfilmen dessen Rechte Universal kurz zuvor erworben hatte
+Topas wurde dann fast ausschließlich mit europäischen Schauspielern besetzt und völlig ohne Hollywood-Stars
+In Europa waren die Französinnen Dany Robin und Claude Jade wie ihre Landsmänner Michel Piccoli und Philippe Noiret und die deutsche Aktrice Karin Dor Stars die für amerikanische Zuschauer bekanntesten Gesichter waren der Fernsehschauspieler John Forsythe und der aus Kanada stammende John Vernon
+Das endgültige Drehbuch wurde erst während der laufenden Dreharbeiten geschrieben der Schluss nach einer katastrophalen Preview improvisiert
+Publikum und Kritik reagierten mit Ablehnung auf Hitchcocks bis dahin teuersten Film doch er zeigte sich zuversichtlich Ich habe meinen letzten Film noch nicht gedreht
+Topas
+ist mein <num> Film aber wann ich meinen letzten Film drehen werde ist von mir meinen Finanziers und Gott noch nicht entschieden worden
+Im Spätsommer <num> nahm Hitchcock sein nächstes Projekt in Angriff und reiste dafür wieder in seine Heimat wo er diesmal begeistert empfangen wurde
+Frenzy
+<num> spielt in London dem Hitchcock eine liebevolle Hommage erweist und ist in seinen Worten die Geschichte eines Mannes der impotent ist und sich deshalb durch Mord ausdrückt Zunächst verliefen die Drehbucharbeit und auch die Dreharbeiten die Hitchcock so ernst nahm wie lange nicht mehr weitgehend reibungsfrei
+Doch als seine Frau Alma einen Herzinfarkt erlitten hatte wurde Hitchcock müde und untätig die Crew war ähnlich wie bei den drei vorangegangenen Filmen wieder weitgehend auf sich alleine gestellt Dennoch wurde Frenzy ein brutaler zum Teil bitterer von tiefschwarzem britischen Humor durchzogener Film und ein großer Erfolg
+Nur in England war man enttäuscht und bemängelte vor allem die anachronistisch wirkende Darstellung von London und des britischen Lebens
+Der letzte Film
+Im Frühjahr <num> entschloss sich Hitchcock den Roman The Rainbird Pattern von Victor Canning zu verfilmen
+Doch die Arbeit am Drehbuch mit Ernest Lehman Der unsichtbare Dritte ging diesmal nicht mehr so reibungslos vonstatten Hitchcock war merklich müde geworden seine körperlichen Schmerzen betäubte er zunehmend mit Alkohol
+Zwei Jahre benötigte die Fertigstellung des Drehbuchs so lange wie nie zuvor in seiner Karriere
+Mit
+Familiengrab wie der Film schließlich hieß kehrte Hitchcock zum scheinbar heiteren diesmal jedoch morbid akzentuierten Unterhaltungsthriller zurück
+Wie stets legte er Wert auf eine ausgeklügelte Bildsprache die erneut mit Hilfe von Storyboards erarbeitet wurde Die Dreharbeiten gestalteten sich reibungslos und in einer entspannten Atmosphäre
+Hitchcock der sich im Rahmen seiner gesundheitlichen Möglichkeiten mit einem lange nicht gezeigten Elan in die Dreharbeiten einbrachte zeigte sich zu Neuerungen bereit Er war offen für Improvisationen seiner Schauspieler und nahm noch während der Dreharbeiten Änderungen am Ablauf vor
+Die Überwachung der Schnittarbeiten musste er weitgehend seinen Mitarbeiterinnen Peggy Robertson und Suzanne Gauthier überlassen da sich sein Gesundheitszustand deutlich verschlechterte
+Zudem erlitt Alma einen zweiten Schlaganfall
+Familiengrab wurde nach seiner Premiere im Frühjahr <num> überwiegend freundlich aufgenommen und Hitchcock schöpfte aus der Sympathie die ihm entgegenschlug für kurze Zeit Kraft neue Filmideen aufzugreifen
+Sein erst Anfang <num> in Angriff genommenes Projekt die Verfilmung des Romans The Short Night von Ronald Kirkbride wurde aufgrund seines sich weiter verschlechternden Gesundheitszustands jedoch etwa ein Jahr später von Universal gestoppt
+Im März <num> wurde er vom American Film Institute für sein Lebenswerk geehrt
+Zwei Monate später schloss er sein Büro auf dem Gelände der Universal-Studios
+Am <num> Januar <num> wurde Hitchcock in den britischen Adelsstand erhoben
+Am Morgen des <num> April <num> starb Alfred Hitchcock in seinem Haus in Los Angeles an Nierenversagen
+Seine Leiche wurde eingeäschert die Asche an einem unbekannten Ort verstreut
+Inhalte und Formen
+In rund fünfzig Jahren hat Alfred Hitchcock dreiundfünfzig Spielfilme als Regisseur begonnen und beendet
+Die weitaus größte Zahl dieser Filme gehört dem Genre des Thrillers an und weist ähnliche Erzählmuster und Motive auf wiederkehrende Elemente visuelle Stilmittel und Effekte die sich wie ein roter Faden durch sein Gesamtwerk ziehen
+Inhalt
+Motive
+Das Grundmotiv in Hitchcocks Filmen bildet meist die Angst der Protagonisten vor der Vernichtung ihrer bürgerlichen Existenz
+Dabei bezieht sich diese Angst nicht nur auf Mörder Gangster oder Spione welche die bürgerliche Ordnung angreifen die Hauptfiguren finden sich häufig in der Lage wieder sogar von Vertretern des Gesetzes bedroht zu werden
+Zu diesem Motiv der Angst kommt - Hitchcocks katholischer Prägung entsprechend - jenes von Schuld und Sühne hinzu
+Der unschuldig Verfolgte in seinen Filmen ist unschuldig aber nur in Bezug auf das was man ihm vorwirft Das heißt die Figur wird durch das was ihr im Laufe des Filmes widerfährt im übertragenen Sinne für andere Defizite oder Vergehen bestraft In Bei Anruf Mord etwa wird die Hauptfigur des Mordes verdächtigt tatsächlich musste sie aus Notwehr töten
+Das folgende Unheil kann jedoch als Strafe für den von ihr begangenen Ehebruch angesehen werden
+Eine Variation dieses Themas ist die Übertragung der Schuld auf eine andere Person
+Unschuldige werden zu Schuldigen oder Mitschuldigen an Verbrechen anderer da sie aus persönlichen Gründen nicht zur Aufklärung beitragen können
+Zentral sind hierbei die beiden Filme Ich beichte und Der Fremde im Zug in denen die jeweiligen Protagonisten von Morden die andere begangen haben profitieren und nachdem sie selbst unter Verdacht geraten keine Möglichkeit haben sich zu entlasten
+In Vertigo macht der wahre Mörder die Hauptfigur durch ein Komplott zunächst scheinbar zum Schuldigen am Tod der ihr anvertrauten Person
+Später macht sich das Opfer der Intrige tatsächlich am Tod der Frau schuldig die er liebt
+Falsche Verdächtigungen aber auch ausgeprägte Schuldkomplexe gehen bei Hitchcocks Filmen mit der Bedrohung der Identität einher
+Seine traumatisierten oder verfolgten Figuren nehmen selbst falsche Namen an oder werden - aus unbekannten Gründen - für jemand anderen gehalten
+Das Motiv des Identitätsverlusts spielt Hitchcock angefangen von seinem ersten bis zu seinem letzten Film in unterschiedlichsten Varianten durch besonders einprägsam in Vertigo Die weibliche Hauptfigur wird zunächst im Rahmen eines Mordkomplotts in eine andere Person die anschließend ermordet wird verwandelt und nimmt daraufhin wieder ihre eigentliche Identität an nur um anschließend wieder in die andere Person zurückverwandelt zu werden
+Oft stehen Schuld und Bedrohung in Zusammenhang mit sexuellen Aspekten
+In Der Fall Paradin genügt bereits der Gedanke an Ehebruch um das Leben des Protagonisten zu gefährden
+In Berüchtigt ist der Zusammenhang zwischen Sex Schuld und Bedrohung zentrales Thema
+Hitchcocks Verbindung von Sex und Gewalt wird in Mordszenen deutlich die er oft wie Vergewaltigungen inszeniert etwa der Schlusskampf zwischen Onkel und Nichte Charlie in Im Schatten des Zweifels die Scherenszene in Bei Anruf Mord und die Duschszene in Psycho
+Darüber hinaus spielt Sexualität gerade in abnorm empfundenen Erscheinungsformen eine große Rolle in seinem Werk
+Aufgrund der Auflagen der Zensur werden jedoch Homosexualität die in Verbindung mit Schuld und Verderben regelmäßig vorkommt oder Nekrophilie in Vertigo nur in einzelnen Gesten oder Schlüsselszenen angedeutet Auch Fetischismus Erpressung Vertigo Psycho und Voyeurismus Das Fenster zum Hof Psycho spielen in seinen Filmen eine gewisse Rolle
+In mehreren Filmen wird zudem ein erotischer Bezug der männlichen Hauptfiguren zu ihren Müttern angedeutet etwa in Psycho und Die Vögel Zentral in diesem Zusammenhang ist Berüchtigt
+Hier verhalten sich Claude Rains und Leopoldine Konstantin in manchen Schlüsselszenen wie ein Ehepaar
+Dieser Eindruck wird durch den geringen Altersunterschied der Schauspieler von nur vier Jahren verstärkt
+Unter den in Hitchcocks Bildsprache verwendeten Symbolen finden sich Vögel als Vorboten des Unglücks etwa in Erpressung später als vorherrschendes Thema in Die Vögel Treppen die Verlust oder Freiheit bedeuten können Berüchtigt Psycho Vertigo und andere sowie Handschellen und andere Fesseln um Abhängigkeit und Ausgeliefertsein auszudrücken meist im sexuellen Kontext zum Beispiel in Der Mieter Auch Spiegel tauchen bei Hitchcock regelmäßig auf - in Zusammenhang mit dem Verlust oder der Erkenntnis der eigenen Persönlichkeit oder als allgemeines Symbol für Täuschungen einprägende Beispiele Vertigo und Psycho
+Figuren
+Die meisten Protagonisten in Hitchcocks Thrillern sind Normalbürger die zu Beginn der Geschichte in der Regel nichts mit kriminellen Machenschaften zu tun haben
+Meist werden sie durch Zufall oder unbekannte Umstände in geheimnisvolle und bedrohliche Vorgänge gezogen
+Dem Zuschauer wird so das beunruhigende Gefühl vermittelt dass auch er jederzeit in derartige Situationen geraten könnte
+Professionelle Agenten oder Spione findet man dagegen nur selten unter den Hauptfiguren obwohl Hitchcock viele Filme drehte die im Agentenmilieu spielen
+Hitchcock drehte bis auf eine Ausnahme Erpressung <num> auch nie einen Film in dem die Arbeit der Polizei im Mittelpunkt steht aktive Polizisten tauchen ansonsten nur als Nebenfiguren und üblicherweise als Hindernis auf
+Männliche Antihelden
+Der Prototyp des Antihelden bei Hitchcock sind die von James Stewart gespielten Figuren In Cocktail für eine Leiche muss der von Stewart dargestellte Lehrer erkennen dass zwei seiner Studenten eine seiner Theorien zum Anlass nahmen einen Mord zu verüben und diesen mit seinen Thesen zu rechtfertigen am Ende steht er hilflos vor diesem menschlichen Abgrund in den er nicht nur hineingezogen wurde sondern den er sogar mit heraufbeschworen hat
+In Das Fenster zum Hof stellt Stewart eine Figur dar die bindungsscheu sowie körperlich beeinträchtigt und voyeuristisch veranlagt ist und dadurch in Schwierigkeiten kommt
+Es gibt nur wenige positive ungebrochene Helden bei Hitchcock
+Ein Schauspieler der diesen seltenen Rollentypus verkörperte war Cary Grant in Über den Dächern von Nizza und in Der unsichtbare Dritte
+Diese Figuren meistern die Herausforderungen zwar mit Charme und Leichtigkeit doch stehen sie in Verdacht kriminell zu sein beziehungsweise verlieren sie zeitweise die Kontrolle womit selbst sie keine gänzlich unantastbaren Helden sein können
+Aber sogar Cary Grant spielt in zwei seiner Hitchcock-Filme Figuren deren Schattenseiten sich zeitweise vor deren positive Merkmale schieben
+Im Laufe der Karriere Hitchcocks gewinnen ambivalente oder gar negativ gezeichnete Hauptfiguren immer stärker an Gewicht
+Diese Antihelden weisen physische oder psychische Probleme auf sind Verlierertypen oder unsympathisch
+Durch ihr obsessives Fehlverhalten wirken sie schwach und können Schaden anrichten
+Diese Figuren dienen zwar kaum als Vorbild doch soll deren ambivalente Persönlichkeit dazu beitragen dass sich der Zuschauer in ihnen wiederfinden kann
+Starke Frauen
+In vielen Filmen bedient Hitchcock auf den ersten Blick das klassische Motiv der schwachen zu beschützenden Frau
+Doch während das Klischee verlangt dass der strahlende Held sie rettet ist sie bei Hitchcock oft auf sich alleine gestellt
+In einigen Fällen ist der vermeintliche Beschützer schwach oder zu sehr mit sich selbst beschäftigt als dass er der bedrohten Frau helfen könnte wie zum Beispiel Ingrid Bergman und Cary Grant in Berüchtigt
+In anderen Fällen geht von der männlichen Hauptfigur in der Regel dem Ehemann sogar ein tatsächliches oder vermeintliches Bedrohungspotential aus
+Klassische Beispiele Joan Fontaine und Cary Grant in Verdacht sowie Grace Kelly und Ray Milland in Bei Anruf Mord
+Die Rollenverteilung zwischen Mann und Frau kehrt Hitchcock in einigen Filmen gänzlich um Die Frau ist dem Mann der zunehmend passiver wird überlegen und wendet das Geschehen zum Guten
+Beispiele sind Jung und unschuldig die Tochter des Polizeichefs verhilft einem Verdächtigen zur Flucht und löst letztendlich den Fall Ich kämpfe um dich eine Psychologin dringt in das Unterbewusste des Mordverdächtigen ein und rettet ihn vor der sicheren Verurteilung sowie Der Mann der zuviel wußte die Ehefrau verhindert zuerst einen geplanten Mord und rettet dann das eigene Kind vor den Verbrechern
+Der Typ der sich dabei im Laufe der Zeit herauskristallisierte ist jener der jungen schönen kühlen hintergründigen und undurchsichtigen Blondine Die oberflächliche Kühle der Hitchcock-Blondine verbirgt jedoch eine stark entwickelte Sexualität
+Besonders deutlich wird dies in Der unsichtbare Dritte wenn Eva Marie Saint zunächst gegenüber Cary Grant zweideutige Bemerkungen macht dann plötzlich den völlig überraschten Fremden küsst und ihn ohne Zögern in ihrem Schlafwagenabteil unterbringt
+Nicht der Mann sondern die blonde Frau spielt hier den aktiven Part und zeigt damit die Fragilität des männlichen bürgerlichen Weltbildes
+Sympathische Schurken
+Hitchcock legt durch seine Gestaltung von Figuren und Dramaturgie dem Zuschauer eine Identifikation mit dem Schurken nahe
+Seine Antagonisten wirken zuweilen auffällig sympathisch und übertreffen mitunter die Ausstrahlung der Hauptfiguren
+Oft konkurrieren Held und Bösewicht um dieselbe Frau die Liebe des Gegenspielers erscheint dabei tiefer und aufrichtiger als die des Helden
+Besonders auffällig ist dies in Berüchtigt Claude Rains gegenüber Cary Grant und in Der unsichtbare Dritte James Mason wiederum gegenüber Cary Grant
+Selbst ein ausgesprochen heimtückischer Schurke wie Ray Milland in Bei Anruf Mord wirkt in einzelnen Momenten gegenüber dem unbeholfenen Robert Cummings sympathischer in jedem Fall jedoch gegenüber der Polizei vertrauenserweckender
+Oft sind sie die eigentlichen Hauptfiguren wie Joseph Cotten als charmanter Witwenmörder in Im Schatten des Zweifels oder Anthony Perkins als linkischer von seiner Mutter gepeinigter Mörder in Psycho
+Dominante Mütter
+In vielen seiner Filme - ab Mitte der <num>er Jahre regelmäßig - tauchen dominante Mütter auf die einen beunruhigenden Einfluss auf ihre meist erwachsenen Kinder ausüben und zum Teil Auslöser oder Ursache dramatischer Ereignisse sind
+Erstmals uneingeschränkt bösartig erscheint die Mutter in Berüchtigt <num> die ihren Sohn zum Mord an der Frau die er liebt antreibt
+Der extremste Fall tritt in Psycho <num> zutage wo die tote Mutter noch von ihrem Sohn Besitz ergreift und ihn zu ihrem mordenden Werkzeug werden lässt
+Daneben gibt es eine Vielzahl weniger dämonischer Variationen wobei Besitzergreifung allen Mutter-Typen gemein ist In Die Vögel <num> erträgt es die Mutter von Mitch Jessica Tandy nicht dass ihr erwachsener Sohn Rod Taylor sich für eine andere Frau interessiert
+In Marnie <num> wird das Leben der Tochter durch einen von der Mutter übertragenen Schuldkomplex beinahe zerstört
+In zwei Filmen variiert Hitchcock dieses Rollenmuster In Rebecca und Sklavin des Herzens übernehmen Haushälterinnen die Funktion der dämonischen Mutter
+Zwielichtige oder leichtgläubige Beamte
+Üblicherweise positiv besetzte Figuren wie Polizisten Richter oder andere Vertreter des Staates erscheinen oft zwiespältig Sie sind nicht in der Lage die Helden zu beschützen oder stellen sogar eine Bedrohung für diese dar
+Polizisten verdrehen das Recht sie handeln aus persönlichen Motiven sie glauben dem ersten Anschein und schützen den tatsächlich Schuldigen aufgrund von dessen vordergründig tadellosem Erscheinen sie sind tollpatschig oder arbeiten schlampig
+Dieses Rollenmuster durchzieht Hitchcocks gesamtes Werk von Der Mieter <num> bis Frenzy <num>
+Darüber hinaus finden sich vereinzelt Geheimdienstmitarbeiter unter den Nebenfiguren die sich als Gegner das Ehepaar Drayton in Der Mann der zuviel wußte <num> oder als Helfer offenbaren wobei auch letztere Schwierigkeiten bringen können - beispielsweise der General Peter Lorre in Geheimagent oder Leo G Carroll als CIA-Mitarbeiter in Der unsichtbare Dritte
+Indem die feste Trennlinie zwischen Gut und Böse verschwimmt wird das Gefühl der Verunsicherung beim Zuschauer gesteigert
+Formale Elemente
+Dramaturgie
+Hitchcocks Credo lautete For me the cinema is not a slice of life but a piece of cake etwa Für mich ist das Kino nicht ein Stück aus dem Leben sondern ein Kinderspiel Film war für ihn eine artifizielle Kunstform
+Nur einmal - in Der falsche Mann - wich er von diesem Grundsatz ab
+Aber auch hier liegt der Akzent auf jenen Elementen die nicht dokumentarisch sind - etwa der subjektiven Perspektive des unschuldig Verdächtigten und seiner hilflosen Frau
+Einigen seiner weiteren Filme liegen zwar auch reale Ereignisse zugrunde Der zerrissene Vorhang Das Fenster zum Hof Der Auslandskorrespondent oder Cocktail für eine Leiche doch werden diese so weit fiktionalisiert dass außer dem Grundmotiv kein Bezug zu der ursprünglichen Geschichte übrig bleibt
+Eine nicht verwirklichte Idee für Der unsichtbare Dritte die der Regisseur im Interview mit Truffaut erwähnt verdeutlicht Hitchcocks Vorstellungen davon die Realität zu transzendieren Er wollte zeigen wie unter den Augen Cary Grants auf einem Fließband ein Auto zusammengebaut wird und anschließend aus dem fertiggestellten Auto eine Leiche fällt - nach realistischen Maßstäben unmöglich
+Doch Hitchcocks Begründung für das Verwerfen der Idee zeigt dass er sich in solchen Fragen nicht an der Wahrscheinlichkeit orientierte Wir haben die Idee in der Geschichte nicht richtig unterbringen können und selbst eine willkürliche Szene kann man nicht ohne Motiv ausführen Den Vorwurf Gesetze der Plausibilität zu missachten nahm er bewusst in Kauf Wenn man alles analysieren wollte und alles nach Erwägungen der Glaubwürdigkeit und Wahrscheinlichkeit konstruieren dann würde keine Spielfilmhandlung dieser Analyse standhalten und es bliebe einem nur noch eines übrig Dokumentarfilme zu drehen Hitchcock vertraute darauf dass die Zuschauer unwahrscheinliche Details akzeptieren würden da er diese nur verwendete um die Handlung zu dramatisieren voranzutreiben oder zu straffen
+Für bewusste Irritation sorgte auch Hitchcocks Spiel mit filmtypischen Klischees
+So vermied er es insbesondere bei den Nebenrollen Schauspieler nach festgelegtem Typ zu besetzen
+Auch bei der Wahl seiner Spielorte entzog sich Hitchcock den Genre-Gesetzen
+So ließ er Verbrechen und bedrohliche Szenen häufig nicht in unheimlichen dunklen Räumen stattfinden sondern bei hellem Tageslicht und an scheinbar harmlosen Orten wie einem mit Menschen übersäten Marktplatz Der Mann der zuviel wußte <num> und Der Auslandskorrespondent in einer menschenleeren Landschaft auf einer öffentlichen Versteigerung und in einer Hotelhalle Der unsichtbare Dritte auf einer idyllischen Bergstraße Über den Dächern von Nizza auf einer Party Berüchtigt und Jung und unschuldig in einer voll besetzten Konzerthalle beide Der Mann der zuviel wußte oder in einem mit lauter freundlichen Menschen besetzten Eisenbahnzug Eine Dame verschwindet
+Suspense
+Die klassische auf das Überraschungsmoment aufbauende Form des Kriminalfilms ist der Whodunit
+Bis auf wenige Ausnahmen bediente sich Hitchcock jedoch einer anderen Form des Spannungsaufbaus des sogenannten Suspense Dem Zuschauer sind ab einem gewissen Zeitpunkt bestimmte Informationen oder Umstände bekannt von denen die handelnden Personen nichts wissen
+Er fiebert in besonderer Weise mit den Helden er sieht Ereignisse kommen möchte den Figuren helfen kann es aber nicht
+In einigen Filmen wird das klassische Suspense dahingehend variiert dass handelnde Personen die Rolle des Zuschauers übernehmen
+Ein Beispiel von vielen In Das Fenster zum Hof dringt Lisa in die Wohnung des verdächtigen Nachbarn ein um nach Beweisen für einen möglichen Mord zu suchen
+Ihr Partner Jeff beobachtet das Geschehen von der gegenüber liegenden Wohnung aus und sieht dabei den Nachbarn vorzeitig zurückkommen
+Er vermutet sie in Lebensgefahr kann ihr aber nicht helfen
+Für einige markante Szenen baute Hitchcock zudem bewusst eine Suspense-Situation auf um den Zuschauer mit einem umso gewaltigeren Überraschungseffekt schockieren zu können
+Ein berühmtes Beispiel findet sich in Psycho Zum einen ist Marion Crane mit verschiedenen Insignien einer typischen Hauptfigur eines Hitchcockfilms ausgestattet so dass kaum jemand erwartet dass sie bereits in der ersten Hälfte des Films stirbt
+Zum anderen schaltet Hitchcock der Duschszene selbst einen Suspense-Moment vor
+Norman Bates beobachtet Marion Crane durch ein Loch in der Wand beim Entkleiden
+Sie geht unter die Dusche
+Der Zuschauer wird nun eben keinen Mord sondern schlimmstenfalls eine Vergewaltigung durch Norman befürchten
+Der bestialische Mord ist somit völlig überraschend und damit ein Grund für die Berühmtheit der Szene
+MacGuffin
+Ein von Hitchcock in seinen Thrillern sehr häufig verwendetes Mittel war der sogenannte MacGuffin ein Element das die Handlung vorantreibt oder sogar initiiert obwohl es für die Entwicklung der Figuren und für den Zuschauer inhaltlich völlig bedeutungslos geradezu austauschbar ist
+Der MacGuffin in Der unsichtbare Dritte sind schlicht Regierungsgeheimnisse über die der Held oder der Zuschauer während der gesamten Handlung nichts Weiteres erfährt
+In Psycho benutzt Hitchcock unterschlagenes Geld das die Sekretärin zur Flucht treibt und so in Bates Motel führt um das Publikum anfangs gezielt in die Irre zu führen und für einen Kriminalfall zu interessieren der mit der eigentlichen Handlung nur am Rande zu tun hat
+Die mysteriösen <num> Stufen im gleichnamigen Film sind eine Geheimorganisation über die bis kurz vor Ende des Films überhaupt nichts bekannt ist außer dass sie gefährlich ist
+Ein besonders außergewöhnlicher MacGuffin ist die als Volksliedmelodie getarnte Geheimdienstinformation aus
+Eine Dame verschwindet
+Filmische Mittel
+Beeinflusst vom Stummfilm beruhte Hitchcocks Filmverständnis auf dem Anspruch alles Wichtige in seinen Filmen visuell und so wenig wie möglich durch Dialoge auszudrücken
+Seine typischen Kameraeinstellungen geben im Bild genau das wieder was für das Verständnis der Szene wesentlich ist - auch um dem Zuschauer nicht die Möglichkeit zu geben sich durch unwesentliche Details ablenken zu lassen
+So wirken beispielsweise Kuss-Szenen bei Hitchcock immer sehr intim da er gewöhnlich mit der Kamera sehr nahe an die beiden sich Küssenden heranfuhr und den Zuschauer sozusagen zum dritten Umarmenden machte Zu den berühmtesten Beispielen dieser visuellen Erzählweise zählen die Duschszene aus Psycho der Flugzeugangriff auf Cary Grant und die Jagd auf Mount Rushmore in Der unsichtbare Dritte die Versammlung der Vögel auf dem Klettergerüst in Die Vögel oder die zehnminütige Konzertszene in der Royal Albert Hall in Der Mann der zuviel wußte von <num>
+Hitchcocks visueller Arbeitsstil drückt sich unter anderem in den Expositionen vieler seiner Filme aus
+Er bringt den Zuschauern die handelnden Figuren und die Umstände der folgenden Handlung ohne die Verwendung von Dialogen nahe
+Die Länge dieser Einführungen variiert zwischen wenigen Sekunden und mehreren Minuten
+Erstmals verfolgte Hitchcock diese Technik <num> in seinem ersten Tonfilm Erpressung
+Zudem tauchen in Hitchcocks Filmen immer wieder ungewöhnliche filmische Operationen auf um die Stimmung und Spannung bewusst zu verstärken beispielsweise eine gegenläufige Zoom-Fahrtbewegung in Vertigo später auch als Vertigo-Effekt bezeichnet lange Kamerafahrten wie die aus einer Totale eines großen Raums bis in die Naheinstellung eines Schlüssels in einer Hand in Berüchtigt oder auf ein zuckendes Auge in Jung und unschuldig sowie die aus ungefähr siebzig Einstellungen bestehende fünfundvierzig Sekunden lange Mordszene unter der Dusche in Psycho unmittelbar gefolgt von einer etwa einminütigen Kamerafahrt ohne einen einzigen Schnitt
+Der Production Designer Robert Boyle mit dem Hitchcock bei fünf Filmen zusammenarbeitete meinte Keiner der Regisseure mit denen ich je zusammengearbeitet habe wusste so viel über Film wie er
+Viele der Regisseure mit denen ich gearbeitet habe wussten eine ganze Menge aber sie besaßen nicht die technischen Fähigkeiten die er hatte
+Er suchte immer nur den visuellen Ausdruck und so etwas wie eine zufällige Einstellung gab es bei ihm nicht
+Nur einmal griff Hitchcock aus Experimentierfreude auf einen filmtechnischen Kniff zurück der sich nicht unmittelbar aus der Dramaturgie ergab
+In Cocktail für eine Leiche <num> drehte er bis zu zehn Minuten lange Einstellungen die er zum großen Teil sogar über unsichtbare Schnitte ineinander übergehen ließ
+Er wollte damit bei dieser Theaterverfilmung die Einheit von Zeit und Raum dokumentieren
+Später gab er zu dass es ein Fehler war damit gleichzeitig den Schnitt als wesentliches gestaltendes Instrument der Dramaturgie aus der Hand gegeben zu haben
+Licht und Farben
+Inspiriert von amerikanischen und deutschen Filmemachern setzte Hitchcock schon bei seinen ersten Filmen Licht- beziehungsweise Schatteneffekte ein
+Typisch für Hitchcock sind Linien und Streifen in Form von Schatten durch Gitter Jalousien oder Ähnliches verursacht die vor allem auf Gesichter fallen und eine unheilvolle Atmosphäre verstärken sollen
+Darüber hinaus verwendet er in einzelnen Szenen sehr starke zum Teil unnatürlich wirkende Kontraste um einen äußeren oder inneren Gut-Böse-Gegensatz zu visualisieren
+Dieses Hell-Dunkel-Spiel unterstützte Hitchcock durch die Kostüme der Figuren
+So ließ er Ingrid Bergman am Anfang von Berüchtigt gestreifte Kleidung tragen um ihre Zerrissenheit zu unterstreichen
+In Der Mieter trug Ivor Novello zu Beginn Schwarz später um seine Unschuld auch nach außen hin deutlich zu machen Weiß
+Die Methode durch die Farbgebung der Kostüme den emotionalen Zustand der Figuren zu unterstreichen behielt Hitchcock auch für die Farbfilme bei
+In Bei Anruf Mord wurden die Kostüme von Grace Kelly mit der Dauer des Films immer trister und grauer entsprechend ihrer inneren Gemütsverfassung
+Zu Hitchcocks Farbwahl von Grace Kellys Kleidern in Das Fenster zum Hof sagte die Kostümbildnerin Edith Head Für jede Farbe und jeden Stil gab es einen Grund er war sich seiner ganzen Entscheidung absolut sicher
+In einer Szene sah er sie in blassem Grün in einer anderen in weißem Chiffon in einer weiteren in Gold
+Er stellte im Studio tatsächlich einen Traum zusammen In seinen späteren Filmen allen voran Marnie und Vertigo gab es eine ausgefeilte die Kostüme die Dekors und die Beleuchtung umfassende Farbdramaturgie
+Tricktechnik
+Nach Hitchcocks Filmverständnis schafft sich der Film seine eigene Realität und soll oder darf kein Abbild des wahren Lebens sein
+Die Nutzung sämtlicher Möglichkeiten genau das wiederzugeben was der Regisseur sich vorstellt ist nach diesem Verständnis nicht nur legitim sondern erforderlich
+Hitchcock hat die Entwicklung der Tricktechnik aufmerksam beobachtet und schon sehr früh - gelegentlich zum Missfallen seiner Produzenten - neue Trickverfahren eingesetzt zum Beispiel das Schüfftan-Verfahren in Erpressung oder das Matte Painting
+In seinen englischen Thrillern vor allem in Nummer siebzehn und Jung und unschuldig arbeitete Hitchcock bei Verfolgungsjagden oft und erkennbar mit Modellen
+In Eine Dame verschwindet sind die Rückprojektionen während der Zugfahrt aber bereits so ausgereift dass sie noch Jahrzehnte später überzeugen
+Ähnliches gilt für die Schlussszene von Der Fremde im Zug in der zwei Männer auf einem sich immer schneller drehenden Karussell kämpfen - in einer virtuosen Kombination von Realeinstellungen Modellen und Rückprojektionen
+Die Vögel <num> beinhaltet rund vierhundert Trickeinstellungen für die Hitchcock auf sämtliche damals verfügbaren Tricktechniken zurückgriff unter anderem auch auf das ansonsten für Animationsfilme verwendete Rotoskopieverfahren
+Ton und Musik
+Hitchcock hat seit dem Aufkommen des Tonfilms Musik und Toneffekte eingesetzt um die Dramaturgie bewusst zu unterstützen
+Den Umgang Hitchcocks mit dem Medium Ton beschrieb die Schauspielerin Teresa Wright Im Schatten des Zweifels folgendermaßen Wenn ein Schauspieler mit den Fingern trommelte war das nicht ein zweckloses Trommeln es hatte einen Rhythmus ein musikalisches Muster - es war wie ein Geräusch-Refrain
+Ob jemand nun ging oder mit Papier raschelte oder einen Umschlag zerriss oder vor sich hin pfiff ob das Flattern von Vögeln oder ein Geräusch von draußen war alles wurde sorgfältig von ihm orchestriert
+Er komponierte die Toneffekte wie ein Musiker Instrumentenstimmen Gegenüber Truffaut erwähnte Hitchcock dass er nach dem Endschnitt eines Films seiner Sekretärin ein Tondrehbuch diktiert das alle von ihm gewünschten Geräusche enthält
+In Mord - Sir John greift ein <num> versteckte Hitchcock da ein nachträgliches Bearbeiten der Tonspur zu diesem Zeitpunkt technisch noch nicht möglich war gar ein komplettes Orchester hinter den Kulissen um die entsprechenden Stellen musikalisch zu untermalen
+Weitere klassische Beispiele für Hitchcocks dramaturgischen Musikeinsatz sind Geheimagent <num> der Dauerakkord des toten Organisten in der Kirche Eine Dame verschwindet <num> die Melodie mit dem Geheimcode und der Volkstanz Im Schatten des Zweifels <num> der Merry-Widow-Walzer Der Fremde im Zug <num> die Szenen auf dem Rummelplatz und Das Fenster zum Hof <num> die im Laufe des Films entstehende Komposition des Klavierspielers
+In Der Mann der zuviel wußte <num> schließlich wird Musik sowohl orchestral wie auch gesungen aktiv inszeniert und dramaturgisch eingebunden Sie spielt eine wesentliche Rolle in der Gesamtdramaturgie des Films
+Die Musik der Filme aus den späten <num>er und frühen <num>er Jahren der Zeit als Hitchcock mit dem Komponisten Bernard Herrmann zusammenarbeitete ist tragendes Element der jeweiligen Filme
+Kritiker bescheinigen der Musik der Filme Vertigo Der unsichtbare Dritte und Psycho sowie den Toneffekten von Oskar Sala zu Die Vögel wesentlich zum jeweiligen Gesamteindruck des Films beizutragen
+Prägende Einflüsse
+Vorbilder
+Hitchcock war beeindruckt von den Filmen die er in seiner Jugend und in seinen frühen Jahren im Filmgeschäft sah etwa jenen von D W Griffith Charlie Chaplin Buster Keaton und Douglas Fairbanks senior
+Als Stummfilmregisseur in England übernahm er vom US-Film unter anderem die Technik mit Hilfe von Beleuchtungseffekten Tiefe zu schaffen und den Vorder- vom Hintergrund abzusetzen was bis in die <num>er Jahre im britischen Film unüblich war
+Angetan war er auch von den deutschen Stummfilmregisseuren wie Fritz Lang und Ernst Lubitsch
+F W Murnaus Der letzte Mann
+dessen Dreharbeiten Hitchcock <num> in München beobachtete bezeichnete er später als den fast perfekten Film Er erzählte seine Geschichte ohne Titel von Anfang bis Ende vertraute er ganz auf seine Bilder
+Das hatte damals einen ungeheueren Einfluss auf meine Arbeit Einfluss auf Hitchcocks Arbeit hatte auch
+Das Cabinet des Dr Caligari
+den Robert Wiene <num> drehte Die Betonung des Visuellen im deutschen Expressionismus prägte seinen eigenen Umgang mit filmischen Mitteln
+Abgesehen von diesen stilistischen Einflüssen vermied es Hitchcock jedoch Szenen oder Einstellungen bekannter Filme zu zitieren
+Als Ausnahme kann
+Panzerkreuzer Potemkin
+<num> des sowjetischen Regisseurs Eisenstein angesehen werden
+In Die <num> Stufen Über den Dächern von Nizza und einigen weiteren Filmen erinnern die vor Entsetzen schreienden Frauen an Einstellungen aus der berühmten und oft zitierten Szene an der Hafentreppe in Odessa
+Es gibt außerdem in Hitchcocks Werk aus den <num>er und <num>er Jahren einige motivische und visuelle Überschneidungen mit der Gattung des Film noir die den amerikanischen Kriminalfilm in jener Zeit bestimmte etwa in Im Schatten des Zweifels und Berüchtigt und besonders in Der falsche Mann wo das Motiv der allgegenwärtigen Bedrohung der Hauptfiguren eine Rolle spielt
+Darüber hinaus bediente er sich gerne einer ähnlich kontrastreichen Bildgestaltung die er sich in den Grundzügen allerdings bereits in den <num>er Jahren angeeignet hatte
+Auch Vertigo erinnert in der Grundkonstellation und der alptraumhaften Zwanghaftigkeit der Geschehnisse an einige Filme des Genres wie zum Beispiel Frau ohne Gewissen hebt sich jedoch formal und stilistisch deutlich vom Film noir ab
+Als typischer Vertreter des Genres kann Hitchcock jedenfalls nicht angesehen werden
+Obsessionen
+Seine Vorliebe für Blondinen erklärte Hitchcock gegenüber Truffaut wie folgt Ich finde die englischen Frauen die Schwedinnen die Norddeutschen und die Skandinavierinnen sind interessanter als die romanischen die Italienerinnen und die Französinnen
+Der Sex darf nicht gleich ins Auge stechen
+Eine junge Engländerin mag daherkommen wie eine Lehrerin aber wenn Sie mit ihr in ein Taxi steigen überrascht sie Sie damit dass sie Ihnen in den Hosenschlitz greift Ähnlich äußerte er sich <num> gegenüber Look über die Truffaut-Schauspielerin Claude Jade die bei ihm in Topaz gespielt hatte Claude Jade ist eine eher ruhige junge Dame doch für ihr Benehmen auf dem Rücksitz eines Taxis würde ich keine Garantie übernehmen
+Dass Hitchcock zu seinen jungen blonden Schauspielerinnen ein besonderes Verhältnis hatte und ihnen mehr Aufmerksamkeit widmete als allen anderen war schon früh bekannt
+Die Sorgfalt mit der Hitchcock bereits in den <num>er und <num>er Jahren Madeleine Carroll Carole Lombard und insbesondere Ingrid Bergman in Szene setzte entwickelte sich mit der Zeit zu einer sich steigernden Verquickung privater und beruflicher Interessen die sich zu einer Obsession ausweitete
+Mit Vera Miles probte er die Nervenzusammenbrüche welche sie in Der falsche Mann darstellen sollte wochenlang jeweils mehrere Stunden täglich Für sie wie für Kim Novak ließ er von der Kostümbildnerin eine komplette Garderobe schneidern die für ihr privates Leben gedacht war
+Tippi Hedren Die Vögel ließ er sogar von zwei Crew-Mitgliedern beschatten und begann ihr Vorschriften für ihr Verhalten im Privatleben zu machen
+Diese Vereinnahmung hatte ihren Höhepunkt in sich über Tage hinziehenden Aufnahmen von auf sie einstürzenden echten Vögeln Nach einem eindeutigen erfolglosen Annäherungsversuch während der Arbeiten zu Marnie kam es schließlich zum Bruch
+Die zuvor offen bekundete Zuneigung schlug ins Gegenteil um und Hitchcock ließ keine Gelegenheit aus Tippi Hedren bei anderen herabzusetzen
+Sie blieb die letzte typische Hitchcock-Blondine Zwar hielt sich Hitchcock darüber stets äußerst bedeckt doch es gilt als gesichert dass der Regisseur sich von diesen Schwierigkeiten lange nicht erholen konnte und in seiner kreativen Schaffenskraft beeinträchtigt war
+Ebenso gelten Filme wie Vertigo und Berüchtigt aber auch Marnie oder Im Schatten des Zweifels die von neurotischen Männern handeln die Frauen manipulieren als stark autobiographisch
+Auch die Verbindung zwischen Sex und Gewalt faszinierte Hitchcock was vor allem in seinen späteren Werken immer deutlicher zutage tritt
+Mehrfach inszenierte er vollendete oder versuchte Vergewaltigungen schon früh in Erpressung später dann in Marnie und Frenzy
+In drei nicht realisierten Projekten sollten Vergewaltiger oder Vergewaltigungen eine zentrale Rolle spielen Morde inszenierte er einige Male als Vergewaltigungen mit dem Messer als Phallus-Symbol
+Doch auch der Tod durch Erwürgen oder Strangulieren übte eine gewisse Faszination auf ihn aus
+Einige Würgeszenen gehören zu den bemerkenswertesten Mordszenen seiner Karriere etwa in Cocktail für eine Leiche Bei Anruf Mord Der zerrissene Vorhang und Frenzy Sich selbst ließ er oft in Würgerposen ablichten
+Ähnlich offen kokettierte Hitchcock zeit seines Lebens mit seiner panischen Angst vor der Polizei
+Hitchcock erzählte gerne dass er mit fünf Jahren nachdem er etwas angestellt hatte von seinem Vater mit einem Zettel auf das nahegelegene Polizeirevier geschickt worden sei
+Der Polizist las den Zettel und sperrte Alfred für fünf oder zehn Minuten in eine Zelle mit dem Kommentar dies würde die Polizei mit ungezogenen Jungen so machen
+In seinen Filmen geht von Polizisten stets eine latente Gefahr aus
+Zu der Frage inwieweit das von Hitchcock in seinen Filmen transportierte Bild der besitzergreifenden Mutter von der eigenen Mutter geprägt ist gab es von ihm selbst keinerlei Aussagen
+Das wenige was man aus seiner Kindheit weiß legt jedoch autobiographische Ursprünge nahe Hitchcocks Mutter starb nach langer Krankheit im August <num> während der Dreharbeiten zu Im Schatten des Zweifels
+Dieser bereits von vornherein stark autobiographisch geprägte Film nimmt eindeutig Bezug auf Hitchcocks Verhältnis zu ihr Der Name Emma scheint nicht die einzige Gemeinsamkeit zwischen ihr und der dominanten Mutterfigur im Film zu sein
+Zudem ist im Film noch von einer anderen gebieterischen jedoch kranken Mutter die Rede - jener des Krimi-Besessenen Herb Hawkins der wiederum als Selbstprojektion Hitchcocks gilt
+Auffallend oft sind Toiletten in Hitchcocks Filmen zu sehen oder zu hören in denen konspirative Dinge irgendwelcher Art stattfinden
+Laut seinem Biographen Donald Spoto hatte er eine pubertäre Fixierung die in seiner viktorianischen Erziehung begründet lag
+Hitchcock äußerte sich zwar oft und gerne über menschliche Körperfunktionen wollte aber den Eindruck erwecken er selbst habe mit solchen Dingen nichts zu tun Bezugnehmend auf seine Körperfülle deutete Hitchcock hingegen mehrfach an dass für ihn Essen eine Art Ersatzbefriedigung sei
+So gibt es in einigen Hitchcockfilmen eine symbolische Verbindung von Essen Sex und Tod
+Zensur
+In den USA galt zwischen <num> und <num> der
+Hays Code
+auch Production Code genannt eine Sammlung von Richtlinien über die Einhaltung der gängigen Moralvorstellungen und über die Zulässigkeit der Darstellung von Kriminalität Gewalt und Sexualität im Film
+So musste Hitchcock zum Beispiel das geplante Ende für Verdacht fallen lassen weil es Anfang der <num>er Jahre nicht möglich war den Selbstmord einer schwangeren Frau zu zeigen
+Noch bis kurz vor Schluss der Dreharbeiten hatte er kein passendes Ende für den Film gefunden
+In Berüchtigt musste Hitchcock einen Dialog streichen in dem sich ein Vertreter der US-Regierung positiv über die Möglichkeit einer Ehescheidung äußerte Bei Saboteure drehte er politisch heikle Textstellen zur Sicherheit alternativ in entschärften Versionen
+Doch in vielen Fällen gelang es ihm die Beschränkungen durch die Zensur kreativ zu umgehen
+So war es damals unter anderem nicht erlaubt eine Toilette zu zeigen
+Daher verzerrte Hitchcock in Mr
+und Mrs Smith
+die eindeutigen Geräusche einer Toilette so dass man sie für eine Dampfheizung halten konnte
+In Psycho zeigte er eine Toilette in der ein Papierzettel hinuntergespült wurde
+Indem er das Bild der Toilette mit einer dramaturgischen Funktion versah - das Verschwinden eines Beweisstücks musste erklärt werden - verhinderte er dass die Szene geschnitten wurde
+Niemals wurde eine Toilette zu Zeiten des Hays Code expliziter gezeigt
+Da auch die Länge von Küssen im Film damals auf drei Sekunden begrenzt war inszenierte Hitchcock den Kuss zwischen Ingrid Bergman und Cary Grant in Berüchtigt als Folge von einzelnen durch kurze Dialogsätze unterbrochenen Küssen
+Hitchcocks größter Sieg gegen die Zensur war die Schlussszene von Der unsichtbare Dritte Cary Grant und Eva Marie Saint befinden sich in einem Schlafwagen
+Er zieht sie zu sich nach oben in das obere Bett und sie küssen sich
+Es erfolgt ein Umschnitt und man sieht einen Zug in einen Tunnel rasen - eine der explizitesten Andeutungen des Sexualakts in einem US-Film zu Zeiten des Production Code
+Arbeitsweise
+Einer der wichtigsten Aspekte der Arbeitsweise Alfred Hitchcocks war dass er im Idealfall von der Stoffauswahl bis zum Endschnitt nichts dem Zufall überließ sondern die völlige Kontrolle über die Herstellung des Films beanspruchte
+Wenn Hitchcock existierende Vorlagen benutzte etwa Romane oder Bühnenstücke übernahm er nur einzelne Grundmotive der Handlung und entwickelte daraus zusammen mit dem jeweiligen Drehbuchautor oft eine völlig neue Geschichte
+Hochwertige komplexe Literatur sperrte sich gegen diesen Umgang und Hitchcock scheute daher deren Verfilmung - auch aus Respekt vor dem Werk
+Hitchcock war meist an der Drehbucherstellung beteiligt wurde aber nach <num> bei keinem seiner Filme offiziell als Autor in Vor- oder Abspann erwähnt Ich will nie einen Titel als Produzent oder Autor
+Ich habe das Design des Films geschrieben
+Mit anderen Worten ich setze mich mit dem Autor zusammen und entwerfe den ganzen Film vom Anfang bis zum Ende Der Autor Samuel A Taylor Mit ihm zu arbeiten bedeutete auch mit ihm zu schreiben was auf die wenigsten Regisseure zutrifft
+Hitchcock behauptete nie selbst ein Schriftsteller zu sein aber in Wahrheit schrieb er doch seine eigenen Drehbücher denn er sah bereits jede Szene deutlich in seinem Kopf vor sich und hatte eine sehr genaue Vorstellung davon wie sie ablaufen sollte
+Ich merkte dass ich nur noch die Figuren persönlicher und menschlicher zu gestalten brauchte und sie weiter entwickeln musste Gelegentlich veränderte Hitchcock im Nachhinein noch die Dialoge ganzer Szenen etwa um die Spannungs-Dramaturgie zu verbessern Beispiel Das Rettungsboot oder um autobiographische Bezüge einzubauen Beispiel Ich beichte
+Auch wenn ihm geschliffene Dialoge wichtig waren legte Hitchcock sein Hauptaugenmerk stets auf die Ausdruckskraft der Bilder
+So wurde im Idealfall jede einzelne Einstellung des Films vor Drehbeginn in Storyboards festgelegt
+Seit Beginn seiner Regisseurtätigkeit verfolgte er das Ziel jegliche Improvisation so weit es geht zu vermeiden
+Gegenüber Truffaut erklärte er Ich habe Angst davor gehabt im Atelier zu improvisieren weil selbst wenn man im Augenblick Ideen hat bestimmt keine Zeit bleibt nachzuprüfen was sie taugen
+Andere Regisseure lassen ein ganzes Team warten und setzen sich hin um zu überlegen
+Nein das könnte ich nicht
+Nach eigenen Aussagen bereitete Hitchcock die Planung eines Projekts mehr Freude als die eigentlichen Dreharbeiten Durch zu viele Einflüsse - Produzenten Technik Schauspieler Zeitdruck - sah er die angestrebte Kontrolle über sein Werk bedroht
+Außerdem sah er im Idealfall die kreative Arbeit am Film mit Beginn der Dreharbeiten als abgeschlossen an Ich drehe einen vorgeschnittenen Film
+Mit anderen Worten jedes Stück Film ist entworfen um eine Funktion zu erfüllen
+Diese Grundsätze waren jedoch eher eine Idealvorstellung Hitchcocks
+Tatsächlich wurde es ihm spätestens ab <num> zur Gewohnheit beim Drehen Alternativen auszuprobieren
+Doch auch hier bemühte er sich um möglichst exakte Vorausplanung Ein Beispiel hierfür ist die Belagerung des Hauses durch die Vögel in Die Vögel
+Gegenüber Truffaut beschrieb Hitchcock wie er die ursprünglich geplante Szene noch unmittelbar am Drehort umschrieb und bis ins kleinste Detail skizzierte so dass sie kurz darauf entsprechend diesen neuen Entwürfen gedreht werden konnte Darüber hinaus wurde Hitchcock im Laufe seiner Karriere immer freier auch kurzfristig vom festgelegten Drehbuch abzuweichen
+Entgegen seinen Gewohnheiten ließ er sogar Improvisationen der Schauspieler zu wenn auch nur bei eher unwichtigen Szenen Bill Krohn ging <num> in Hitchcock at Work ausführlich auf Hitchcocks Arbeitsweise ein
+Er rekonstruierte auf Basis von Originalunterlagen wie Drehbuchversionen Skripte Storyboards Memos Produktionsnotizen etc und mit Hilfe von Beteiligten die Produktionsgeschichte diverser Filme darunter Hitchcocks berühmteste und widerlegt Hitchcocks Bekenntnis zum vorgeschnittenen Films So kam es bei vielen Filmen vor dass Hitchcock entscheidende Schlüsselszenen in verschiedenen Varianten drehte und meist erst im Schneideraum über die endgültige Form einzelner Szenen entschied
+Mitarbeiter
+Im Laufe der Jahre entwickelte sich mit verschiedenen Autoren eine besonders kreative Zusammenarbeit
+Hervorzuheben sind Eliot Stannard Angus McPhail Charles Bennett Ben Hecht und John Michael Hayes
+Obwohl Samuel A Taylor Vertigo und auch Ernest Lehman Der unsichtbare Dritte nur je zwei Drehbücher zu tatsächlich realisierten Filmen schrieben gehörten sie zu den wenigen Mitarbeitern die mit ihm in den letzten Jahren seiner Karriere regelmäßig zusammenarbeiteten und bis kurz vor seinem Tod Kontakt hatten
+Doch auch mit namhaften Theater- oder Romanautoren arbeitete Hitchcock mehrfach bei der Drehbucherstellung zusammen reibungslos mit Thornton Wilder und George Tabori konfliktbeladen mit John Steinbeck Raymond Chandler und Leon Uris Der Kult den Hitchcock gern um seine Person betrieb und sein manchmal diktatorischer Stil führte auch zu Konflikten mit befreundeten Autoren
+John Michael Hayes der im Streit von Hitchcock schied Ich tat für ihn was jeder andere Autor für ihn tat - ich schrieb
+Wenn man aber Hitchcocks Interviews liest kann man den Eindruck bekommen er habe das Drehbuch geschrieben die Charaktere entwickelt die Motivation beigesteuert Wenn Hitchcock mit der Arbeit eines Autors nicht zufrieden war oder wenn er seine Autorität angegriffen fühlte dann ersetzte er Autoren kurzerhand durch andere
+Cary Grant und James Stewart wurden innerhalb der jeweils vier Filme die sie für Hitchcock drehten zu Hitchcocks Alter Ego
+Grant wurde zu dem was Hitchcock gerne gewesen wäre wie es Hitchcocks Biograph Donald Spoto formulierte während Stewart vieles wäre von dem Hitchcock dachte er sei es selbst Mit einigen seiner Schauspieler verband Hitchcock zudem eine langjährige persönliche Freundschaft allen voran mit Grace Kelly Darüber hinaus sind die als neurotisch zu bezeichnenden Beziehungen zu seinen blonden Hauptdarstellerinnen - insbesondere mit Tippi Hedren - bekannt
+Am Anfang von Hitchcocks Karriere galt Film in England als Unterhaltung für die Unterschicht
+Aus dieser Zeit stammt Hitchcocks oft zitierter Ausspruch Alle Schauspieler sind Vieh der sich auf diejenigen Theaterschauspieler bezog die nur mit Widerwillen und des Geldes wegen nebenher als Filmschauspieler arbeiteten
+Die Aussage verselbständigte sich später und wurde oft als genereller Ausdruck der Geringschätzung Hitchcocks Schauspielern gegenüber angesehen
+Tatsächlich hatte er auch später oft Probleme mit Schauspielern die eigene Vorstellungen durchsetzen wollten anstatt sich in die vorgefertigte Planung des Regisseurs einzufügen
+Anhänger des Method Actings wie Montgomery Clift und Paul Newman waren Hitchcock daher genauso lästig wie Exzentriker oder Egomanen
+Große Achtung hatte Hitchcock hingegen vor Schauspielern die sein Filmverständnis teilten oder sich zumindest seiner Arbeitsweise anpassten und gewährte etwa Joseph Cotten und Marlene Dietrich große künstlerische Freiheiten Oft waren es jedoch die Produzenten die über die Besetzung der Hauptrollen entschieden
+Umso mehr nutzte Hitchcock seine größere Freiheit bei den zu besetzenden Nebenrollen wobei er gerne auf Theaterschauspieler zurückgriff die er noch aus seiner Zeit in London in bester Erinnerung hatte zum Beispiel Leo G Carroll in insgesamt sechs Filmen oder Cedric Hardwicke in Verdacht und Cocktail für eine Leiche
+Die bekannte Kostümbildnerin Edith Head mit der er ab Das Fenster zum Hof bei fast allen Filmen zusammenarbeitete meinte Loyalität war Hitchcock besonders wichtig
+Er war Mitarbeitern gegenüber so loyal wie er es von ihnen erwartete
+Bei fünf Filmen war Robert F Boyle für das Production Design verantwortlich er gehörte bis zu Hitchcocks Tod zu dessen engsten Mitarbeitern
+Außerdem griff er im Laufe seiner Karriere gern auf Albert Whitlock als Szenenbildner zurück
+Äußerst zufrieden war Hitchcock dem die Ausdruckskraft der Bilder stets wichtig war auch mit dem Art Director Henry Bumstead
+Der Titeldesigner Saul Bass entwarf nicht nur einige Filmtitel für die Vorspanne sowie Plakate sondern war bereits bei den Arbeiten an vielen Storyboards maßgeblich beteiligt
+Wichtigster Kameramann in seinen frühen Jahren bei den British International Pictures war John J Cox
+Über Hitchcock sagte Kameramann Robert Burks der mit Ausnahme von Psycho an allen Filmen zwischen <num> und <num> beteiligt war Man hatte nie Ärger mit ihm solange man etwas von seiner Arbeit verstand und sie ausführte
+Hitchcock bestand auf Perfektion Mit Leonard J South ehemaliger Assistent Burks arbeitete Hitchcock über einen Zeitraum von insgesamt <num> Jahren zusammen
+Von den Komponisten der Filmmusiken ist Louis Levy hervorzuheben der die Soundtracks für die frühen englischen Filme von Der Mann der zuviel wußte bis Eine Dame verschwindet beisteuerte
+Als der Hitchcock-Komponist schlechthin gilt Bernard Herrmann der ab Immer Ärger mit Harry bis einschließlich Marnie <num> alle Filmmusiken für Hitchcock komponierte
+Der Filmeditor George Tomasini war bis zu seinem Tod <num> ein Jahrzehnt lang enger Mitarbeiter Hitchcocks
+Zu Beginn seiner Karriere wirkte seine Frau Alma als Editorin bei seinen Filmen mit sie blieb bis zuletzt eine der einflussreichsten Mitarbeiterinnen
+Selbstvermarktung
+Schon zu Beginn seiner Karriere war Hitchcock die Bedeutung der Vermarktung der eigenen Person bewusst Viele seiner späteren Tätigkeiten sind Teil einer Strategie sich und seinen Namen als Marke zu etablieren
+Bereits <num> führte Hitchcock ein stilisiertes Selbstporträt als Logo das bis heute bekannt ist Anfang der <num>er Jahre als er mit dem Erfolg seiner Filme in England populär wurde gründete er mit der Hitchcock Baker Productions Ltd
+eine Gesellschaft die bis zu seiner Übersiedlung nach Amerika ausschließlich dafür zuständig war für ihn und mit seiner Person Öffentlichkeitsarbeit zu betreiben
+Anschließend wurden diese Aufgaben von der Künstleragentur Selznick-Joyce danach von der Music Corporation of America MCA wahrgenommen wobei der Präsident der MCA Lew Wasserman zu seinem persönlichen Agenten wurde
+<num> wurde unter Herman Citron eine neue Gesellschaft gegründet die Hitchcocks Interessen vertrat und seinen Namen vermarktete Diese Selbstvermarktung diente auch dazu eine Machtposition im Produktionsprozess seiner Filme zu erlangen und war somit Teil seines Kampfes um künstlerische Unabhängigkeit
+Cameo-Auftritte
+Aus Mangel an Statisten in seinen ersten britischen Filmen sah man Hitchcock immer wieder im Hintergrund auftauchen
+Daraus entwickelte er eines seiner bekanntesten Markenzeichen Hitchcocks obligatorischer Cameo-Auftritt
+Da das Publikum mit der Zeit immer weniger auf die Handlung achtete als vielmehr auf Hitchcock lauerte legte er in späteren Filmen diesen Running Gag möglichst weit an den Filmanfang
+In drei Filmen hatte Hitchcock keinen eigentlichen Cameo-Auftritt
+In zwei von diesen Filmen trat er auf Fotos in Erscheinung
+Das Rettungsboot
+spielt ausschließlich in einem kleinen Rettungsboot auf dem Meer
+Er ist daher in einer zufällig im Boot liegenden Zeitung in einer Werbeanzeige für eine Diät auf einem Vorher-Nachher-Foto zu sehen Auch in
+Bei Anruf Mord
+war kein Auftritt möglich
+Stattdessen taucht Hitchcock auf einem an der Wand hängenden Foto einer Wiedersehensfeier von College-Absolventen auf
+In
+Der falsche Mann
+schließlich tritt er am Anfang des Films persönlich auf und spricht den Prolog
+Dies ist gleichzeitig seine einzige Sprechrolle in einem seiner Kinofilme
+Alle bekannten Hitchcock-Cameos chronologisch
+ilmAuftrittRolleFilmAuftrittRolleDer MieterErst an einem Schreibtisch in einer Redaktion dann eilt er eine Mütze auf dem Kopf auf den Hauptdarsteller Ivor Novello zu als dieser mit Handschellen an einem Gitter hängt nach <num> bzw <num> minEasy VirtueMit einem Gehstock hinter einem Tennisplatz nach <num> minErpressungLiest in der U-Bahn eine Zeitung und wird dabei von einem Jungen gestört der ihm den Hut über die Ohren zieht nach <num> minMord - Sir John greift ein
+Geht im Gespräch mit einer Frau an dem Haus vorbei in dem der Mord stattfand nach <num> minDer Mann der zuviel wußte von <num>Überquert die Straße in einem Regenmantel nach <num> minDie <num> StufenGeht über den Gehsteig und wirft eine Kaugummipackung weg während Robert Donat und Lucie Mannheim fluchtartig das Theater verlassen nach <num> minSabotageGeht an einem Kino vorbei nach <num> minJung und unschuldigVor dem Gerichtsgebäude mit einer Kamera in der Hand nach <num> minEine Dame verschwindetIn der Londoner Victoria Station geht er mit dunklem Mantel und einer Zigarette hastig auf den Bahnsteig nach <num> minRebeccaGeht hinter George Sanders vorbei als dieser neben einer Telefonzelle mit einem Polizisten diskutiert nach <num> minDer AuslandskorrespondentMit Mantel Hut und Tageszeitung kurz nachdem Joel McCrea sein Hotel verlassen hat nach <num> minVerdachtAn einem Briefkasten nach <num> minMr und Mrs SmithAuf der Straße geht er an Robert Montgomery vorbei nach <num> minSaboteureSteht links vor dem Schaufenster eines Drugstore als das Auto des Saboteurs dort anhält nach <num> minIm Schatten des ZweifelsHat beim Kartenspiel im Zug nach Santa Rosa ein Full House nach <num> minIch kämpfe um dichKommt aus dem Fahrstuhl im Hotel Empire mit einem Geigenkasten und einer Zigarette nach <num> minBerüchtigtAuf der Party in Rains Wohnung trinkt Champagner in einem Zug leer und verschwindet dann nach <num> minDer Fall ParadinKommt an der Cumberland Station aus dem Zug mit einem Cellokasten in der Hand nach <num> minCocktail für eine LeicheGeht unmittelbar nach dem Vorspann zusammen mit einer Frau auf dem Bürgersteig
+Sein Markenzeichen ist kurz unter der Neonreklame zu sehen nach <num> minSklavin des HerzensEr ist auf dem Empfang des Gouverneurs mit blauem Mantel und braunem Hut zu sehen außerdem später auf der Treppe im Regierungspalast nach <num> bzw <num> minDie rote LolaDreht sich nach Jane Wyman um die sich gerade als Marlene Dietrichs Dienstmädchen verkleidet hat nach <num> minDer Fremde im ZugSteigt mit einem Kontrabass in einen Zug als Farley Granger den Zug in Metcalf verlässt
+nach <num> min Als Guy und seine Freundin in einem Museum überraschenderweise auf Bruno treffen läuft im Hintergrund Hitchcock mit einem Buch durch den Saal nach <num> min
+Ich beichteGeht am oberen Rand an einer langen Treppe vorbei nach <num> minDas Fenster zum HofZieht im Apartment des Musikers eine Uhr auf nach <num> minImmer Ärger mit HarryBei der Ausstellung von John Forsythe in jener Szene in der der spätere Bilder-Käufer eingeführt wird überquert er hinter einer parkenden Limousine die Straße nach <num> minÜber den Dächern von NizzaEr sitzt neben John Robie Cary Grant im Bus nach <num> minDer Mann der zuviel wußte von <num>Mit dem Rücken zur Kamera auf dem Markt in Marrakesch bei dem Akrobaten kurz vor dem Mord nach <num> minVertigo - Aus dem Reich der TotenIn der Nähe des Büros von Gavin Elster der die Beschattung seiner Frau in Auftrag gibt überquert er in einem grauen Anzug mit einem Flügelhornkoffer eine Straße und geht in eine Werft nach <num> minDer unsichtbare DritteLäuft auf einen Bus zu dessen Tür sich vor seiner Nase schließt nach <num> minPsychoEr steht vom Inneren von Marions Büro aus sichtbar auf der Straße und trägt einen Cowboyhut nach <num> minDie VögelVerlässt die Tierhandlung mit zwei weißen Terriern in dem Moment in dem Tippi Hedren eintritt nach <num> minMarnieVerlässt ein Hotelzimmer und geht durch den Korridor nach <num> minDer zerrissene VorhangSitzt mit einem Baby auf dem Schoß im Hotelfoyer nach <num> minTopasAm La-Guardia-Flughafen in New York steht er aus einem Rollstuhl auf und begrüßt jemanden nach <num> minFrenzyAm Anfang des Films als die Leiche in der Themse gefunden wird steht er in der Menge und ist der einzige der dem Redner nicht applaudiert nach <num> minFamiliengrabIn seinem letzten Film sieht man seine Silhouette hinter der Milchglasscheibe einer Türe mit der Aufschrift Registratur für Geburten und Sterbefälle nach <num> min
+Trailer
+Während von den Filmgesellschaften üblicherweise für die Vermarktung eigene Abteilungen oder externe Agenturen beauftragt werden trugen bei Hitchcocks Filmen die Werbekampagnen deutlich die Handschrift des Regisseurs
+Seine Kino-Trailer waren häufig nicht nur Zusammenschnitte des angekündigten Films Mit steigendem Wiedererkennungswert seiner Person stellte Hitchcock in der Rolle eines Master of Ceremony seine eigenen Filme vor und führte den Zuschauer humorvoll durch die Kulissen
+Fernsehen
+Auf den Rat seines Agenten Lew Wasserman hin stieg Hitchcock <num> in das Fernsehgeschäft ein
+Hitchcock gründete die Fernsehproduktionsfirma Shamley Productions und produzierte bis <num> seine eigene wöchentliche Fernsehserie Am Anfang vieler Folgen begrüßte Hitchcock das Publikum indem er mit ungerührter Miene makabre Ansagetexte sprach
+Die Moderationen die ihn zu einer nationalen Berühmtheit machten wurden von dem Bühnenautor James D Allardice verfasst der fortan bis zu seinem Tod <num> für Hitchcock auch als Redenschreiber arbeitete Als Titelmusik für die Serie Alfred Hitchcock Presents verwendete Hitchcock das Hauptthema von Charles Gounods Marche funèbre dune marionette Trauermarsch einer Marionette das sich im Weiteren zu einer Erkennungsmelodie für Hitchcocks Öffentlichkeitsarbeit entwickelte
+Bücher und Zeitschriften
+<num> schloss Hitchcock einen Lizenzvertrag mit HSD Publications ab der die Überlassung seines Namens für das Krimi-Magazin Alfred Hitchcocks Mystery Magazine zum Inhalt hatte
+Die Zeitschrift enthält Mystery- und Kriminalgeschichten Buchrezensionen und Rätsel und erscheint noch heute
+Einführungen und Vorworte die mit seinem Namen unterschrieben waren wurden stets von Ghostwritern verfasst
+Von <num> bis <num> erschien in den USA die Jugend-Krimi-Reihe The Three Investigators auf Deutsch seit <num>
+Die drei
+Der Journalist und Autor Robert Arthur kannte Alfred Hitchcock persönlich und bat ihn seinen Namen zur Vermarktung dieser geplanten Buchreihe verwenden zu dürfen
+Schließlich baute er die Figur Alfred Hitchcock in die Handlung ein
+Anders als in Europa hielt sich der Erfolg der Bücher in den USA in Grenzen
+In Deutschland wo die Bücher besonders populär waren entstand die gleichnamige Hörspielreihe
+Durch diese bis heute erfolgreichste Hörspielproduktion der Welt wurde der Name Hitchcock auch bei vielen bekannt die mit seinem filmischen Schaffen nicht vertraut waren
+Wirkung
+Viele Elemente aus seinem Werk sind inzwischen in das Standardrepertoire des Kinos eingegangen ohne dass sie noch bewusst oder direkt mit Hitchcock in Verbindung gebracht werden insbesondere der Einsatz von Suspense als spannungserzeugendem Mittel oder die Verwendung von MacGuffins als handlungsvorantreibendes Element
+Darüber hinaus gibt es seit den <num>er Jahren unzählige Beispiele für Thriller oder Dramen teils von sehr namhaften Regisseuren in denen typische Motive Hitchcocks oder seine Stilelemente bewusst kopiert oder variiert werden
+Manche dieser Filme sind als Hommage des jeweiligen Regisseurs an Hitchcock zu verstehen in anderen Fällen wurde Hitchcocks Stil übernommen da er sich als erfolgreich und wirksam erwiesen hat
+USA
+Insbesondere Hitchcocks Erfolgsfilme aus den <num>er bis Anfang der <num>er Jahre inspirierten in den Folgejahren Hollywood-Produktionen die inhaltlich oder stilistisch oft mit Hitchcock in Verbindung gebracht werden
+Zu den vielen Hollywood-Regisseuren die Alfred Hitchcock mehr oder weniger direkt beeinflusste zählt Brian De Palma der mit vielen Verweisen und Zitaten auf Hitchcocks Werk arbeitet
+Überdies übernahm er in einigen Filmen Grundstrukturen aus dessen Filmen
+So entwickelt er in
+Dressed to Kill
+<num> das Grundmotiv aus
+Psycho
+weiter und zitiert aus weiteren Hitchcock-Filmen
+<num> lehnte sich
+Schwarzer Engel
+stark an
+Vertigo
+an
+<num> spielt de Palma in
+Der Tod kommt zweimal
+mit eindeutigen Bezügen auf
+Das Fenster zum Hof
+und Vertigo
+Auch wenn Steven Spielberg selten direkt stilistische Motive kopiert oder adaptiert und nur wenige seiner Filme thematische Parallelen aufzeigen erinnert
+Der weiße Hai
+<num> in Spannungsaufbau und Dramaturgie an
+Die Vögel
+und ist die Filmreihe <num>-<num> stark von
+Der unsichtbare Dritte
+<num> beeinflusst
+Auch ein Film wie
+Schindlers Liste
+<num> wäre in dieser Form ohne den Einfluss Hitchcocks nicht möglich gewesen
+Der von Hitchcocks Kameramann Irmin Roberts entwickelte Vertigo-Effekt wird bisweilen auch als Jaws Effect bezeichnet da Spielberg diese relativ schwierig umzusetzende Kameraeinstellung im Weißen Hai Originaltitel Jaws als einer der ersten prominenten Regisseure <num> Jahre nach Vertigo einsetzte
+Inzwischen gehört dieser emotional sehr wirkungsvolle Kameratrick zum Standardrepertoire des Hollywood-Kinos
+Weitere amerikanische Regisseure die erkennbar von Hitchcock beeinflusst wurden oder sich auf dessen Werk berufen sind John Carpenter David Fincher David Mamet Quentin Tarantino
+Martin Scorsese David Lynch und M Night Shyamalan
+Frankreich
+Bereits seit Mitte der <num>er Jahre war Hitchcock insbesondere in Frankreich bei den Vertretern der Nouvelle Vague hoch angesehen
+<num> veröffentlichten die damaligen Filmkritiker und späteren Regisseure Éric Rohmer und Claude Chabrol das erste Buch über ihn
+<num> erschien ein Sonderheft der Cahiers du cinéma das maßgeblich zu Hitchcocks Popularität in Frankreich beitrug
+Als er im Mai <num> zu einem Filmfestival reiste das die Cinémathèque française ihm zu Ehren in Paris abhielt wurde er von Dutzenden jungen Filmemachern frenetisch gefeiert
+Die internationale Ausgabe der Herald Tribune schrieb dass Hitchcock in dieser Woche das Idol der französischen Avantgarde geworden sei
+Im August <num> gab Hitchcock dem damals dreißigjährigen französischen Filmkritiker und Regisseur François Truffaut ein fünfzigstündiges Interview
+Truffaut befragte Hitchcock chronologisch zu dessen bisherigen achtundvierzig Filmen
+Das Interview erschien <num> als
+Mr
+Hitchcock wie haben Sie das gemacht
+in Buchform und gilt als Standardwerk der Filmliteratur
+Einzelne Filme Truffauts zeigen den Einfluss Hitchcocks deutlich etwa
+Die Braut trug schwarz
+<num> oder
+Das Geheimnis der falschen Braut
+<num> die Geschichte eines Mannes der einer Betrügerin und Mörderin verfällt und auch nicht von ihr lassen kann als sie ihn zu töten versucht
+Der Film ist stark von verschiedenen inhaltlichen und stilistischen Motiven aus
+Vertigo
+Marnie
+und
+Verdacht
+beeinflusst
+Sein letzter Film
+Auf Liebe und Tod
+<num> in dem ein unschuldiger Mann eines Mordes beschuldigt wird ist voll von hitchcockschen Motiven und Anspielungen auf dessen Werk
+Weitere Filme die Truffaut selbst in der Tradition Hitchcocks sah waren
+Die süße Haut
+und
+Fahrenheit <num>
+<num><num> besetzte Hitchcock die bevorzugte Schauspielerin Truffauts Claude Jade für seinen Film
+Topas
+In vielen Filmen von Claude Chabrol wird eine scheinbar heile bürgerliche Welt angegriffen und durcheinandergebracht
+Die hitchcockschen Hauptmotive der Schuldübertragung sowie der doppelten oder der gespaltenen Persönlichkeit tauchen bei Chabrol immer wieder auf
+Einige Beispiele sind
+Schrei wenn du kannst
+<num>
+Das Auge des Bösen
+<num>
+Der Schlachter
+<num> und
+Masken
+<num>
+Neben Chabrol und Truffaut haben sich in Frankreich unter anderen auch Henri-Georges Clouzot und René Clément des hitchcockschen Repertoires bedient
+Übriges Europa
+Außerhalb Frankreichs war in Europa der unmittelbare Einfluss Hitchcocks auf andere Filmemacher deutlich geringer
+Einige europäische oder europäischstämmige Regisseure haben jedoch einzelne Filme gedreht denen eine Stilverwandtschaft anzuerkennen ist oder die unmittelbar als Hommage an Hitchcock gedacht sind zum Beispiel
+Ministerium der Angst
+von Fritz Lang <num>
+Der dritte Mann
+von Carol Reed <num>
+Zeugin der Anklage
+von Billy Wilder <num>
+Frantic
+von Roman Polański <num> und
+Schatten der Vergangenheit
+von Kenneth Branagh <num>
+Filmografie
+Alle Filme an denen Hitchcock beteiligt war in der Reihenfolge ihrer Produktion
+Jahr das Jahr der Uraufführung bei nicht oder erst später aufgeführten Filmen das letzte Produktionsjahr
+Beteiligung R
+Regie R
+Hitchcock drehte als Regisseur nur einzelne Szenen und wird im Abspann nicht genannt R TV
+Regiearbeiten für das Fernsehen B
+Buch nur bei namentlicher Nennung Hitchcock arbeitete jedoch an fast allen Drehbüchern seiner Filme mit und lieferte in vielen Fällen Szenen oder einzelne Dialoge P
+Produktion D
+Darsteller Statist TA
+Treatment Advisor TD
+Titel-Designer RA
+Regie-Assistent AD
+Art Director
+ohne namentliche Nennung
+Nr Position in den <num> von Hitchcock selbst inszenierten Spielfilmen
+Uraufführung für die Kinofilme nach der
+Internet Movie Database
+für die Fernsehfilme nach Donald Spoto
+<num>-<num>
+Stummfilme in Schwarzweiß
+<num>-<num>
+bis einschließlich Nr <num> Stummfilme ab Nr <num> Tonfilme alle Filme in Schwarzweiß
+<num>-<num>
+alle Filme in Schwarzweiß
+In diese Phase fällt auch Hitchcocks einzige Mitarbeit an einem längeren Dokumentarfilm German Concentration Camps Factual Survey von Mai bis Juli <num> in London
+Er hat dies später im Interview als seinen Beitrag zum Krieg bezeichnet
+Der Film wurde nicht fertiggestellt
+<num>-<num>
+Filme Nr <num> <num> <num> und <num> in Schwarzweiß alle anderen in Farbe
+Zwischen <num> und <num> trat der Regisseur in insgesamt <num> Folgen der Fernsehserien Alfred Hitchcock Presents <num> Folgen und The Alfred Hitchcock Hour <num> Folgen in der Rolle des Gastgebers auf
+<num>-<num>
+Film Nr <num> in Schwarzweiß alle anderen in Farbe
+<num>-<num>
+alle Filme in Farbe
+Auszeichnungen
+DateiHitchcock walk of famejpg
+Hitchcock wurde sechsmal für den Oscar nominiert fünfmal für die Beste Regie einmal für den Besten Film als Produzent
+Alle sechs Mal ging er leer aus was ihn zu dem Kommentar veranlasste Immer nur Brautjungfer nie die Braut Dennoch blieb er nicht oscarlos denn <num> gewann er den Irving G Thalberg Memorial Award als Spezialoscar für besonders kreative Filmproduzenten
+Zudem wurde Rebecca <num> mit dem Oscar für den besten Film ausgezeichnet den aber nicht Hitchcock sondern der Produzent David O Selznick entgegennehmen durfte
+<num> NYFCC Award als
+Bester Regisseur
+für Eine Dame verschwindet
+<num> Oscar-Nominierung für Rebecca Beste Regie
+<num> Oscar-Nominierung für Verdacht Bester Film
+<num> Oscar-Nominierung für Das Rettungsboot Beste Regie
+<num> Oscar-Nominierung für Ich kämpfe um dich Beste Regie
+<num> Kinema Junpo Award für Verdacht als Bester Fremdsprachiger Film
+<num> Preis beim Filmfestival von Locarno für Die rote Lola
+<num> Oscar-Nominierung für Das Fenster zum Hof Beste Regie
+<num> Golden Globe für The best TV-Show Alfred Hitchcock Presents
+<num> Zweiter Platz beim Laurel Award als Bester Regisseur
+<num> Silberne Muschel beim Filmfestival von San Sebastián für Vertigo - Aus dem Reich der Toten
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Silberne Muschel beim Filmfestival von San Sebastián für Der unsichtbare Dritte
+<num> Oscar-Nominierung für Psycho Beste Regie
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Zweiter Platz beim Laurel Award als Bester Regisseur
+Produzent
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Zweiter Platz beim Laurel Award als Bester Regisseur
+Produzent
+<num> Milestone Award der Producers Guild of America
+<num> Ehrung durch die Association of Cinematography Television and Allied Technicians ACTT
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Zweiter Platz beim Laurel Award als Bester Regisseur
+Produzent
+<num> Irving G Thalberg Memorial Award als Spezialoscar für besonders kreative Filmproduzenten
+<num> Ehrendoktorwürde der University of California
+<num> D W Griffith Award der Directors Guild of America
+<num> Officier des Arts et des Lettres
+<num> National Board of Review Award als Bester Regisseur für Topas
+<num> Ehrenmitgliedschaft der britischen Society of Film and Television
+<num> Golden Laurel als Bester Regisseur
+Produzent
+<num> Ernennung zum Ritter der Ehrenlegion bei der Cinémathèque française
+<num> BAFTA Award für sein Lebenswerk
+Academy Fellowship
+<num> Golden Globe für sein Lebenswerk Cecil B DeMille Award
+<num> Ehrendoktorwürde der Universität von Columbia
+<num> Grand Master Award der Mystery Writers of America
+<num> Würdigung durch die Film Society of Lincoln Center in New York
+<num> AFI Life Achievement Award des American Film Institute
+<num> Knight Commander of the British Empire
+<num> Jussi Finnland als Bester ausländischer Filmemacher
+<num> Life Career Award postum der
+Academy of Science Fiction Fantasy
+Horror Films USA
+Er wurde mit zwei Sternen auf dem Hollywood Walk of Fame geehrt
+Den einen in der Kategorie Film findet man bei der Adresse <num> Hollywood Blvd den anderen in der Kategorie Fernsehen am <num> Hollywood Blvd
+Biografische Spielfilme über Hitchcock
+The Girl TV Spielfilm <num>
+Regie Julian Jarrold Besetzung Toby Jones Alfred Hitchcock Sienna Miller Tippi Hedren Imelda Staunton Alma Reville Hitchcock Conrad Kemp Evan Hunter Penelope Wilton Peggy Robertson
+Hitchcock
+Spielfilm <num>
+Regie Sacha Gervasi Besetzung Anthony Hopkins Alfred Hitchcock Helen Mirren Alma Reville Hitchcock Scarlett Johansson Janet Leigh Danny Huston Whitfield Cook Toni Collette Peggy Robertson Michael Stuhlbarg Lew Wasserman Michael Wincott Ed Gein Jessica Biel Vera Miles James DArcy Anthony Perkins
+Dokumentarfilme
+Hitchcock - Truffaut Dokumentarfilm USA Frankreich <num> <num> Min Buch Kent Jones und Serge Toubiana Regie Kent Jones Produktion arte France Artline Films Cohen Media Group Erstsendung <num> November <num> bei arte Dossier mit Filmausschnitten vom Festival de Cannes <num>
+Literatur
+Biografien
+Laurent Bouzereau Alfred Hitchcock Knesebeck München <num> ISBN <num>-<num>-<num>-<num>-<num> mit einem Vorwort von Patricia Hitchcock OConnell und bisher unveröffentlichtem Bildmaterial und herausnehmbaren Faksimiles von Storyboards und handschriftlichen Notizen
+Charlotte Chandler Its Only a Movie Alfred Hitchcock - A Personal Biography Simon
+Schuster New York <num> ISBN <num>-<num>-<num>-<num>
+Thomas Koebner Alfred Hitchcock In Ders
+Hrsg Filmregisseure
+Biographien Werkbeschreibung Filmographien
+<num> aktualisierte und erweiterte Auflage
+Reclam Stuttgart <num> <num> Aufl <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
+Patrick McGilligan Alfred Hitchcock
+A Life in Darkness and Light
+Wiley Chichester <num> ISBN <num>-<num>-<num>-<num>
+Enno Patalas Hitchcock dtv München <num> ISBN <num>-<num>-<num>-<num>
+Donald Spoto Alfred Hitchcock - Die dunkle Seite des Genies Ins Deutsche übersetzt von Bodo Fründt
+Heyne München <num> ISBN <num>-<num>-<num>-X
+John Russel Taylor Die Hitchcock-Biographie Fischer Cinema Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num>
+Thilo Wydra Alfred Hitchcock
+Leben - Werk - Wirkung
+Suhrkamp Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+Werkschauen
+Sortiert in der chronologischen Reihenfolge der jeweiligen Originalausgabe
+Éric Rohmer Claude Chabrol Hitchcock Ed Universitaires Paris <num>
+HP
+Manz Alfred Hitchcock - eine Bildchronik Mit Texten von Hitchcock Godard Truffaut u a Sanssouci Zürich <num>
+François Truffaut
+Mr
+Hitchcock wie haben Sie das gemacht
+Heyne München <num> ISBN <num>-<num>-<num>-<num> Abfolge von Interviews circa <num> Stunden des französischen Regisseurs mit Hitchcock Originalausgabe Le cinéma selon Hitchcock <num> dt etwa Der Film gemäß Hitchcock
+Robert A Harris Michael S Lasky Hrsg Joe Hembus Alfred Hitchcock und seine Filme OT The Films of Alfred Hitchcock
+Citadel-Filmbücher bei Goldmann München <num> ISBN <num>-<num>-<num>-<num>
+François Truffaut Robert Fischer Hrsg Truffaut Hitchcock Diana Zürich <num> ISBN <num>-<num>-<num>-<num> frz Original <num> erweiterte und gebundene Ausgabe von Mr
+Hitchcock wie haben Sie das gemacht
+<num>
+Bodo Fründt Alfred Hitchcock und seine Filme Heyne Filmbibliothek Band Nr <num> München <num> ISBN <num>-<num>-<num>-<num>
+Robert E Kapsis Hitchcock The Making of a Reputation University of Chicago Press Chicago <num> ISBN <num>-<num>-<num>-<num> wissenschaftliche englischsprachige Arbeit die informationsreich den aufgebauten Ruf Hitchcocks beleuchtet und so auch auf Nachahmungen seiner Filme eingeht speziell Brian De Palma
+Frank Schnelle Hrsg Alfred Hitchcocks Psycho Verlag Robert Fischer
+Uwe Wiedleroither Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Eva Rieger Alfred Hitchcock und die Musik
+Eine Untersuchung zum Verhältnis von Film Musik und Geschlecht
+Kleine Bielefeld <num> ISBN <num>-<num>-<num>-<num>
+Donald Spoto Alfred Hitchcock und seine Filme Wilhelm Heyne München <num> ISBN <num>-<num>-<num>-X
+Lars-Olav Beier Georg Seeßlen Hrsg Alfred Hitchcock Bertz
+Fischer Berlin <num> ISBN <num>-<num>-<num>-<num>
+Bill Krohn Hitchcock at Work Phaidon Wien <num> ISBN <num>-<num>-<num>-<num> detaillierte Studie über Hitchcocks Arbeitsweise in seiner amerikanischen Zeit
+Paul Duncan Alfred Hitchcock The Complete Films Deutsch im Taschen-Verlag Köln <num> ISBN <num>-<num>-<num>-X
+Nikolai Wojtko Hrsg Alfred Hitchcock - der Filmverführer Kovac Hamburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Gregor J Weber Jeder tötet was er liebt
+Liebes- und Todesszenen in den Filmen Alfred Hitchcocks
+Schüren Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Adrian Weibel Spannung bei Hitchcock
+Zur Funktionsweise des auktorialen Suspense
+Königshausen
+Neumann Würzburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Henry Keazor Hrsg Hitchcock und die Künste Schüren Marburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Éric Rohmer und Claude Chabrol Hitchcock Hrsg und aus dem Französischen von Robert Fischer
+Alexander Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+Stephen Rebello Hitchcock und die Geschichte von Psycho Wilhelm Heyne München <num> ISBN <num>-<num>-<num>-<num>-<num> Grundlage für das Drehbuch von Hitchcock
+Paul Duncan Hrsg Alfred Hitchcock
+Sämtliche Filme
+Taschen Köln <num> ISBN <num>-<num>-<num>-<num>-<num> Mit zahlreichen Filmfotos Kinoplakaten und Bildern von Dreharbeiten
+Weiteres
+Antoine de Baecque Serge Toubiana François Truffaut - Biographie Éditions Gallimard Paris <num> dt <num> Egmont vgs Verlagsgesellschaft ISBN <num>-<num>-<num>-<num>
+FußnotenEinzelnachweise
+Hauptquellen sind die beiden Biografien von Taylor und Spoto sowie die Bücher von Truffaut und Krohn
+Weblinks
+Hitchcock-Wiki hitchcocktv - umfangreiche englischsprachige Privatseite
+Hitchcock EyeGate Sammlung Alfred Hitchcock Homepage - umfangreiche deutschsprachige Privatseite von Hermann Holzner
+abgerufen am <num> September <num>die biografischen Daten entstammen in der Regel den Biografien von Spoto und Taylor Laut Spoto dort S <num> war St Ignatius nie ein Internat wie dies andere Quellen oft behaupten zu den diesbezüglich provozierten Spuren im Werk des Regisseurs vgl Henry Keazor Hrsg Hitchcock und die Künste Marburg Schüren <num> hier insbesondere die Einleitung S <num>-<num> Vgl u a Taylor S <num>f httpswwwyoutubecomwatchvIceUa<num>c-<num>zY httpswwwyoutubecomwatchv-HXLIx<num>KhKg Er selbst bezeichnete später Der Mieter als seinen eigentlich ersten Film Vgl Duncan S <num>Vgl Spoto S <num>ff Vgl Spoto S <num> Vgl u a Duncan S <num>Verschiedene Sprachversionen waren bei den frühen Tonfilmen üblich Siehe Duncan S <num> Vgl Taylor S <num> Vgl Spoto S <num> Vgl Spoto S <num> Vgl Spoto S <num> Vgl Truffaut <num> S <num>ff Vgl Spoto S <num>-<num> Vgl Spoto S <num>ff Vgl Taylor S <num> Vgl Spoto S <num>Donald Spoto schreibt Burks sei noch im selben Jahr bei einem Hausbrand ums Leben gekommen Dies ist falsch Er starb erst <num> Vgl Taylor S <num>f Vgl Spoto S <num>f Hitchcock im September <num> siehe Spoto S <num> Siehe Spoto S <num> Vgl Spoto S <num>ff Siehe Donald Spoto The Art of Alfred Hitchcock Fifty Years of Motion Pictures New York London etc Doubleday <num> S <num>-<num> Vgl Truffaut <num> S <num> Vgl Truffaut <num> S <num> In Psycho indem die Mutter über ihren Tod hinaus von ihrem Sohn Besitz ergreift und Nebenbuhlerinnen ermordet In Die Vögel ist die Mutter nicht in der Lage ihren erwachsenen Sohn loszulassen Hitchcock selbst sagte hierzu Sie hat ihren Sohn ihren Ehemann ersetzen lassen Siehe Spoto S <num> Bezeichnenderweise beginnt Hitchcocks erster Film Irrgarten der Leidenschaft mit einer Treppenszene und sein letzter Film Familiengrab endet mit einer solchen Hitchcock erklärte die Verwendung dieser Symbolik so Psychologisch betrachtet haben die Handschellen natürlich eine tiefere Bedeutung Irgendwie hat es schon etwas mit Fetischismus zu tun und hat auch sexuelle Untertöne Als ich einmal in Paris das Kriminalmuseum besuchte bemerkte ich dass sexuelle Abartigkeiten sehr häufig im Zusammenhang mit Fesselung standen Siehe Spoto S <num> Vgl Spoto S <num>f In Verdacht ist Grant ein Hochstapler und Verführer der sich über beide Ohren verschuldet seine Frau belügt und von ihr verdächtigt wird sie ermorden zu wollen In Berüchtigt erwartet er als Geheimdienstmitarbeiter von der Frau mit der er eine Liebesbeziehung hat dass diese aus staatsbürgerlichem Pflichtbewusstsein mit einem anderen Mann schläft Als sie dies tut und den anderen sogar heiratet übersieht er in seiner Eifersucht lange dass sie dabei ist vergiftet zu werden Die Blondine erscheint vor allem in Hitchcocks berühmtesten und erfolgreichsten Filmen der <num>er- und <num>er-Jahre verkörpert durch Grace Kelly Eva Marie Saint Kim Novak Janet Leigh und Tippi Hedren In früheren Filmen standen Anny Ondra Madeleine Carroll Joan Fontaine und vor allem Ingrid Bergman für diesen Typus und selbst in seinen ganz frühen Filmen traten blonde Hauptdarstellerinnen auf Corey K Creekmur Alexander Doty Out in Culture Gay Lesbian and Queer Essays on Popular Culture Continuum International Publishing Group <num> S <num> Shohini Chaudhuri Feminist Film Theorists Laura Mulvey Kaja Silverman Teresa de Lauretis Barbara Creed Taylor
+Francis <num> S <num> Siehe Truffaut <num> S <num> Siehe Truffaut <num> S <num> Vgl Spoto S <num> Siehe Spoto S <num> Gegenüber Truffaut bezeichnete er dies als idiotisch und als verzeihlichen Versuch als weitaus größeren Fehler nämlich als unverzeihlichen Irrtum sah er jedoch an dass er ein Jahr später in Sklavin des Herzens die gleiche Methode wiederholte und bis zu sieben Minuten lange ungeschnittene Einstellungen drehte für die es keine Notwendigkeit gab Vgl Truffaut <num> S <num> <num> Siehe Spoto S <num> Vgl Spoto S <num> Siehe Spoto S <num> Vgl Truffaut <num> S <num> Siehe Spoto S <num> Vgl Spoto S <num> <num> Es gibt über ein Dutzend Filme mit solchen Einstellungen Sehr eindrucksvoll ist der stumme Schrei von Lydia Brenner Jessica Tandy in
+Vgl auch Duncan S <num>Vgl Foster Hirsch
+The Dark Side of the Screen Film Noir
+Da Capo Press Boston <num> unpaginiert Auszug Siehe Truffaut <num> S <num> Donald Spoto Alfred Hitchcock - Die dunkle Seite des Genies S <num> Vgl u a Spoto S <num> <num>f Vgl Spoto S <num>ff In dem Film No Bail for the Judge den er <num> mit Audrey Hepburn inszenieren wollte in einem Film namens Frenzy über einen psychopathischen Frauenmörder den er <num> drehen wollte und der nichts mit dem gleichnamigen Film von <num> zu tun hat und in seinem letzten Projekt The Short Night das er ab <num> verfolgte und nicht mehr zu Ende bringen konnte Vgl Spoto S <num> Vgl Spoto S <num>ff Vgl Spoto S <num>ff Vgl Spoto S <num> <num> Vgl Spoto S <num> <num> Vgl Krohn S <num>f Vgl Krohn S <num>ff Vgl Krohn S <num>ff Hitchcock selbst nannte es die impertinenteste Schlusseinstellung die ich je gemacht habe s Truffaut <num> S <num> Siehe Spoto S <num> Taylor über die Zusammenarbeit bei Vertigo siehe Spoto S <num> Siehe Truffaut <num> S <num>siehe Spoto <num> S <num>f Vgl Truffaut <num> S <num>ff Ein Beispiel ist der Dialog in der dreiminütigen Kussszene zwischen Cary Grant und Ingrid Bergman in Berüchtigt der die einzelnen Küsse verbindet Vgl Spoto S <num>f <num> John Michael Hayes über die Zusammenarbeit an Das Fenster zum Hof in Spoto S <num> So geschah dies mit Evan Hunter Ernest Lehman oder Anthony Shaffer - drei Autoren mit denen Hitchcock zuvor erfolgreich zusammengearbeitet hatte Vgl Spoto S <num> <num>f und <num> Siehe Spoto S <num>f Gute Kontakte pflegte er auch mit Tallulah Bankhead Ingrid Bergman Anny Ondra oder Carole Lombard So durfte Joseph Cotten seine Garderobe für Im Schatten des Zweifels selbst aussuchen während Marlene Dietrich in Die rote Lola sogar dem Kameramann und dem Beleuchter Anweisungen geben durfte wie sie am besten auszuleuchten und aufzunehmen sei Vgl Spoto S <num> Vgl u a Truffaut <num> S <num>f <num> <num> <num> Siehe Duncan S <num> Siehe Spoto S <num>Klangbeispiele und umfangreiche Informationen zur Zusammenarbeit von Hitchcock mit Herrmann finden sich im Artikel
+Hitchcocks Hofkomponist Bernard Herrmann
+moviepilotdeSiehe
+Vgl Spoto S <num> <num> <num>Vgl u a HarrisLasky Seite <num>Laut Hitchcocks Aussage in einem späteren Interview sei die erste Idee gewesen ihn als Leiche am Rettungsboot vorbei treiben zu lassen doch dies wurde verworfen da Hitchcock nach eigenen Angaben zu große Angst vor dem Ertrinken hatte Hitchcock erhielt <num> Dollar pro Folge und jeweils nach der ersten Ausstrahlung alle Rechte an der Weiterverwertung - ein zu damaliger Zeit beispielloser Vertrag Vgl u a Spoto S <num>ff Vgl Spoto S <num>ff <num> Taylor S <num>ff Siehe hitchcocktv Vgl Duncan S <num> Hitchcock genoss diese Anerkennung obwohl er das Ausmaß der Begeisterung nicht ganz verstand - er sah sich selbst nie als Autorenfilmer Joseph Stefano mit dem Hitchcock zu dieser Zeit zusammenarbeitete sagte später Hitchcock liebte die Aufmerksamkeit und das Getue und den Ruhm und wenn er nicht verstand weshalb man so eine Aufregung machte dann fühlte er sich doch nicht verpflichtet es zu ergründen Es war gut für das Geschäft und es war gut für sein Ego Siehe Spoto S <num>vgl de BaecqueToubiana S <num>Weitere Beispiele
+Die Wendeltreppe
+von Robert Siodmak <num>
+Es geschah am hellichten Tag
+von Ladislao Vajda <num> und
+Do You Like Hitchcock
+von Dario Argento <num> Vgl Spoto S <num>
+Die Auteur-Theorie von frz Auteur
+Autor ist eine Filmtheorie und die theoretische Grundlage für den Autorenfilm - insbesondere den französischen - in den <num>er Jahren der sich vom Produzenten-Kino abgrenzte
+Auch heute noch wird die Definition des Auteur-Begriffs ständig weiterentwickelt
+Im Zentrum des Films steht für die Auteur-Theorie der Regisseur oder Filmemacher als geistiger Urheber und zentraler Gestalter des Kunstwerks
+Geschichte der Auteur-Theorie
+Ende der <num>er Jahre wurde eine erste Auteur-Theorie von dem französischen Filmkritiker Alexandre Astruc formuliert indem er die Frage nach dem geistigen Besitz eines Films aufwarf
+Im traditionellen Schaffensprozess lassen sich die Anteile von Drehbuchautor Kameramann und Filmregisseur am Gesamtwerk nur schwer zuordnen
+Durch die Zuteilung der Teilaufgaben als Honorartätigkeit durch die Filmgesellschaften leide die Kreativität so die These
+Im Umkehrschluss fordert diese Theorie die Zusammenführung der Tätigkeiten zu einer kreativen Einheit
+Er formulierte seinen Entwurf in dem Aufsatz La caméra-stylo Die Kamera sollte wie ein Stift verwendet werden
+Er war sich sicher dass bedeutende Schriften in Zukunft nicht mehr als Text sondern mit der Kamera geschrieben würden
+Doch durchgesetzt haben sich solche und ähnliche Ideen der Auteur-Theorie erst in den <num>er Jahren
+Deren gängiger Begriff als Wegbereiter für die heutige Auteur-Theorie lautete zunächst politique des auteurs Autoren-Politik was erst im Laufe der Zeit zur Theorie umgeformt wurde
+Das Wort politique bzw Politik stand hier also eher für Parteilichkeit welche für filmwissenschaftliche Diskussionen eher hinderlich ist siehe unten
+Die politique des auteurs wurde zu dieser Zeit von einer Gruppe von jungen Filmkritikern um André Bazin entwickelt die für die Filmzeitschrift
+Cahiers du cinéma
+schrieben
+Eine wesentliche Rolle spielte dabei François Truffaut Im Januar <num> veröffentlichte er seinen Aufsehen erregenden Aufsatz
+Eine gewisse Tendenz im französischen Film
+Une certaine tendance du cinéma français in dem er sich mit scharfer Polemik gegen den etablierten französischen Qualitätsfilm wandte
+Bei diesem trat der Regisseur gegenüber dem Drehbuchautor und dem Autor der literarischen Vorlage oft in den Hintergrund
+Truffaut plädierte dagegen für einen Film bei dem Form und Inhalt vollständig vom Regisseur selbst als dem eigentlichen auteur des Films bestimmt werden
+Er fand das bei traditionell als Autoren ihrer Filme betrachteten europäischen Regisseuren wie Luis Buñuel Jean Renoir und Roberto Rossellini außerdem aber auch und vor allem bei Regisseuren wie Alfred Hitchcock Howard Hawks Fritz Lang und Vincente Minnelli die zum großen Teil als Vertragsregisseure im Studiosystem Hollywoods arbeiteten deren Filme aber trotzdem einen persönlichen Stil aufweisen
+Das Konzept des Regisseurs als auteur seiner Filme wurde für die Filmkritik der Cahiers du cinéma bestimmend und damit für die Regisseure der Nouvelle Vague die daraus hervorgingen neben Truffaut etwa Jean-Luc Godard Jacques Rivette oder Claude Chabrol - Filmemacher die sich zur Umsetzung ihrer künstlerischen Ziele einer jeweils ganz eigenen filmischen Form bedienten
+Roland Barthes hingegen misst in seinem Essay La mort de lauteur <num>
+Der Tod des Autors
+dem Autor für die Literatur eine weitaus geringere Bedeutung bei als es bisher der Fall war
+Der Auteur-Dieu Autoren-Gott wird von Barthes durch den écrivain den Schriftsteller ersetzt und folgt damit einer Kritik die Julia Kristeva bereits <num> in ihrem Aufsatz
+Bakhtine le mot le dialogue et le roman Bachtin das Wort der Dialog und der Roman <num> aufbrachte
+Für den europäischen Film blieb die Auteur-Theorie aber noch bis in die <num>er prägend
+Danach setzte auch hier eine Abkehr von der verhängnisvollen Macht der Regisseure Günter Rohrbach ein
+Wirtschaftlicher Druck zwang zur Rückkehr zu einer arbeitsteiligen Produktionsweise wie sie für den Produzenten-Film charakteristisch ist
+Damit einher ging notwendigerweise auch wieder die Einigung aller Beteiligten auf einen kleinsten gemeinsamen Nenner und somit auch häufig eine gewisse Banalisierung der Filminhalte die umso stärker zu Tage tritt je weniger der Produzent als Projektverantwortlicher in den eigentlichen schöpferischen Prozess eingebunden ist
+In der Filmwissenschaft wurden auch immer neue Autorschaften von Teammitgliedern entdeckt
+In der Realität ist Film Teamarbeit und es ist dem Film nicht anzusehen ob zum Beispiel die Idee für eine Einstellung nun vom Regisseur oder vom Kameramann stammt
+Im Dogma-Film ist der Kameramann nicht weisungsgebunden
+Die Polnische Schule bindet den Kameramann bereits in den Prozess des Drehbuchschreibens ein
+Unerfahrene Regisseure sind meist sehr auf die Kreativität des Kameramanns oder der Kamerafrau und anderer Teammitglieder angewiesen
+Durch das Aufkommen digitaler Aufnahmetechniken wie Digital Video seit Ende der <num>er Jahre sehen viele Filmemacher wie etwa Wim Wenders wieder günstigere Bedingungen für individuelle subjektive Produktionen gegeben
+Kritik und Diskussion
+Die von François Truffaut und Jean-Luc Godard proklamierte politique des auteurs Autorenpolitik der fünfziger Jahre war ursprünglich ein Versuch bestimmte Regisseure wie Alfred Hitchcock als Künstler anzuerkennen die ihre völlig eigene Bildsprache entwickelten oder wie Truffaut selber sämtliche Aspekte ihrer Filme selbst bestimmten
+Ein Autorenfilmer ist demnach ein Regisseur der einen Film - möglichst ohne Kompromisse - so gestaltet wie er ihn selbst haben möchte
+Die politique des auteurs geriet schnell in die Kritik
+Kritiker wie Andrew Sarris und Peter Wollen wiesen auf ein empirisches Problem hin Niemand kann beweisen wie viel Einfluss der Regisseur wirklich auf seine Filme hatte bzw welchen Einfluss Form und Inhalt wirklich auf das haben was wir als Autorschaft wahrnehmen
+Als Beispiel hierfür gilt der Vorspann von
+Vertigo - Aus dem Reich der Toten
+<num> den Alfred Hitchcock nicht selbst angefertigt hat oder die Tatsache dass viele seiner Filme auf einer Buchvorlage fremder Autoren basieren und selbst die Drehbücher selten von ihm selbst stammten
+Gerade Hitchcock aber ist eine zentrale Figur in der politique des auteurs
+Wie der Name politique des auteurs sagt handelte es sich um eine Politik einen gezielten polemischen Eingriff
+Der Village-Voice-Kritiker Andrew Sarris übersetzte politique des auteurs jedoch <num> mit auteur theory wobei unklar blieb in welchem Sinne es sich hier tatsächlich um eine
+Theorie
+handelt
+Sarris popularisierte diese Theorie im englischen Sprachraum und benutzte sie vor allem um die absolute Überlegenheit des Hollywood-Kinos darzulegen war er doch davon überzeugt es sei the only cinema in the world worth exploring in depth beneath the frosting of a few great directors at the top Nun war die Frage Wo ist die Grenze
+Wen oder vielmehr was nehmen wir als Autor wahr
+Soziologisch gesehen war die Autorentheorie eine Distinktionsstrategie junger Kritiker die auf sich aufmerksam machen wollten
+Godard hat dies später offen zugegeben Wir sagten von Preminger und den anderen Regisseuren die für Studios arbeiteten wie man heute fürs Fernsehen arbeitet Sie sind Lohnempfänger aber gleichzeitig mehr als das denn sie haben Talent einige sogar Genie
+aber das war total falsch
+Wir haben das gesagt weil wir es glaubten aber in Wirklichkeit steckt dahinter dass wir auf uns aufmerksam machen wollten weil niemand auf uns hörte
+Die Türen waren zu
+Deshalb mussten wir sagen Hitchcock ist ein größeres Genie als Chateaubriand
+In den siebziger Jahren folgte dann die stärkste Kritik an der politique des auteurs Roland Barthes proklamierte bereits <num> vor einem poststrukturalistischen Hintergrund den Tod des Autors Der Autor wurde nun aufgrund des empirischen Dilemmas der Beweisbarkeit von Autorschaften als Image-Figur erkannt die sich aus ihrer Umwelt formt und in die Werke einschreibt
+Auch von feministischer Seite wurde die politique des auteurs scharf angegriffen diene sie doch dazu den kollektiven Charakter des Filmemachens zu verdecken und in der Tradition patriarchaler Heldenverehrung Männer zu Superstars zu stilisieren
+Claire Johnston verteidigte den Ansatz insofern als dieser einer zu monolithischen Sicht des Hollywood-Kinos entgegenwirke
+In den neunziger Jahren schließlich ging die Tendenz zu der Annahme dass Autorschaften zum Großteil z T kommerziell konstruiert sind
+Timothy Corrigan nennt dies den commercial auteur Es wird damit gerechnet dass das Publikum den Film eines als Autor bekannten Regisseurs als z B Der neue Woody Allen wahrnimmt ohne wirklich zu wissen wie viel Einfluss Woody Allen tatsächlich auf den Film hatte
+Dana Polan verfolgte einen weiteren interessanten Ansatz Er sieht den auteurist als Hauptverantwortlichen für konstruierte Autorenbilder
+Das sind Kritiker die den Autor als höchste Instanz suchen und damit - wie François Truffaut - auf einen Filmemacher als Künstler hinweisen wollen und nebenbei ihre eigene Erkenntniskraft zelebrieren
+Der Begriff dafür lautet Auteur Desire Dieser Ansatz zeigt noch einmal den größten Vorwurf gegenüber der politique des auteurs auf
+Doch trotzdem ist die Nennung eines Regisseurs parallel zu - beispielsweise - einem Buchautor als Schöpfergeist auch unter reflektierenden Filmkritikern und -wissenschaftlern weiterhin außerordentlich beliebt
+Steckt also doch mehr dahinter
+Ein neuerer Ansatz die kontextorientierte Werkanalyse von Jan Distelmeyer versucht diese Frage zu klären
+Als Grundlage dienen Publikums- und Kritikerrezeption auf der einen Seite und die Konstruktion des Autors aus Biografie Filmindustrie und kulturellem Umfeld auf der anderen Seite
+Diese zweiseitige Annäherung erkennt das empirische Dilemma der Definition von auteur an und maßt sich auch keine Bestimmung dessen an was jetzt eigentlich das Werk von Autor XYZ ist
+Viele andere Filmtheoretiker verfolgen heutzutage ähnliche Konzepte
+Doch auch eine solch freie Handhabung kann das Problem nicht vollständig lösen da die wichtigsten Elemente variabel sind und sich so einer eindeutigen Aussage verschließen
+Der Schwerpunkt kritischer Tendenzen liegt also zum Großteil in der Empirie
+Einen Filmemacher als auteur anzuerkennen fordert uneingeschränktes Vertrauen in seine Aussagen wie viel Einfluss er auf seine eigenen Filme hatte
+Da dies in Zeiten einer sehr starken Vermarktung aller möglichen mehr oder weniger unabhängigen Regisseure seitens von Filmindustrie und Verleih ein fast aussichtsloses Unterfangen ist ist ein Restzweifel und das stete Hinterfragen der auteur-Definition angebracht
+weitere Quellenangaben zu diesem Abschnitt Kritik und Diskussion im Literaturverzeichnis
+Einzelnachweise
+Wichtige Auteur-Theoretiker
+André Bazin
+Andrew Sarris
+Claude Chabrol
+Dana Polan
+Éric Rohmer
+François Truffaut
+Jan Distelmeyer
+Jean-Luc Godard
+Peter Wollen
+Roland Barthes
+Timothy Corrigan
+Literatur
+François Truffaut Une certaine tendance du cinéma français In Cahiers du cinéma <num> Januar
+Übersetzung A Certain Tendency of the French Cinema In Bill Nichols Hrsg Movies and Methods Berkeley <num> S <num>-<num>
+Jean-Luc Godard GodardKritiker München <num> S <num>-<num>
+Jean-Luc Godard Einführung in eine wahre Geschichte des Kinos Hanser <num> ISBN <num>
+Andrew Sarris Towards a Theory of Film History In Bill Nichols Hrsg Movies and Methods Berkeley <num> S <num>-<num>
+Peter Wollen The Auteur Theory In Signs and Meaning in the Cinema London <num> S <num>-<num>
+Roland Barthes Der Tod des Autors In Fotis Jannidis Gerhard Lauer Mathias Martinez Simone Winko Hrsg Texte zur Theorie der Autorschaft Stuttgart <num> S <num>-<num>
+Timothy Corrigan A Cinema without Walls
+Movies and Culture after Vietnam
+New Brunswick <num> S <num>-<num>
+Dana Polan Auteur Desire In
+Nr <num> Auteurism <num>
+Jan Distelmeyer Vom auteur zum Kulturprodukt
+Entwurf einer kontextorientierten Werkgeschichtsschreibung
+In Andrea Nolte Hrsg Mediale Wirklichkeiten Dokumentation des <num> Film- und Fernsehwissenschaftlichen Kolloquiums
+Marburg <num> S <num>-<num>
+Jean-Luc Godard Einführung in eine wahre Geschichte des Kinos Hanser <num> ISBN <num> S <num>
+DateiAki Kaurismäki at Berlinale <num>jpg Aki Olavi Kaurismäki
+<num> April <num> in Orimattila ist ein vielfach preisgekrönter finnischer Filmregisseur
+Leben und Werk
+Aki Kaurismäki studierte an der Universität Tampere Literatur- und Kommunikationswissenschaften
+Neben diversen Aushilfsjobs etwa als Briefträger oder in der Gastronomie war er Herausgeber eines universitären Filmmagazins
+Darüber hinaus schrieb er von <num> bis <num> Filmkritiken für das Magazin Filmihullu
+Das erste Drehbuch folgte <num> für den mittellangen Film Der Lügner Valehtelija bei dem sein Bruder Mika Regie führte
+Kaurismäkis Filme thematisieren häufig Schicksale von gesellschaftlichen Außenseitern in städtischen Zentren wie Helsinki
+Sie sind nicht nur für ihre sparsamen Dialoge sondern auch für einen skurril-lakonischen Humor bekannt
+Kaurismäki arbeitet regelmäßig mit einem festen Stamm befreundeter Schauspieler und Musiker die seine Filme auch stilistisch geprägt haben Matti Pellonpää Kati Outinen Kari Väänänen und Sakke Järvenpää
+Als Reminiszenz an Alfred Hitchcock hat er in seinen Filmen gelegentlich Cameo-Auftritte was auch Hitchcock zu tun pflegte
+In Deutschland wurden seine Filme zum ersten Mal <num> auf dem Filmfestival Grenzland-Filmtage in Selb gezeigt
+Aki Kaurismäki führte dabei die Filme Der Lügner Calamari Union
+und
+Crime and Punishment
+persönlich vor Während des Festivals schrieb er das Drehbuch für seinen Film
+Schatten im Paradies den er <num> erneut persönlich bei den Grenzland-Filmtagen in Selb präsentierte
+Dieser Film brachte ihm den internationalen Durchbruch
+Ein Großteil der Filmmusik kam von der Band Nardis aus Erlangen die Kaurismäki <num> auf den Grenzland-Filmtagen kennengelernt hatte
+Dem breiten deutschen Publikum bekannt wurde der finnische Regisseur durch seine Teilnahme an der Berlinale <num>
+Für großes Aufsehen sorgte Kaurismäki im Herbst <num> als er sich weigerte seinen Film
+Lichter der Vorstadt
+als offiziellen finnischen Beitrag für eine Oscar-Nominierung in der Kategorie Bester fremdsprachiger Film zuzulassen obwohl das Drama von der finnischen Filmkammer einstimmig ausgewählt worden war
+Kaurismäki begründete seine Ablehnung mit seiner seit Jahren vertretenen kritischen Haltung gegen den Irak-Krieg der USA
+Zusammen mit seinem Bruder Mika Kaurismäki gründete er das Midnight Sun Film Festival im lappischen Sodankylä sowie die Verleihfirma Villealfa
+Der Name geht zurück auf die Figur Ville Alfa den Protagonisten im Film Der Lügner
+Gleichzeitig handelt es sich um ein Anagramm von
+Alphaville einem Film von Jean-Luc Godard
+<num> emigrierte Kaurismäki mit seiner Frau nach Portugal weil es in ganz Helsinki keinen Platz mehr gebe wo er seine Kamera noch postieren könne
+Rainer Gansera der für die Zeitschrift epd Film mit dem Chef-Melancholiker des europäischen Autorenkinos <num> in Hof gesprochen hat zeigte sich auch von seinem Auftreten persönlich beeindruckt und beschrieb atmosphärisch
+Als persönliche Leitbilder will Kaurismäki Bresson Ozu und Godard gesehen haben der Ausbildung an den Filmhochschulen seines Landes dagegen habe er nicht viel Positives abgewinnen können
+Bei Pandora sind Ende <num> als Aki Kaurismäki DVD-Collection <num> Spielfilme und fünf Kurzfilme mit digital restaurierten Bildern in vier Boxen erschienen
+<num> stellte Kaurismäki nach fünf Jahren mit
+Le Havre
+einen Spielfilm fertig der ihm wieder einmal eine Einladung in den Wettbewerb der Filmfestspiele von Cannes einbrachte
+Der in Frankreich gedrehte Film handelt von einem Schuhputzer aus der gleichnamigen Hafenstadt der sich eines illegalen Flüchtlingskindes aus Afrika annimmt
+Le Havre gewann in Cannes den FIPRESCI-Preis
+Für den Spielfilm
+Die andere Seite der Hoffnung
+erhielt Kaurismäki <num> eine Einladung in den Wettbewerb der <num> Internationalen Filmfestspiele Berlin
+Der Film spielt in Helsinki und erzählt von der Begegnung eines älteren finnischen Handelsvertreters dargestellt von Sakari Kuosmanen mit einem jungen syrischen Flüchtling Sherwan Haji
+Der Film kam am <num> Februar <num> in die finnischen Kinos
+Filmografie
+Regisseur
+<num> The Saimaa Gesture Saimaa-ilmiö - Dokumentarfilm mit seinem Bruder Mika
+<num> Crime and Punishment Rikos ja rangaistus
+<num> Der Clan - Geschichte der Frösche Klaani - tarina Sammakoitten suvusta - Co-Autor seines Bruders Mika
+<num> Calamari Union
+<num> Rocky VI - Kurzfilm
+<num> Schatten im Paradies Varjoja paratiisissa
+<num> Hamlet goes Business Hamlet liikemaailmassa
+<num> Thru The Wire - Kurzfilm
+<num> Rich Little Bitch - Kurzfilm
+<num> Ariel
+<num>
+Likaiset kädet
+- Produktion für das finnische Fernsehen
+<num> Leningrad Cowboys Go America
+<num> Das Mädchen aus der Streichholzfabrik Tulitikkutehtaan tyttö
+<num> Vertrag mit meinem Killer I Hired a Contract Killer
+<num> Those Were The Days - Kurzfilm
+<num> Das Leben der Bohème Boheemielämää
+La vie de Bohème
+<num> These Boots - Kurzfilm
+<num> Tatjana - Take Care Of Your Scarf Pidä huivista kiini Tatjana
+<num> Total Balalaika Show
+<num> Leningrad Cowboys Meet Moses
+<num> Wolken ziehen vorüber Kauas pilvet karkaavat
+<num> Juha
+<num> Der Mann ohne Vergangenheit Mies Vailla Menneisyyttä
+<num> Dogs Have No Hell - Kurzfilmbeitrag in
+Ten Minutes Older The Trumpet
+<num> Lichter der Vorstadt Laitakaupungin valot
+<num> Le Havre
+<num> Juice Leskinen
+Grand Slam Bluesia Pieksämäen asemalla - Kurzfilm
+<num> Tavern Man - Beitrag in Historic Centre
+<num> Die andere Seite der Hoffnung Toivon tuolla puolen
+Schauspieler
+<num> Der Lügner Valehtelija - auch Drehbuchautor Film seines Bruders Mika
+<num> The Worthless Arvottomat - auch Drehbuchautor und Regieassistent Film seines Bruders Mika
+<num> Aaltra
+<num> Estrada de Palha
+<num> Vandaleyne Cameo
+Auszeichnungen
+DVD
+Aki Kaurismäki Collection
+Pandora Film <num> <num> DVDs mit insgesamt <num> Filmen aus den Jahren <num>-<num>
+Literatur
+Peter von Bagh
+Kaurismäki über Kaurismäki Alexander Berlin <num> ISBN <num>-<num>-<num>-<num>-<num> Gespräche und Essays mit rund <num> Abbildungen
+Beate Rusch Hrsg Schatten im Paradies
+Von den Leningrad Cowboys bis Wolken ziehen vorüber - Die Filme von Aki Kaurismäki
+Berlin Schwarzkopf
+Schwarzkopf Verlag <num> ISBN <num>-<num>-<num>-<num> Fotografien von Marja-Leena Hukkanen mit Begleittexten von Aki Kaurismäki
+Jochen Werner Aki Kaurismäki Mainz Bender <num> <num> S <num> sw-Abb ISBN <num>-<num>-<num>-<num> Analyse aller Kaurismäkifilme und ein langes Interview mit Kaurismäki
+Ulrike Hanstein Unknown Woman geprügelter Held die melodramatische Filmästhetik bei Lars von Trier und Aki Kaurismäki Berlin Alexander <num> ISBN <num>-<num>-<num>-<num>
+Ralph Eue und Linda Söffker Hrsg Aki Kaurismäki film <num> Mit Beiträgen von Lars-Olav Beier Harun Farocki Ulrich Gregor Anke Leweke und Jan Schulz-Ojala
+Berlin Bertz
+Fischer Verlag <num> <num> S <num> sw-Fotos
+Bildsequenzen ISBN <num>-<num>-<num>-<num>
+Reinhold Zwick Wolken ziehen herauf und vorüber
+Strukturen des Komischen in der Bibel und bei Aki Kaurismäki
+in StOrthJValentinRZwick Hrsg Göttliche Komödien
+Religiöse Dimensionen des Komischen im Kino Film und Theologie Bd <num> Köln <num> S <num>-<num>
+Reinhold Zwick Selig die Armen in den Wohncontainern
+Aki Kaurismäki und seine Tragikomödie Der Mann ohne Vergangenheit
+in Stimmen der Zeit <num> <num> S <num>-<num>
+Reinhold T Schöffel Grenzland Filmtage
+Programm
+Grenzlandfilmtage eV Wunsiedel <num> S <num>-<num>
+Weblinks
+Aki Kaurismäki von Stadtbibliothek Orimattila finnischenglisch
+Aki Kaurismäki - Die Helden diesseitig und einsam Dietrich Kuhlbrodt epd Film <num><num>
+Begrabt mein Herz an der Müllkippe Andreas Kilb Die Zeit <num><num>
+Wo ich lebe ist immer ein Schatten Interview im Stadtmagazin Zitty <num>
+Kino der Lakonik Filmzyklus in Zürich
+Einzelnachweise
+Ralph Eue Biografische Skizze In Ralph Eue und Linda Söffker S <num>-<num> Grenzland Filmtage Programm Grenzlandfilmtage eV Wunsiedel <num> S <num>-<num> epd Film <num><num> S <num>Eue S <num> epd Film <num><num> S <num>Hopewell John
+bei varietycom <num> Mai <num> aufgerufen am <num> Mai <num> Aunimo Rane
+bei demokraattifi <num> April <num> abgerufen am <num> März <num> Taavitsainen Iikka
+bei savonsanomatfi abgerufen am <num> April <num> httpwwwimdbcomtitlett<num> Rezension von Dietmar Kammerer taz vom <num> Oktober <num> abgerufen <num> September <num>
+Anime jap
+im Deutschen häufig
+Plural Animes bezeichnet in Japan produzierte Zeichentrickfilme
+In Japan selbst steht Anime für alle Arten von Animationsfilmen und -serien für die im eigenen Land produzierten ebenso wie für importierte
+Er bildet das Pendant zum Manga dem japanischen Comic
+Japan besitzt die umfangreichste Trickfilmkultur weltweit
+Definition und Begriffsgeschichte
+Im Japanischen kann Anime jegliche Animationsfilme bezeichnen sowohl die aus dem eigenen Land als auch aus dem Ausland
+Außerhalb Japans wird der Begriff ausschließlich für Animationsfilm japanischer Herkunft verwendet
+Historisch wurden Animationsfilme in Japan lange Zeit nicht Anime genannt
+Zu Beginn des <num> Jahrhunderts gab es zunächst die Worte senga Linienkunst und kuga Klapp-Bilder vgl Daumenkino dekobō shin gachō schelmische neue Bilder oder chamebō-zu verspielte Bilder Später kamen manga eiga
+Manga-Filme und dōga
+bewegte Bilder auf
+Erst in den <num>er Jahren tritt das Wort Anime in Japan zusammen mit der Wortschöpfung Japanimation auf
+Letztere wird ausschließlich für die damals erstmals stark wachsende eigene Animationsbranche verwendet Anime entstand als eine Verkürzung des japanischen Lehnwortes animēshon
+von
+Während animēshon eher als Bezeichnung für höher geachtete Animationskunst und Kinofilme verwendet wurde wurde dessen Kurzform vor allem für die ab den <num>er entstehenden günstiger produzierten Fernsehserien verwendet Letztlich setzte sich Anime als Bezeichnung aller Animationsproduktionen durch
+Die anderen Begriffe blieben nur in Nischen erhalten Als Bezeichnung nur für japanische Animationsfilme und -serien hat sich der Begriff seit den <num>er Jahren in den USA und Europa durchgesetzt Im englischen Sprachraum wurde seit Ende der <num>er Jahre in der kleinen Fanszene und von ersten kommerziellen Vertrieben zunächst häufiger Japanimation verwendet was jedoch zu Verballhornungen und Missverständnissen führte
+So wurde dieses Wort um <num> von dem aus Japan übernommenen kürzeren Anime abgelöst
+Im wissenschaftlichen oder journalistischen Diskurs ist die genaue Abgrenzung zwischen Anime und Animation allgemein jedoch umstritten
+auch wenn Anime und japanischer Animationsfilm meist synonym verwendet werden
+So nennt Thomas Lamarre eine Abgrenzung von Full Animation und Limited Animation im japanischen Diskurs
+Anime besonders Fernseh-Anime in der einfachen kostengünstig produzierten Form der <num>er Jahre wird dann als eine Form der Limited Animation aufgefasst
+Produzenten von Full Animation wollen sich davon abgrenzen
+Beispielsweise lehnt das Studio Ghibli den Begriff Anime für ihre Filme ab und verwendet stattdessen manga eiga Aufwändige Filme und Fernsehproduktionen haben jedoch gemeinsam dass die Ästhetik traditioneller Animationstechniken fast immer erhalten wird auch wenn vielfach Computeranimationen zum Einsatz kommen
+Reine Computeranimationsfilme denen diese Technik auch anzusehen ist und die nach Realismus streben kommen zwar vor sind aber eine Ausnahme Stevie Suan und José Andrés Santiago Iglesias nennen eine Reihe von Stil-Merkmalen die japanischen Fernsehproduktionen und solchen mit japanischem Einfluss zu eigen sind Eine durchgehende Erzählung über alle Folgen der Gebrauch von Cliffhangern und deren Auflösung durch Eukatastrophen reduziertes und ikonisches Charakterdesign größere Vielfalt in der Farbpalette Gebrauch von Limited Animation und die Erzeugung eines Raumeindrucks durch Bewegung sowie der Einsatz vieler Schnitte Kameraeinstellungen und Montagen zur Darstellung vieler Perspektiven und Details einer Szene
+Die Gesamtheit dieser Merkmale fassen Suan und Iglesias unter dem Begriff animesque zusammen
+Ein animesques Werk wird von Fans als Anime erkannt da es die erzählerischen und formalen Erwartungen erfüllt die mit dem japanischen Animationsfilm verbunden werden Brian Ruh verweist neben den von Iglesias genannten Stilmerkmalen auf die Transnationalität des Mediums Anime die sich in dessen Geschichte als auch in international verständlichen Designs äußert Ähnlich beschreiben auch andere Autoren ein Verständnis von Anime als in einen Medienmix eingebundene Fernseh-Serienproduktionen mit auch in ihren Filmadaptionen wiedererkennbaren im Fernsehen entstandenen Stil- und Erzählmerkmalen Daneben gibt es Produkte des japanischen Animationsfilms die von einigen Rezipienten nicht als Anime angesehen werden sondern einem unbestimmten Alternativen japanischen Animationsfilm oder nur allgemein Animationsfilm zugerechnet werden
+Jonathan Clements weist ebenfalls auf mehrere Abgrenzungsunschärfen des Begriffs hin Neben der technischen zwischen Full und Limited Animation gibt es Autoren die Anime historisch abgrenzen als japanischen Animationsfilm ab den Fernsehserien der <num>er Jahre
+Japanischer Animationsfilm aus der Zeit davor wird dann nicht als Anime bezeichnet obwohl die frühen Filme von großer Bedeutung für die späteren Produktionen waren
+Weitere Unschärfen ergeben sich aus dem umfangreichen Prozess von Produktion Vertrieb und Konsum
+So sind einige ausländische - insbesondere US-amerikanische - Trickfilmproduktionen unter japanischer Mitwirkung oder sogar großteils in Japan entstanden andererseits waren japanische Unternehmen Auftraggeber für Animationsarbeit in anderen Staaten und schließlich sind bei der Lokalisierung Vertrieb und Vermarktung ausländischer Produktionen japanische Firmen beteiligt
+All die damit in Verbindung stehenden Werke können daher auch als Teil der japanischen Animationsfilmindustrie beziehungsweise von dessen Geschichte begriffen werden
+Und schließlich gehören zu Anime nicht nur die Objekte die hergestellten und verkauften Werke sondern auch die Ereignisse der Vorführung und des Konsums Steven T Brown geht so weit die Bedeutung des Begriffs Anime in der Präsentation und Anordnung der Informationen bei der Vorführung und in der Interaktion des Rezipienten mit dem Werk zu suchen
+In der Beschreibung von Anime als Medium wird auch oft darauf hingewiesen wie stark sich der japanische Animationsfilm von dem unterscheidet was westliche Zuschauer von Animationsfilmen - insbesondere amerikanischen Cartoons oder Filmen von Walt Disney - erwarten
+Viele Animes sind nicht für Kinder gemacht manche sogar pornografischer Natur erzählen dramatische oder actionreiche Geschichten und bedienen eine große Vielfalt an Genres
+Im Vergleich zu vielen im Westen erfolgreichen Trickfilmen kommen Musicaleinlagen Tierfiguren und Slapstick-Humor deutlich seltener vor
+Trotz dieser häufig genannten Merkmale beziehungsweise auffälligen Unterschiede werden diese nicht zur Definition herangezogen
+Als Anime um <num> herum in den USA immer größeren Zuspruch fanden zugleich aber Vorurteile gegenüber einem als für Kinder gefährlichen Kulturimports herrschten wurde Anime auch pejorativ verwendet - vor allem von solchen Vertrieben die selbst japanische Animationsfilme importierten und ihre Produkte vor den Vorurteilen schützen wollten
+Historische Entwicklung
+Zu Beginn der <num>er Jahre kamen erste westliche Trickfilme nach Japan
+Die ersten japanischen Nachahmer sind aus dem Jahr <num> bekannt in dem die Pioniere Oten Shimokawa Junichi Kōuchi und Seitarō Kitayama ihre ersten Filme aufführten
+Aus dieser Zeit sind nur sehr wenige Werke erhalten
+Ab den <num>er Jahren nahm die Produktion zu
+Die entstandenen Kurzfilme waren meist Komödien Lehrfilme oder zeigten japanische und chinesische Mythen
+In den <num>er Jahren wurden zunehmend Propagandafilme produziert die vor amerikanischem Einfluss warnten und Japans Kriege in China und die Expansion im Pazifik vorbereiteten und begleiteten
+Diesem Ziel diente auch der erste abendfüllende Animefilm
+Momotarō Umi no Shimpei
+Die in schwarz-weiß erzählte Geschichte von Tieren die Pazifikinseln von der britischen Kolonialmacht befreien und ihnen die japanische Kultur bringen kam <num> nicht lange vor der Kapitulation in die Kinos
+Nach Ende des Krieges dauerte es über zehn Jahre ehe <num> mit
+Hakujaden
+wieder ein abendfüllender nun farbiger Anime in die japanischen Kinos kam
+Er war der Beginn einer Reihe von Filmen des Studios Toei Animation die als Klassiker vor der Zeit des Fernseh-Animes gelten und erheblichen Einfluss auf die späteren Produktionen hatten
+Ihre Ästhetik war bereits vom zeitgenössischen Manga beeinflusst und an den Produktionen waren viele beteiligt die später eigene Studios gründeten und dabei ihre ersten Erfahrungen von Toei mitnahmen
+Eine wichtige Figur der Anime-Geschichte ist ähnlich wie beim Manga Osamu Tezuka
+Nachdem er an einem Spielfilm mit Toei Animation gewirkt hatte wollte der bereits erfolgreiche Mangaka die eigenen Serien verfilmen und schuf schließlich <num> mit
+Astro Boy
+die erste Anime-Fernsehserie mit halbstündigen Folgen
+Sein Studio produzierte weitere Serien die auf Tezukas Geschichten basierten darunter den mit amerikanischer Finanzierung entstandenen ersten farbigen Fernsehanime
+Kimba der weiße Löwe
+Ab Ende der <num>er Jahre schuf Tezuka dann anspruchsvollere und experimentellere Filme sowie einige der ersten erotischen Animefilme
+Tezuka war - wie auch bei seinen Mangas - noch stark von den Filmen Walt Disneys und deren Ästhetik beeinflusst
+Seine eigenen Werke hatten wiederum großen Einfluss auf die ihm nachfolgenden Filmschaffenden entweder in Anlehnung oder Abgrenzung seiner Stile und Arbeitsweisen In den späten <num>er und den <num>er Jahren entstanden vor allem Science-Fiction-Serien und mit ihnen wuchs die erste Generation an Fans auf die ab den <num>er Jahren selbst als Produzenten in der Anime-Industrie aktiv wurde Ebenso ab Ende der <num>er Jahre entstanden im bisher männlich dominierten Medium die ersten Serien die sich an Mädchen richteten
+Ribon no Kishi
+<num> von Tezuka und
+Mila Superstar
+<num> zählten zu den ersten mit denen der Entstehung des Shōjo-Mangas auch dessen Adaptionen als Anime folgten
+Diese Serien brachten neuen Themen in das Medium insbesondere Emanzipation Selbstfindung und Liebesgeschichten
+In diesem Umfeld entstanden neue Genre In den <num>ern die von sich magisch verwandelnden Mädchen erzählenden Magical-Girl-Serien in den <num>ern kamen Geschichten über homoerotische Beziehungen zunehmend aus dem Manga auch in den Anime und generell fanden ästhetische Prinzipien aus Serien für Mädchen stärkere Verbreitung darunter die Darstellung schöner Jungen als Bishōnen
+Seit den <num>er Jahren kamen Animes ins europäische und amerikanische Kino zunächst vor allem Kinderserien die auch in Koproduktion mit westlichen Sendern und Studios entstanden
+Gegenüber erwachseneren actionhaltigen Stoffen bestanden große Vorbehalte In den Videotheken wurden zunächst vor allem pornografische und erotische Titel vertrieben was Anime generell einen entsprechenden Ruf gab Das änderte sich ab Ende der <num>er unter anderem mit dem Erfolg des Science-Fiction-Films
+Akira
+im Kino in den <num>ern dann mit den Filmen des Studio Ghibli und mit international erfolgreichen Fernsehserien wie
+Sailor Moon
+und
+Dragon Ball
+sodass das Medium um das Jahr <num> herum international seinen Durchbruch erlebte und eine große Fangemeinde gewinnen konnte
+Inhalte Genres und Zielgruppen
+Animes decken ein breitgefächertes Themenspektrum für alle Altersstufen ab
+Geschichten sind oft komplexer und vielschichtiger als bei vielen westlichen Trickfilmproduktionen üblich
+Es findet mehr Charakterentwicklung statt und auch der Tod wichtiger Charaktere kann vorkommen
+Auch wenn grundsätzlich alle möglichen Themen auftreten können so sind doch besonders solche mit Bezug zum japanischen Alltag oder der japanischen Kultur verbreitet
+Die kann zum einen Sport und Kunst Probleme des Alltags und dessen Regeln oder des Lebens im modernen technisierten und in den Metropolen dicht besiedelten Landes sein zum anderen traditionelle Künste Themen des Buddhismus und Shinto und der japanischen Geschichte und Mythologie
+Diese Themen werden nicht selten gemischt mit Science-Fiction- und Fantasy-Elementen und die meisten Werke lassen sich nicht klar einem einzigen Genre zuordnen Auch gibt es seit den <num>er Jahren auch immer wieder Werke die die Fanszene selbst in den Fokus nehmen und sich wiederum vor allem an diese als Zielgruppe wenden
+Antagonisten sind häufig differenziert und verfügen über eine Hintergrundgeschichte die ihre Handlungen erklärt
+Klischees über typische Bösewichte werden gebrochen und beispielsweise gerade die Gegenspieler als besonders schön dargestellt
+Von Literaturverfilmungen z B
+Das Tagebuch der Anne Frank
+oder
+Heidi
+über Horror bis zu Romanzen werden nahezu alle Bereiche und Altersklassen abgedeckt
+Auch gibt es Genres die ausschließlich in Anime und Mangas vorkommen oder in diesen Medien entstanden sind so zum Beispiel Mecha-Serien über überdimensional große meist von Menschen gesteuerte Roboter
+Pornographische Animes sogenannte Hentai machen nur einen kleinen Teil des japanischen Kaufvideo-Marktes aus im Fernsehen und im Kino werden diese in Japan überhaupt nicht gezeigt
+Viele Animes beinhalten jedoch erotische Elemente ohne dem Hentai-Genre zugeordnet werden zu können insbesondere die des Genres Etchi
+Solche sowie Serien mit hohem Anteil von Gewalt oder anspruchsvollen Inhalten laufen im japanischen Fernsehen im Nachtprogramm und finanzieren sich in der Regel nicht durch die Ausstrahlung sondern durch die mit Fernsehausstrahlung beworbenen DVD-Verkäufe
+Erotische Geschichten und der relativ freizügige Umgang mit Sexualität in der Populärkultur haben in Japan eine lange Tradition so gab es in der Edo-Zeit viele solche Ukiyo-e Shunga genannt
+n Hentai als auch in Etchi-Manga sind wie in der japanischen Erotik allgemein üblich Sexszenen oft in eine humoristische oder parodistische Erzählung eingebettet
+Erotik ist in Japan stark geprägt von der unter der amerikanischen Besatzung entstandenen Gesetzgebung die die Darstellung des erwachsenen Genitalbereichs und andere anstößige Inhalte unter Strafe stellte
+<num> des jap Strafgesetzbuchs
+Dies wurde von vielen Künstlern umgangen indem die Figuren und ihre Genitalien kindlich gezeigt wurden
+Zusammen mit der Kawaii-Ästhetik beförderte das die Entstehung vieler erotischer und pornografischer Geschichten mit kindlichen Figuren und die Etablierung der Genres Lolicon und Shotacon
+Auch wenn die Auslegung der Gesetze gelockert wurde blieb diese Strömung erhalten
+Andere Wege die Zensurgesetzgebung zu umgehen sind die Verwendung von Balken oder Verpixelung Auslassungen oder stark reduzierte symbolhafte Darstellung von Geschlechtsorganen
+International waren erotische Anime zeitweise kommerziell deutlich erfolgreicher und verbreiteter als andere Genres was zur Legende führte alle Anime seien pornografisch
+Dieser Eindruck ist jedoch auch Ergebnis der Stereotype des westlichen Publikums und wirkte vermutlich auch auf die japanischen Produktionen zurück die wiederum an amerikanischen Filmen orientierend den Frauen größere Brüste und den Männern mehr Muskeln gaben
+Nacktheit kann darüber hinaus auch jenseits sexueller Szenen vorkommen in Alltags- oder Kinderserien da es in solchen Situationen in Japan nicht als anstößig gilt
+Während sich Fernsehproduktionen häufiger an Kinder richten ist die Zielgruppe des Videomarktes ältere Jugendliche und Erwachsene
+Anime- und Manga-spezifische Genre
+Etchi Abgeleitet von der Aussprache des englischen Buchstabens H für Hentai Japanisch für unanständige Sexualität
+Diese Anime enthalten nach der westlichen und insbesondere der deutschen Definition nur leicht sexuelle Andeutungen
+In Japan sind Etchi und Hentai das Gleiche was sich vor allem durch die Wortbildung selbst erklären lässt
+Gourmet Geschichten über Kochen und Essen in denen vor allem Gourmets Restaurantkritiker oder Köche im Mittelpunkt stehen
+Harem Lose definiertes Genre in dem der Protagonist der Handlung von mehreren oder gar einer Vielzahl weiterer Charaktere anderen Geschlechts umgeben ist die sich zu ihm hingezogen fühlen
+Hentai japanisch für abnormal oder pervers
+Dieser Begriff wird hauptsächlich von westlichen Zusehern für Anime mit pornographischen oder erotischen Inhalten genutzt
+In Japan jedoch sind die Begriffe Poruno oder Ero gebräuchlich um auf solches Material hinzuweisen
+Isekai bedeutet soviel wie andere Welt
+Hierbei gelangen ein oder mehrere Charaktere aus verschiedensten Gründen aus der realen Welt in eine andere
+Diese kann beispielsweise ein Videospiel oder eine Fantasiewelt sein
+Josei ist das weibliche Gegenstück zu Seinen
+Behandelt oft den Alltag oder auch das Berufs- und Liebesleben von jungen Frauen
+Kodomo jap für Kind Produktionen für jüngere Kinder
+Magical GirlMahō Shōjo jap für magisches Mädchen Geschichten über Mädchen die sich in magische Kriegerinnen verwandeln können
+Mah-Jongg Geschichten um das Spiel Mah-Jongg
+Mecha Anime und Manga in denen riesige Roboter vorkommen
+Seinen jap für junger Mann Primäre Zielgruppe sind Männer im Alter von <num> bis <num> Jahren
+Es werden meist anspruchsvollere erotischere oder gewalthaltigere Inhalte thematisiert
+SentaiSuper Sentai jap für Kampfteam Bezieht sich auf jede Sendung mit einem Team aus Superhelden
+Shōjo jap für Mädchen Sendungen für weibliche Jugendliche oft auch Liebesgeschichten
+Shōnen jap für Junge Produktionen für männliche Jugendliche oft auch den Genres Action Science-Fiction und Fantasy zuzuordnen
+Shōnen Ai jap für Jungen-Liebe Bezeichnung für Manga und Anime deren Thema die Liebe und Romantik zwischen männlichen Charakteren ist
+Diese Bezeichnung ist in Japan wegen der Andeutungen auf Pädophilie nicht gebräuchlich und wurde daher durch den Begriff Boys Love oder ähnliche ersetzt
+Sport Geschichten in denen eine Sportart im Mittelpunkt steht
+Üblicherweise wird die Entwicklung eines Sportlers von den Anfängen bis zur professionellen Karriere verfolgt
+Yaoi wie Shōnen Ai hat aber meist auch eine sexuelle Beziehung zum Thema
+Zielgruppe sind Frauen
+Yuri bezieht sich auf Anime und Manga die Liebe und Romantik zwischen weiblichen Charakteren zum Inhalt haben
+Produktion und Arbeitsbedingungen
+Traditionell entstehen Animes wie auch Trickfilme in anderen Ländern in Cel-Animation
+Die bemalten Folien Cel werden vor einen Hintergrund gelegt und einzeln abgelichtet
+Die Zahl der produzierten Folien und Einzelbilder pro Sekunde hängt von Budget und der beabsichtigten Qualität beziehungsweise Realismus der Bewegung ab
+Tendenziell sind Kinofilme aufwändiger und höherwertiger mit mehr Cels für die gleiche Zeit produziert als Fernsehserien
+Auch Produktionen direkt für den Videomarkt haben in der Regel eine höhere Qualität als für das Fernsehen
+Cel-Animation wurde seit den <num>er Jahren zunehmend von Computeranimationen verdrängt Seit den Fernsehserien ab Beginn der <num>er Jahre - für manche aus diesem Grund die eigentliche Geburt von Anime - herrscht Limited Animation als Animationsprinzip vor
+Bei den Produktionen von Kinofilmen in den Jahren zuvor wurde noch nach dem Vorbild Disneys Full Animation angestrebt das heißt möglichst realistische Darstellung und bestmögliche Illusion der Bewegung wobei eine größere Zahl von Bildern pro Sekunde und entsprechender Aufwand eingesetzt wird
+<num> unterschiedliche Bilder pro Sekunde sind dafür üblich <num> in der Spitze
+Dieser Ansatz ist unüblich geworden nur Kinoproduktionen insbesondere von Studio Ghibli verfolgen diesen noch und wurde weitgehend durch Limited Animation abgelöst
+Diese kommt mit nur durchschnittlich <num> Bildern pro Sekunde aus
+Der Eindruck von Bewegung wird nicht nur durch unterschiedliche Bilder sondern auch Arrangement der Bilder und Schnitte erzeugt
+So kann der Eindruck von Bewegung anstatt durch verschiedene Bilder durch das Verschieben von Vorder- und Hintergrund gegeneinander erzeugt werden
+In Actionszenen wechseln eher Standbilder in ausdrucksstarken Posen in schnellen Schnitten als dass Bewegungen tatsächlich gezeigt werden Raumtiefe kann durch das Übereinanderlegen der Folien und deren Überschneidung zumindest angedeutet werden Bildfolien werden häufig wiederverwertet
+Zu diesem Zweck verwenden Studios Folienbibliotheken der einzelnen Figuren in unterschiedlichen Positionen und Bewegungen die erneut eingesetzt werden können
+Die deutliche Kostenersparnis dabei war zunächst einer der wichtigsten Gründe dafür
+Osamu Tezuka hat seine ersten Folgen für nur <num> Yen jeweils verkauft
+Doch auch als ab den <num>er Jahren die Studios langsam mehr Geld zur Verfügung hatten wurde von diesem Prinzip nicht abgewichen
+Stattdessen wurden wie schon von Beginn an von Tezuka dessen künstlerische Möglichkeiten erkundet oder zusätzlicher Aufwand in Hintergründe und Designs investiert
+Als in den <num>er Jahren erstmals Computeranimationen eingesetzt wurden gehörte die japanische Filmwirtschaft zu den ersten Anwendern
+Seitdem wurde immer wieder mit <num>D-Animation experimentiert
+Anders als in den USA konnte die Computeranimation aber nicht die traditionelle <num>D-Ästhetik ablösen reine <num>D-Animationsfilme aus blieben eine Seltenheit
+Stattdessen werden Animationen als Effekte in Szenen klassischer Animation eingesetzt beispielsweise Lichteffekte und am Computer animierte Bildelemente werden in einer Weise gerendert die sie wie handgezeichnet erscheinen lässt
+Besonders letzteres ist seit Ende der <num>er Jahre durch neue Software einfacher umsetzbar geworden und wurde daher zunehmend in Bildelementen eingesetzt die mit der Hand gezeichnet zu aufwändig oder nur schwer zufriedenstellend umzusetzen sind
+Insbesondere die Charaktere aber bleiben handgezeichnet und die Ästhetik der traditionellen Cel-Animation wird beibehalten
+Zugleich bringt der Einsatz von Computern neue Möglichkeiten für die Einbindung von Fotografien und Rotoskopie
+Die Herstellung findet nicht nur in Japan statt sondern aus Kostengründen auch in anderen asiatischen Ländern Amerika und Europa
+Die wichtigsten Nachunternehmer sitzen in Korea China und Thailand
+Ausgelagert werden vor allem die Herstellung von Zwischenphasenbildern und die Koloration
+Die Entwicklung von Drehbüchern und Storyboards Designs und Schlüsselbildern bleibt in der Regel in Japan
+Wichtigste Einnahmequelle der Studios waren in den <num>er Jahren an erster Stelle das Merchandising danach Senderechte und in deutlich geringerem Umfang Kinoeinnahmen und Werbefilme
+Hauptabnehmer ist das Fernsehen gefolgt vom Kino und dem Videomarkt an letzter Stelle
+Fur eine einzelne Folge werden etwa <num> Millionen Yen in früheren Zeiten eher <num> Millionen und anderthalb Monaten Produktionszeit aufgewendet
+In den <num>er Jahren wurden jedes Jahr <num> bis <num> Fernsehserien und <num> bis <num> Kinofilme produziert
+Laut einer im Jahr <num> durchgeführten Studie arbeiten japanische Anime-Zeichner im Durchschnitt <num> bis <num> Stunden pro Arbeitstag bzw <num> Stunden pro Monat bzw <num> freie TageMonat
+Animatoren verdienen pro Jahr durchschnittlich Mittelwert <num> Millionen Yen ca <num>
+bzw am häufigsten Modalwert <num> Mio Yen <num>
+angefangen bei Einstiegspositionen wie Zwischenzeichnern mit <num> Mio Yen <num>
+über Schlüsselzeichner mit <num> Mio Yen <num>
+und Storyboarder<num>D-Animatoren mit <num> Mio Yen <num>
+bis zu Regisseuren mit <num> Mio Yen <num>
+Zeichner werden häufig nach einem Schema bezahlt bei dem sie zusätzlich zu einem festen Lohn noch nach fertiggestellten Einzelbildern bzw -szenen bezahlt werden
+Bildsprache
+DateiMahurijpg DateiVergleich zwischen Manga und Fotojpg
+Die häufig anzutreffenden Stile Bildsprache und Symbolik von Animes sind zum einen geprägt durch die lange Zeit übliche Produktion als Cel-Animation zum anderen durch Einflüsse von Mangas und insbesondere in der frühen Zeit aus dem amerikanischen und französischen Film
+Ähnlich wie im Manga sind die handelnden Figuren einfach und stilisiert gehalten während die Hintergründe detaillierter und realistischer gezeichnet sind
+Auf diese Weise wird sowohl die Identifikation mit den Charakteren erleichtert als auch das Eintauchen in die Welt der Geschichte Der Detailreichtum der Hintergrundbilder kann insbesondere in Kinoproduktionen ein großes Ausmaß erreichen und bildet einen entsprechenden Kontrast zu den Charakteren im Vordergrund Das Charakterdesign ist stark vom Manga beeinflusst und entspricht beispielsweise oft dem Niedlichkeitskonzept Kawaii
+Bei älteren Charakteren oder Werken für erwachseneres Publikum kommt auch das reifere nicht niedliche Designprinzip kirei vor
+Darüber hinaus finden japanische Idealvorstellung von schönen Frauen und Männern Bishōjo und Bishōnen Anwendung und in der Charakterentwicklung werden Archetypen Stereotype und Klischees verwendet von denen sich manche von denen anderer Kulturkreise unterscheiden
+Daneben ist - im Unterschied zum westlichen Animationsfilm - nicht die realistische Bewegung Ziel der Animation sondern der Übergang zwischen ausdrucksstarken Posen
+Dies lässt sich sowohl auf Kostenzwänge in der Produktion in der stehende Bilder günstiger sind als auch auf eine japanische ästhetische Tradition zurückführen die sich beispielsweise auch im Kabuki-Theater zeigt in dem Posen ebenfalls eine wichtige Rolle einnehmen Die einfach gehaltene günstigere Animationstechniken der sogenannten Limited Animation prägten den Anime
+Erzählerisch können durch die zurückhaltende Animation der Geschichte und den Charakteren größeres Gewicht gegeben werden als Bewegung Action und visuellem Humor Limited Animation geht mit einer sich von Full Animation unterscheidenden Ästhetik einher Neben der Betonung von Posen der Figuren auch eine große Bedeutung von Rhythmus bei Einsatz und Wiederverwendung der Einzelbilder und Schnitten
+Durch die Posen fällt dem vor der Animation stattfindende Charakterdesign ein größeres Gewicht zu als bei der auf Bewegung fokussierten Full Animation
+Diese Hinwendung zu den beziehungsweise Betonung von einzelnen Charakteren dient zugleich dem multimedialen Einsatz der Figuren die sich leichter aus ihrer Serie herauslösen und in anderen Kontexten verwenden und vermarkten lassen
+Während die Techniken der Limited Animation für manche nicht als richtige Animation gelten sind sie für andere eine modernere weiterentwickelte Animation die sich von der Nachempfindung des Realfilms gelöst hat und in der sich sowohl kommerzielle Massenwerke als auch experimentelle Kunst realisieren und manchmal kaum noch unterscheiden lassen
+Thomas Lamarre nennt einige Einsätze dieser Techniken wie sie beispielsweise bei Gainax geschehen wegen ihrer besonderen Ästhetik und dem ausgefeilten Einsatz von Schnitt und Rhythmus sogar Full Limited Animation Hiroki Azuma macht die Folienbibliotheken der Studios als eine frühe Form von Datenbanken zu einem wichtigen Element seiner Analyse der Anime-Fankultur und deren Verhältnis zu Technik und Information Die im Anime übliche flächenhafte Ästhetik die durch stilisierte Figuren und die Techniken der Cel-Animation mit ihrer Arbeit in Schichten entsteht wird mit dem Begriff Superflat in Verbindung mit einem größeren Trend in der japanischen Kunst und Populärkultur gebracht der von Holzschnitt bis zu Computerspielen und Manga reicht
+Über die international bekannte Ästhetik von Anime hinaus gibt es auch viele Werke die diesen Vorstellungen nicht entsprechen
+Dazu können schon ältere Anime-Klassiker zählen die nicht mehr heutigen Stilen ähneln aber auch Puppentrickfilme von Kihashiro Kawamoto oder Animation mit Silhouetten und Schattenrissen
+Besonders im Animationsfilm bis zum Zweiten Weltkrieg sind die Einflüsse des japanischen Theaters und Kunst in der Vorliebe zu flächiger Bildgestaltung und für Choreografie deutlich zu erkennen
+Anime in Japan
+Anime sind ein fester Bestandteil des japanischen Kulturgutes
+Zu den erfolgreichsten Kinofilmen in Japan zählen viele Animes so
+Prinzessin Mononoke
+Pokémon Der Film
+und
+Chihiros Reise ins Zauberland
+Nach einer Umfrage sind die <num> beliebtesten Zeichentrickserien in Japan alle Anime mit Ausnahme von
+Tom und Jerry
+Veröffentlichungsarten
+Neben Fernsehserien und Kinofilmen werden Animes seit den frühen <num>er Jahren als Original Video Animation kurz OVA für den Kaufvideo- und DVD-Markt produziert
+Die Zielgruppe sind meist junge Erwachsene daher sind die Inhalte in der Regel mit viel Fanservice versehen
+Diese wurden aber weitestgehend durch Mitternachtsanime ersetzt
+Seit <num> gibt es auch Serien direkt für das Internet Original Net Animation ONA genannt
+Fernsehen
+Anime-Fernsehserien haben für gewöhnlich <num>-<num> <num>-<num> sowie seltener <num> oder mehr Folgen so dass bei wöchentlicher Ausstrahlung eine Laufzeit von einem viertel halben oder ganzen Jahr erreicht wird
+Ein solches Vierteljahresintervall wird als cours
+kūru bezeichnet
+Die cours sind dabei saisonal d h es gibt Winter- Frühlings- Sommer- und Herbst-Cours die im Januar April Juli bzw Oktober beginnen
+Die meisten Anime-Serien sind nicht als Endlosserien ausgelegt obwohl insbesondere Verfilmungen langer Manga-Serien auf weit mehr als <num> Folgen kommen können
+Im Jahr <num> wurden sieben Serien gesendet dies wird generell als der Beginn von Anime-TV-Serien angesehen
+<num> wurde die <num>er-Grenze mit <num> Serien gebrochen
+<num> wurde die <num>er-Grenze mit <num> Serien erreicht
+Mit <num> Serien wurde die <num>er-Grenze im Jahr <num> erreicht
+Seitdem hat sich die Anzahl der Serien mehr oder weniger etabliert jedoch gab es Jahre wie <num> und <num> in denen die <num>er-Grenze erreicht wurde
+Der Anstieg der Anime-Anzahl in den <num>ern ist darauf zurückzuführen dass seit <num> die Mitternachtsprogrammplätze für Anime verwendet werden aber auch darauf dass durch den großen Erfolg und die Kontroverse von
+Neon Genesis Evangelion
+immer mehr Studios Videounternehmen und Verlage Werke produzieren ließen Diese schließen sich dann oft mit Merchandising-Partnern zu Produktionskomitees
+seisaku iinkai zusammen und kaufen einen Mitternachtsprogrammplatz - daher auch als Mitternachtsanimes
+shinya anime bezeichnet - bei mehreren Sendern üblicherweise für ein bis zwei cours
+Der größte Teil dieser Programmierungen geschieht auf Regionalsendern die keinem der großen Networks angeschlossen sind
+Da diese auf UHF-Band ausstrahlen werden derartige Anime auch UHF-Anime UHF genannt
+Mitternachtsanimes erreichen durchschnittliche Einschaltquoten von etwa <num>
+während <num> bis <num>
+schon außergewöhnlich hoch sind
+Einschaltquoten spielen bei Mitternachtsanimes und damit den meisten Animes seit den späten <num>ern kaum eine Rolle sondern die Ausstrahlung dient der Werbung für die DVD- oder Blu-ray-Veröffentlichungen mit denen und den Merchandise-Artikeln der Gewinn gemacht wird
+Abhängig von deren Verkaufszahlen entscheidet sich dann ob weitere Staffeln produziert werden
+Viele der Anime die ein bestehendes Werk adaptieren dienen letztendlich aber auch der Bewerbung der Vorlage so dass für das auftraggebende Produktionsunternehmen auch die Animeverkäufe zweitrangig sein können sofern die Vorlagenverkäufe anziehen was sich daran äußert dass teilweise auch nur wenig erfolgreiche Anime Fortsetzungen bekommen können
+Anders sieht dies bei am Tage ausgestrahlten Animes aus die meist langläufig sind über zwei cours und sich zudem auch entweder an ein junges oder ein Familienpublikum richten
+Seit der Einführung der Mitternachtsanime hat sich die Anzahl der Serien mit hohen Einschaltquoten verringert und auch die Art der Serien im Tagesprogramm hat sich verändert
+Anime mit den höchsten Einschaltquoten
+Anime mit den höchsten Heimvideoverkäufen
+Durch die sich erholende Wirtschaft während der <num>er Jahre die starke Berichterstattung über die steigende Beliebtheit von Animes im Ausland und den Moe-Boom investierten aber auch branchenfremde Unternehmen wie Finanz- und neue IT-Unternehmen in diesen früheren Nischenmarkt
+Der Rückgang seit <num> wird auf die sinkenden Geburtenraten und die wirtschaftliche Rezession zurückgeführt
+Japanische Fernsehsender gehen aber auch dazu über den ausländischen Markt direkt zu beliefern
+In den USA wird der Rückgang der Marktgröße für Animes von <num> Mrd
+Dollar im Jahr <num> auf <num> Mrd
+Dollar für <num> hauptsächlich mit der Fansubbing-Szene in Zusammenhang gesetzt die Serien bereits kurz nach deren Erstausstrahlung im japanischen Fernsehen untertitelt über Filesharing verbreitet
+Im Januar <num> begann TV Tokyo als erster größerer Fernsehsender seine Animes nur Stunden nach deren Ausstrahlung im japanischen Fernsehen englisch untertitelt auf einer abopflichtigen Website zu veröffentlichen Heute wird ein großer Teil der Neuerscheinungen gleichzeitig zur japanischen Ausstrahlung Simulcast auf Websites mit englischen Funimation und Crunchyroll aber auch deutschen Untertiteln gestreamt
+Zusammenspiel mit anderen Medien
+Die Produktion und Veröffentlichung von Animes ist oft eng mit anderen Medien verknüpft
+Viele Animes beruhen auf erfolgreichen Mangas sowie vor allem in jüngerer Zeit auf Light Novels
+Es wird aber auch umgekehrt nach dem Erfolg eines Animes ein entsprechender Manga gezeichnet
+Vergleichsweise selten sind Anime-Comics bei denen der Manga nicht neu gezeichnet sondern aus Einzelbildern des Animes und eingefügten Sprechblasen zusammengesetzt wird
+Oft ist auch die Computerspiel-Industrie an der Anime-Produktion beteiligt die auf Grundlage der Animes Computer- und Konsolenspiele produziert
+Ebenfalls gab es Animes die wie
+Pokémon
+und
+Digimon
+auf erfolgreichen Spielen basieren Auch eine parallele Entwicklung oder der Beginn der Animeproduktion noch vor Start eines Spiels kommen vor
+Dabei ist jedoch oft eines der Werke das Zugpferd an dessen Popularität sich die Adaption hängt
+Die Zweitverwertungen werden dann vor allem von Fans und Sammlern gekauft wird die weitere Einsätze ihrer Lieblingscharaktere oder -welt erleben wollen
+Unabhängig solcher Franchise- und Lizenzprodukte beeinflussten Anime und Computerspiele sich in ihren Darstellungsformen und Erzähltechniken gegenseitig
+Insbesondere die Ästhetik von Manga und Anime hat den Stil von japanischen Computerspielen geprägt vor allem was das Charakterdesign betrifft
+Bereits frühe japanische Computerspiele orientierten sich in der Darstellung ihrer Figuren an Manga und Anime
+und Techniken wie Cel-Shading das Computeranimationen den Anschein klassischer Animationen gibt oder Prinzipien der Limited Animation werden auch in Spielen eingesetzt
+Die Produktionen werden in der Regel von Produktionskomitees geleitet denen oft Unternehmen unterschiedlicher Branchen angehören so neben Buch- Spieleverlagen Studios auch Lebensmittelfirmen die Kapital einbringen und sich die Rechte am Werk aufteilen
+Durch diese frühe Verknüpfung erscheinen parallel zum Anime auch Manga Romane und weitere Artikel
+Teilweise werden diese Franchises dann gezielt zur Werbung für ein Produkt oder eine Produktgruppe eingesetzt
+Die Zusammenarbeit in Produktionskomitees soll auch gewährleisten dass inhaltliche- und Designelemente über die einzelnen Werke hinaus im Franchise genutzt werden beispielsweise der Einsatz von Charakteren in einem Videospiel bei der Entwicklung für eine Fernsehserie schon mitgedacht wird
+Dabei können jedoch Entwicklung der Geschichte der Figuren und die Darstellung von Konflikten und menschlichen Beziehungen in den Hintergrund treten Diese enge Zusammenarbeit über Komitees hat ab den <num>er Jahren deutlich zugenommen in denen auch der Medienmix an Bedeutung gewonnen hat
+Praktiziert wurde diese Zusammenarbeit aber bereits seit langem so war schon
+Astro Boy
+<num> von Süßwaren- und Spielzeugherstellern mitfinanziert die passendes Merchandising auf den Markt brachten
+Zu den diversen üblichen Merchandising-Artikel von Franchises unter anderem Artbooks Soundtrack-CDs und Klingeltöne nehmen Model-Kits und fertige Figuren eine wichtige Rolle ein
+Diese werden in Japan in großer Zahl für viele Serien verkauft sind außerhalb des Landes jedoch nur schwer erhältlich Zusätzlich zu diesen Musikthemen veröffentlichen die Sprecher eines bestimmten Animes auch CDs für ihren Charakter Image Album genannt
+Trotz dem Wort image beinhalten sie nur Musik undoder Textpassagen in denen der Sprecher zum Hörer spricht oder über sich singt wodurch der Zuhörer glaubt dass der Charakter selbst singt oder redet
+Eine weitere Variante von Anime-CD-Veröffentlichungen sind Drama-CDs Hörspiele in denen die Sprecher eine Geschichte erzählen die häufig im Anime nicht vorkommt
+Wie in Kinofilmen wird im Anime die Musik als wichtiges künstlerisches Mittel benutzt
+Mit Anime-Soundtracks wird in Japan sehr viel Geld gemacht da diese sich häufig ebenso gut verkaufen wie Chartstürmer-Alben
+Aus diesem Grund wird Animemusik häufig von erstklassigen Musikern komponiert und aufgeführt
+Fähige Komponisten für die Hintergrundmusik sind bei den Fans hochangesehen
+Zu den bekannteren Komponisten zählen z B
+Joe Hisaishi Yuki Kajiura Yōko Kanno und Kenji Kawai
+Am häufigsten wird Musik in Animes als Thema für einen Charakter genutzt oder um als Hintergrundmusik die Stimmung einer Szene wiederzugeben
+Serien haben ein Vorspannlied als Einleitung
+Dieses Thema passt für gewöhnlich zum Gesamtton der Sendung und dient dazu den Zuschauer für das anschließende Programm zu begeistern
+Zwischen- und Abspannlieder kommentieren oft die Handlung oder die Sendung als Ganzes und dienen häufig dazu eine besonders wichtige Szene hervorzuheben
+Diese Lieder werden häufig von bekannten Musikern oder japanischen Idolen gesungen aber auch von den Synchronsprechern Seiyū die dadurch wiederum zu Idolen werden
+Somit sind sie ein sehr wichtiger Bestandteil des Programms
+Gesellschaft und Politik
+Während Anime genauso wie andere japanische Populärkultur noch bis in die <num>er Jahre von der Politik wenig beachtet und wenn überhaupt nur als Problem wahrgenommen wurde änderte sich dies nach <num>
+Insbesondere durch Außenminister und später Premierminister Tarō Asō selbst Fan von Anime und Manga wurde ab japanische Populärkultur als wichtiger Teil der japanischen Wirtschaft und Kultur begriffen und dessen Export beworben und gefördert
+Mehrere Gesetzesvorhaben stärkten den Urheberschutz und Vertreter der Anime-Industrie wurden in politische Beratungsgremien aufgenommen
+Anime und Manga sollten als Soft Power beziehungsweise im Kontext mit der Idee von Cool Japan ein positives Bild Japans in der Welt vermitteln und wichtiger Teil der Exportwirtschaft sein
+Diesen Initiativen entgegen steht dass Anime wie auch Manga nicht so neu und modern nicht so stilistisch und inhaltlich einheitlich sind wie die politischen Strategien sie bewerben
+Stilmerkmale und Marketingstrategien haben eine weit vor <num> zurückreichende Geschichte und sind oft im Zusammenspiel mit westlichen Einflüssen entstanden sind also weniger originär japanisch als politisch suggeriert wird
+Manche Animeserien werden dafür krititiert nationalistische oder revanchistische Ideen zu transportieren
+Japanischen Animefans wird ein stärkeres Nationalbewusstsein zugeschrieben als anderen Teilen der Gesellschaft
+Zugleich findet im Medium auch Kritik an Politik Gesellschaft und Nationalismus statt viele Werke zielen auf einheimisches Publikum und sind international nicht verständlich und die Szene und deren Vertreter versuchen sich politischer Einvernahme zu entziehen
+Des Weiteren ist fraglich ob die auch in Japan recht kleine Branche die von der Politik in sie gesetzten wirtschaftlichen Hoffnungen erfüllen kann
+Bekannte Anime-Studios
+Eines der international bekanntesten Anime-Studios ist Studio Ghibli das seit <num> unter der Leitung von Hayao Miyazaki Filme produziert z B
+Prinzessin Mononoke
+<num>
+Chihiros Reise ins Zauberland
+<num> oder
+Das wandelnde Schloss
+<num>
+Seinen bisher größten weltweiten Erfolg hatte Studio Ghibli mit Chihiros Reise ins Zauberland
+Der Film erhielt neben zahlreichen internationalen Zuschauer- und Kritikerpreisen im Jahr <num> den Goldenen Bären auf der Berlinale und im Jahr <num> den Oscar als bester Animationsfilm was ihn zum meistausgezeichneten Zeichentrickfilm aller Zeiten macht
+Bei Animeserien ist Tōei Animation bedeutend das bei frühen Science-Fiction-Klassikern wie
+Uchū Senkan Yamato
+auch Space Battleship Yamato und
+Captain Future
+und später bei
+Sailor Moon
+Dragon Ball
+und weiteren Serien beteiligt war die große internationale Verbreitung gefunden haben
+Darüber hinaus produzierte Tōei die bedeutendsten Anime-Filme der <num>er Jahre
+Weitere bekannte Anime-Studios
+A-<num> Pictures
+Fairy Tail
+Sword Art Online
+Bee Train
+El Cazador
+hackSIGN
+Madlax
+Noir
+Tsubasa - Reservoir Chronicle
+Bones
+Eureka Seven
+Fullmetal Alchemist
+Ouran High School Host Club
+Soul Eater
+Wolfs Rain
+GAINAX
+FLCL
+Gurren Lagann
+He Is My Master
+Die Macht des Zaubersteins
+Neon Genesis Evangelion
+JCStaff
+Slayers
+Shakugan no Shana
+To Aru Majutsu no Index
+Zero no Tsukaima
+Kyōto Animation
+Clannad
+Kanon
+K-On
+Lucky Star
+Die Melancholie der Haruhi Suzumiya
+Madhouse
+Black Lagoon
+Chobits
+Death Note
+No Game No Life
+Ninja Scroll
+Summer Wars
+Nippon Animation Serienreihe
+World Masterpiece Theater
+Chibi Maruko Chan
+Production IG
+Blood - The Last Vampire
+Ghost in the Shell
+Higashi no Eden
+Neon Genesis Evangelion The End of Evangelion
+Jin-Roh
+Shaft
+Bakemonogatari
+Puella Magi Madoka Magica
+Magister Negi Magi Negima
+Sayonara Zetsubō Sensei
+Studio Pierrot
+Bleach
+Frau Pfeffertopf
+Naruto
+Saber Rider
+Saiyuki
+Sunrise
+City Hunter
+Code Geass
+Cowboy Bebop
+Inu Yasha
+The Vision of Escaflowne
+TMS Entertainment
+Mila Superstar
+Lupin III
+Lady Oscar
+Detektiv Conan
+Monster Rancher
+WIT Studio
+Attack on Titan
+Seraph of the End
+Kabaneri of the Iron Fortress
+Anime international
+Außerhalb Asiens sind hauptsächlich die USA Frankreich und Italien für die Verbreitung von Anime in Nachbarländern wie Spanien Portugal Arabien Lateinamerika und auch Deutschland verantwortlich Die Veröffentlichung findet sowohl synchronisiert als auch untertitelt statt wobei insbesondere Fans untertitelte Fassungen oft bevorzugen um problematische Übersetzungen zu meiden
+Da viele Animes Bezüge zur japanischen Kultur haben und daher für Zuschauer in anderen Ländern nicht immer leicht zugänglich sind waren außerhalb Asiens zunächst vor allem neutrale Stoffe oder solche basierend auf europäischen oder internationalen Märchen erfolgreich ehe auch stärker japanische Serien ein Publikum finden konnten Diese hatten und haben es teilweise noch immer schwer ihr Publikum zu finden da speziell japanische Stilelemente Bildsprache und Symbole außerhalb Japans für viele nicht verständlich sind
+Außerdem wurden bei vielen Lokalisationen die Dialoge und teilweise auch die Handlung angepasst um sie kindgerechter zu gestalten da Zeichentrick im Westen ausschließlich als Medium für Kinderunterhaltung verstanden wurde
+So wurden sexuelle Anspielungen oder Gewaltdarstellungen durch Dialogänderungen oder Schnitte entfernt oder entschärft bis hin zu sinnentstellenden Änderungen
+Auch die Komplexität einiger Animes wurde durch Kürzungen reduziert oder die Musik durch neue ersetzt um die Werke dem Publikum gefälliger zu machen
+USA
+Anime-Serien sind im Westen erstmals in den Vereinigten Staaten im Fernsehen aufgetaucht
+Dort sind in den <num>er Jahren unter anderem
+Astro Boy
+Kimba der weiße Löwe
+Gigantor
+und
+Speed Racer
+gelaufen
+Danach waren Anime-Serien weniger präsent als es in Europa der Fall war
+Die populärsten Serien waren Serien im Science-Fiction-Bereich wie
+Star Blazer
+Voltron
+und
+Robotech
+In den späten <num>ern ist wie in Deutschland die internationale Vermarktung der Serien
+Sailor Moon
+Pokémon
+und
+Dragon Ball Z
+für die Wahrnehmung von Anime im Speziellen verantwortlich gewesen
+Auch gab es Koproduktionen zwischen den USA und Japan dazu zählen
+Das Letzte Einhorn
+und
+Transformers
+Erfolgreiche Ausstrahlungen von Anime-Serien hatten Einfluss auf die Cartoon-Industrie in den USA selbst
+Serien wie
+Galaxy Rangers
+in den <num>ern sowie
+Avatar - Der Herr der Elemente
+Monsuno und
+Teen Titans
+in den <num>ern waren von der Anime-Ästhetik beeinflusst
+Im US-Fernsehen werden für Anime die im Kinderprogramm laufen die umfangreichsten Bearbeitungsmaßnahmen unternommen
+Diese Fassungen werden dann oft international vermarktet
+Der amerikanische Jugendschutz ist im Vergleich zum europäischen Standard in Deutschland Frankreich etc weitaus strenger In den USA stehen den Unternehmen umfangreiche Mittel zur Verfügung um Bilder zu retuschieren Namen zu ändern Folgen auszulassen zusammenzuschneiden und somit die Handlung zu verändern
+Auch die Musik wurde teilweise verändert
+Freizügige gewalttätige religiöse oder japanisch-kulturelle Inhalte und auch Bezüge zu Alkohol Waffen und Drogen werden entfernt
+Ernsthafte Themen wie der Tod werden umschrieben oder ausgelassen
+Diese Maßnahmen unterscheiden sich von Serie zu Serie und auch von Firma zu Firma
+Die konsequentesten und umfangreichsten Bearbeitungen finden bei <num>Kids
+One Piece
+Yu-Gi-Oh
+Harmony Gold
+Robotech
+Saban Brands
+Digimon
+Glitter Force
+und DiC Sailor Moon statt
+Weitgehend unbearbeitete Serien haben Popularität durch Videokassetten oder durch Nachtprogramme von Sendern wie Cartoon Network oder SyFy gewonnen
+Speziell im Nachtprogrammblock von Cartoon Network sind
+Cowboy Bebop
+und Big O sehr populär geworden
+Space Dandy vom Regisseur von Cowboy Bebop
+Ghost in the Shell Stand Alone Complex
+und eine zweite Staffel von Big O wurde von amerikanischen Geldern mitfinanziert Netflix plant mehrere Serien mitzufinanzieren die dann als Netflix Original beworben werden
+Anime in Deutschland
+Als erster Anime in Deutschland wurde ab dem <num> März <num> der Film
+Der Zauberer und die Banditen
+von Toei Animation aus dem Jahr <num> in den Kinos gezeigt
+Die erste Anime-Serie im deutschen Fernsehen war
+Speed Racer
+von der <num> aber nur einige Folgen gezeigt wurden ehe sie wegen Protesten abgesetzt wurde
+Ähnliches geschah zu Erstausstrahlung von
+Captain Future
+in den <num>er Jahren
+Entsprechend wurden in den <num>er und <num>er Jahren nur kinderfreundliche Serien zum Beispiel des
+Masterpiece Theater
+gezeigt bei denen keine Proteste zu befürchten waren
+Einige davon waren deutsche Koproduktionen wie
+Wickie und die starken Männer Die Biene Maja
+und
+Nils Holgersson
+Die ersten deutschen Kauf-Animes gab es im Jahr <num> auf sogenannten TED-Bildplatten
+In den <num>er Jahren erschienen zahlreiche Animes auf VHS-Kassetten
+Dieser Markt war neben der Zweitverwertung von Kinderserien aus dem Fernsehen geprägt von erotischen Werken die von Trimax herausgebracht wurden Diese Importe führten dazu dass Anime noch bis nach <num> von vielen eng mit pornografischen oder stark gewalthaltigen Werken verknüpft wurden
+Mit Beginn der <num>er Jahre sind im deutschen Kino häufiger Anime-Filme gezeigt worden darunter
+Akira
+<num>
+Ghost in the Shell
+<num> sowie einige Produktionen von Studio Ghibli wie
+Prinzessin Mononoke
+<num> und
+Chihiros Reise ins Zauberland
+<num>
+Mit dem Aufkommen des Privatfernsehens kam auch eine Vielzahl von Anime-Serien ins Fernsehen zunächst über Einkäufe von europäischen Programmpaketem in denen neben westlichen Zeichentrickserien auch vereinzelt Anime enthalten waren
+Mit der Zeit wurden auch Serien für Jugendliche ins Programm genommen und im August <num> erhielten Animes den Programmblock Moon Toon Zone bei RTL <num>
+Dieser Block bestand aus
+Sailor Moon Dragon Ball
+und
+Pokémon
+und wurde mit AnimeRTL<num> ab <num> und PokitoTV im Jahr <num> ausgebaut Durch den Erfolg der RTL-<num>-Ausstrahlungen begann das bewusste Lizenzieren von Anime durch RTL<num> und andere Fernsehsender
+K-Toon MTV VIVA und VOX sendeten Animes für ein älteres Publikum
+Ab <num> ging dieses Angebot von Animes im Fernsehen wieder deutlich zurück
+<num> wurde das Programm bei RTL II vollständig abgesetzt Von <num> bis Juni <num> gab es mit Animax Deutschland ein eigener Pay-TV-Sender für den deutschsprachigen Raum
+Heute senden nur noch ProSieben MAXX seit <num> und Nickelodeon regelmäßig Animes
+Die Nachbearbeitung von Animes geschah im deutschen Fernsehen und Kino lange Zeit in großem Maße und war oft Gegenstand großer Kritik von Fans
+Dabei wurden zahlreiche Schnitte und inhaltliche Änderungen meist mit dem Jugendschutz begründet da Trickserien als Kinderprogramm gelten und für dieses Publikum eingekauft und gezeigt werden
+Das erste deutsche Anime-Label war OVA Films gegründet <num>
+Um <num> kamen immer mehr Label auf den Markt von denen sich jedoch viele nicht halten konnten
+Erst ab <num> traten neue Unternehmen dazu von denen einige seit <num> auch regelmäßige Anime-Festivals veranstalten
+Als erste deutsche Videoplattform startete im September <num> Kazé Deutschland das Video-on-Demand-Portal Anime on Demand Mit der Zeit folgten weitere deutsche wie internationale Angebote die jedoch nicht alle von Dauer waren
+So stellte das zu ProSiebenSat<num> Media gehörende MyVideo sein <num> gestartete Angebot <num> wieder ein Seit <num> bedient das amerikanische Portal Crunchyroll auch den deutschen Markt
+Eine Fanszene entwickelte sich ab den <num>er Jahren in kleinerem Maße
+Mit zunehmender Verbreitung und Popularität von Animes wie auch Mangas nach der Veröffentlichung von
+Akira
+im Westen und umso mehr nach dem Erfolg von Fernsehserien darunter
+Sailor Moon
+und
+Dragon Ball
+entwickelte sich eine größere Fangemeinde
+Diese stützte sich stark auf kommunikation über Chats und Foren es entstanden Fanzines und Veranstaltungen der Szene sowie Treffen auf Buchmessen
+Darüber hinaus gehört Cosplay das Verkleiden als Figur aus einem Manga oder Anime und Fan-Art zu wichtigen Hobbys in der Szene
+Außerdem findet nicht selten eine Auseinandersetzung mit japanischer Kultur und Gesellschaft jenseits von Populärkultur statt Bedeutende Veranstaltungen auf denen sich Fans vorrangig treffen sind Anime- und Manga-Conventions sowie der Japantag die Buchmessen oder Veranstaltungen zum japanischen Film
+Das einzige derzeitige professionelle deutschsprachige Anime-Fachmagazin ist die
+AnimaniA
+die seit September <num> erscheint
+Dazu kommen Jugendmagazine mit eigenen Anime-Bereichen wie Mega Hiro
+Koneko
+und
+Kids Zone
+Mittlerweile eingestellt sind die vom Verein Anime no Tomodachi herausgegebene
+Funime
+sowie die
+MangasZene
+Frankreich
+In Frankreich sind Anime zum ersten Mal mit den Serien
+Choppy und die Prinzessin
+Erstausstrahlung folgte in Deutschland in <num> und Kimba der weiße Löwe vier Jahre vor der Deutschen Ausstrahlung im Jahr <num> aufgetaucht
+Ähnlich wie bei Wickie und die starken Männer und Die Biene Maja gab es französisch-japanische Koproduktionen
+Barbapapa
+Odysseus <num>
+und
+Die geheimnisvollen Städte des Goldes
+Mit der Toei-Produktion
+Grendizer
+auch genannt
+Goldorak
+wurde <num> eine Serie ausgestrahlt die maßgeblich dafür verantwortlich war dass im Kinderprogramm vermehrt auf Anime gesetzt wurde
+Die Serie erreichte hohe Einschaltquoten löste aber auch große Anfeindungen und Proteste gegenüber gewalthaltigen japanischen Produktionen aus
+TF<num> ist der größte Privatsender Frankreichs und setzte im Kinderprogramm stark auf Anime viele Serien waren verantwortlich für die große Fanszene in Frankreich Während RTL<num> insgesamt etwa <num> Serien zeigte waren es auf TF<num> weit über <num> AB Productions hat die Serien jedoch als billiges Kinderprogramm angesehen und diese Massen an Serien dann so im Schnitt und Dialog zusammengestutzt <num> wurde das Programm auf TF<num> nach Protesten und einen Konflikt über Anime der über <num> Jahre anhielt vollständig abgesetzt
+Danach haben sich verschiedene Spartensender gefunden die ein Animeprogramm sendeten während im Kinderprogramm der großen Sender ausschließlich auf sehr kindgerechte Anime gesetzt wurde
+Space Adventure Cobra gilt als der Anime mit dem höchsten Kultstatus in Frankreich Realverfilmungen und Fortsetzungen als Koproduktion sind geplant
+<num> wurde
+Ghost in the Shell <num> Innocence
+bei den Internationalen Filmfestspielen von Cannes <num> nominiert
+Wie in den USA hatten Anime Einfluss auf die heimische Zeichentrickindustrie in Frankreich
+Totally Spies
+und
+Wakfu
+sind ästhetisch an Anime angelehnt
+Italien
+In Italien war die Resonanz auf Anime durchwegs positiv
+Seit Goldorak wurde beinahe jedes Genre und Format von Japan übernommen In Italien wurden die meisten Anime außerhalb Japans im Fernsehen und Kino gezeigt Während in Deutschland in den <num>ern und <num>ern nur knapp <num> Serien gezeigt wurden waren es in Italien bereits über <num>
+Der Grund für diese Massenimporte war dass Italien bereits <num> das Fernsehen privatisierte und daraus eine Vielfalt an Sendern hervorging
+Auch waren Anime die preiswertesten Zeichentrickproduktionen Koproduktionen mit Japan wie
+Calimero
+Z wie Zorro
+und Die Abenteuer des Sherlock Holmes sind entstanden
+Eine Vielzahl der Sendungen die in Kinderprogrammen der großen Sender liefen Rai und Mediaset wurden konsequent bearbeitet
+So hat man Gewalt und freizügige Szenen geschnitten - aber auch Zensur und Veränderungen im Dialog wurden vorgenommen
+Thematiken wie der Tod sexuelle Anspielungen japanische kulturelle Inhalte sowie drastische Bilder und Zustände wurden sehr kindgerecht und abgeflacht aufbereitet
+Durch die Thematik der Serie Detektiv Conan haben sich aber solche Dialogumschreibungen wieder gelegt und diese werden inzwischen auch in anderen Serien nicht mehr verwendet
+In den <num>ern <num>ern und <num>ern sind verschiedene Serien unverändert auf verschiedenen Lokalsendern gelaufen jedoch geriet
+Fist of the North Star
+in starke Kritik weshalb fortan auf diesen kleineren Sendern auf Anime verzichtet wurde
+<num> begann mit MTV Italy die erste Ausstrahlung von Anime explizit für ein älteres Publikum zu einer passenden Sendezeit
+In Italien sind speziell Anime für jüngere Mädchen beliebter als in vielen anderen Ländern speziell
+Rock n Roll Kids
+ist für vier Staffeln als Realserie umgesetzt worden
+Der mitunter populärste Anime ist
+Lupin III
+Italien war Mitfinanzierer einer neuen Serie des Franchises
+Lupin Sansei
+Spanien
+Verschiedene Animeserien sind in Spanien zunächst auf dem öffentlich-rechtlichen Sender Televisión Español gelaufen jedoch geriet
+Saint Seiya
+in die Kritik und wurde abgesetzt
+Auch Koproduktionen wie
+Um die Welt mit Willy Fog
+DArtagnan und die drei MuskeTiere
+und Roy the Little Cid sind entstanden
+Mit dem Aufkommen des Privatfernsehens im Jahre <num> startete der Sender Telecinco
+Er setzte Saint Seiya fort und importierte fast <num> weitere Animeserien
+Genau wie in Frankreich und Italien hat sich die Wahrnehmung für Anime weit vor Deutschland und den USA entwickelt Jedoch kamen viele dieser Serien in die Kritik aufgrund von Gewaltdarstellungen oder auch wegen freizügigeren Szenen kurze Röcke bei Sailor Moon oder Nacktheit bei Ranma <num><num> und wurden <num> zeitweilig mit Disneycartoons ersetzt
+Die zwei kulturell bedeutendsten Anime in Spanien sind
+Mazinger Z
+und
+Shin Chan
+Zu Mazinger Z gibt es eine Statue in der Stadt Tarragona und Shin Chan hatte mitunter eine größere Beliebtheit im Fernsehen als manche Hauptnachrichtensendungen
+Fankultur
+Japanische Animationsfilme haben weltweit eine Fangemeinde die sich in großen Teilen mit der von Mangas überschneidet
+Viele Veranstaltungen widmen sich daher beiden Medien
+Eine Fanszene entwickelte sich zunächst in Japan und ab den <num>er Jahren in kleinerem Maße in den USA und Frankreich
+ie japanische Fanszene entstand ab den <num>er Jahren vor allem im Zusammenhang mit Science-Fiction-Serien und dem SF-Fandom
+Im folgenden Jahrzehnt wurden diese Fans auch in der Anime-Industrie selbst aktiv
+Die Szene emanzipierte sich von der Science-Fiction-Szene und es kam der Begriff Otaku für Anime-Fans auf der bis heute sowohl als Selbstbezeichnung als auch spöttische herabwürdigende Fremdbezeichnung verwendet wird
+Ein wichtiges Porträt dieser Fans war die Kurzserie
+Otaku no Video
+des von Fans gegründeten Studios GainaxM it zunehmender Verbreitung und Popularität von Animes wie auch Mangas nach der Veröffentlichung von
+Akira
+im Westen und umso mehr nach dem Erfolg von Fernsehserien darunter
+Sailor Moon
+und
+Dragon Ball
+entwickelte sich auch in Nordamerika und Europa eine größere Fangemeinde
+Als die deutsche Fanszene um das Jahr <num> herum wuchs war sie noch sehr jung
+Einer Umfrage von Sozioland aus dem Jahr <num> sowie einer Untersuchung des französischen Centre dÉtudes et de Recherches Internationales zufolge waren die meisten zwischen <num> und <num> Jahren alt
+Nur wenige waren über <num> spielten jedoch in der Fanszene eine wichtige Rolle gründeten die ersten Magazine und Veranstaltungen
+<num> bis <num> Prozent der Befragten waren weiblich
+Das Medium lädt wie auch Manga in großem Maße zu eigener Kreativität ein
+In der Fanszene ist die Auseinandersetzung mit den Werken und deren Fortsetzung in Form von Dōjinshi Fan-Manga Fanfiction Fanart oder das Verkleiden als Figur aus einem Anime Cosplay weit verbreitet
+Dieses große Maß an Interaktion zwischen Medium und Fans kann als ein weiteres wichtiges Merkmal von Anime gesehen werden De Anime- und Manga-Fanszene aklnn as in eine breitere Kultur moderner Japan-Mode eingebettet gesehen werden bestehend aus J-Pop und Visual Kei japanischem Essen Mode Karaoke und Computerspielen Bedeutende Veranstaltungen auf denen sich Fans vorrangig treffen sind Anime- und Manga-Conventions
+Diese Conventions bieten Verkaufsstände Workshops Autogrammstunden Konzerte oder Videoabende und Cosplay-Wettbewerbe Eine der weltweit größten Conventions ist die Japan Expo in Frankreich mit über <num> Besuchern
+Darüber hinaus finden viele weitere Veranstaltungen in Europa und Nordamerika statt
+Daneben ist Anime auch bei Veranstaltungen zu Japan Animationsfilm Comic oder Literatur ein Thema so finden sich in Deutschland beim Japantag oder der Frankfurter Buchmesse Veranstaltungen zum japanischen Animationsfilm
+Die Attraktivität des Medium für die Fans so Ralf Vollbrecht liege im deutlichen Unterschied zum westlichen Zeichentrick
+Statt kindlich-kindisch zu sein würde das Körperliche und sexuelle Attraktivität stärker betont und die Geschichten seien auch bei fantastischen Stoffen in ihren Themen nah an den Lebenswelten - insbesondere Entwicklungsthemen werden oft angesprochen - und es gibt ein hohes Identifikationspotenzial für die vor allem junge Zielgruppe und Fangemeinde Auch Alexander Zahlten betont der Reiz vieler Serien gerade für jugendliches Publikum läge in der Thematisierung von Transformation des Selbst und der Begegnung mit Anderen und bringt dies in Zusammenhang mit dem Ende der bipolaren Weltordnung nach dem Ende des Kalten Krieges das eine Verunsicherung und Sorge um das Selbst gebracht habe Gerade für Mädchen biete Anime Geschichten mit besonderem Identifikationmöglichkeiten so Dinah Zank
+Vor allem einige Genres von Animes sprechen in Themenwahl und Design ein weibliches Publikum an und bietet diesem auch Charaktere wie weibliche Kriegerinnen die Stereotype aufbrechen
+Dabei sprechen solche Werke auch männliche Zuschauer an auch weil sie die Flucht in eine andersartige sichere fantasievolle und idealisierte Mädchenwelt bieten
+Siehe auch
+Liste der Anime-Titel
+Liste der Anime-Vertriebe
+Literatur
+Gilles Poitras The Anime Companion Whats Japanese in Japanese Animation Stone Bridge Press ISBN <num>-<num>-<num>-<num> englisch <num>
+Jonathan Clements Helen McCarthy The Anime Encyclopedia A Guide to Japanese Animation Since <num>
+Stone Bridge Press <num> ISBN <num>-<num>-<num>-<num> englisch
+Patrick Drazen Anime Explosion
+- The What
+Why
+Wow
+of Japanese Animation
+Stone Bridge Press ISBN <num>-<num>-<num>-<num> englisch <num>
+Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg <num> ga-netchû
+Das Manga Anime Syndrom
+Henschel Verlag ISBN <num>-<num>-<num>-<num>-<num>
+Jonathan Clements Anime - A History
+Palgrave Macmillan <num> ISBN <num>-<num>-<num>-<num>-<num>
+Weblinks
+Datenbanken Aniki - Größtes Wiki zum Thema Anime und Manga AIDB - Anime-Informationsdatenbank mit Releaselisten Episodenlisten und Fernsehplaner
+aniSearch - Größte deutsche Anime-Informationsdatenbank mit umfangreichen Informationen
+Anime News Network englisch
+Teil <num> einer <num>-teiligen Reihe über ihren Einfluss auf den Westen Themen Bildsprache von Rüdiger Suchsland auf Telepolis
+Einzelnachweise
+Jonathan Clements Anime - A History Palgrave Macmillan <num> S <num> ISBN <num>-<num>-<num>-<num>-<num> Darin Verweis auf Ōtsuka Yasuo Sakuga Asemamire Tokuma Shoten <num> S <num> Und Tsugata Nobuyuki Nihon Hatsu no Animation Sakka Kitayama Seitarō Rinsen Shoten <num> S <num> Alexander Zahlten Something for Everyone - Anime und Politik in ga-netchû Das Manga Anime Syndrom S <num> Henschel Verlag <num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime sowie Bernd Dolle-Weinkauff Fandom Fanart Fanzine - Rezeption in Deutschland In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num> Fred Patten Whats Wrong with Japanese Animation In Watching Anime Reading Manga - <num> Years of Essays and Reviews Stone Bridge Press <num> S <num> Fred Patten Anime Versus Japanimation In Watching Anime Reading Manga - <num> Years of Essays and Reviews Stone Bridge Press <num> S <num>fClements <num> S <num>f <num>-<num> Susan J Napier Anime from Akira to Princess Mononoke Experiencing Contemporary Japanese Animation Palgrave <num> S <num>f Fred Patten Letter to the Editor Anime as Pejorative In Watching Anime Reading Manga - <num> Years of Essays and Reviews Stone Bridge Press <num> S <num>-<num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Lawrence Eng The Fans who became Kings - Gainax und die Otaku-Kultur in Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hg ga-netchû Das Manga Anime Syndrom S <num>-<num> Henschel Verlag <num> Dinah Zank Girls only - Japanische Mädchenkultur im Spiegel von Manga und Anime In ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> Das Gute im Bösen - Differnzierung statt Polarisierung In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hg ga-netchû Das Manga Anime Syndrom S <num> Henschel Verlag <num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>f <num>f ISBN <num>-<num>-<num>-<num>-<num> Thomas Lamarre Full Limited Animation in Ga-netchū - Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>f <num>f ISBN <num>-<num>-<num>-<num>-<num> Alexander Zahlten Something for Everyone - Anime und Politik in ga-netchû Das Manga Anime Syndrom S <num>-<num> Henschel Verlag <num> Julia Nieder Südwind aus Fernost - Die Filme des Studio Ghibli In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>f ISBN <num>-<num>-<num>-<num>-<num> Joachim Friedmann Sometimes Good Guys Dont wear White In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Ralf Vollbrecht Anime - Ein Phänomen aus Japan In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Joachim Friedmann Sometimes Good Guys Dont wear White In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num> Daniel Kothenschulte Opulenz und Beschränkung - Stile des frühen Anime sowie Bernd Dolle-Weinkauff Fandom Fanart Fanzine - Rezeption in Deutschland In Deutsches Filminstitut - DIF
+Deutsches Filmmuseum
+Museum für angewandte Kunst Hrsg ga-netchû Das Manga Anime Syndrom Henschel Verlag <num> S <num> <num> ff
+DateiStunt Pyrotechnics Luc Viatourjpg Der Actionfilm von engl action Tat Handlung Bewegung ist ein Filmgenre des Unterhaltungskinos in welchem der Fortgang der äußeren Handlung von zumeist spektakulär inszenierten Kampf- und Gewaltszenen vorangetrieben und illustriert wird
+Es geht eher um stimulierende Aktionen als um inhaltliche Zusammenhänge empathisches Miterleben der Gefühlswelt der Protagonisten oder künstlerisch-ästhetische Bildwelten
+Hauptbestandteile von Actionfilmen sind daher meist aufwendig gedrehte Stunts Nahkampf-Szenen Schießereien Explosionen und Verfolgungsjagden
+Geschichte
+Ursprung
+Der Actionfilm ist seit den <num>er-Jahren ein eigenständiges Filmgenre doch seine Konventionen sind bereits seit dem Beginn der Filmgeschichte bekannt
+Künstler aus dem Vaudeville wie Buster Keaton ließen ihr Können in artistischer Bewegung in Verbindung mit Tricktechnik in ihr Filmschaffen einfließen
+Der Actionfilm als eigenes Genre hat seinen Ursprung im Kriminalfilm in dem in den <num>er-Jahren Aktion und explizite Darstellung von physischer Gewalt zunehmend an Bedeutung gewann etwa in Stanley Kubricks Die Rechnung ging nicht auf
+<num>
+Alfred Hitchcock präsentierte in
+Der unsichtbare Dritte
+<num> erstmals eine geschlossene filmische Welt die ausschließlich als Herausforderung für die physische Aktion der Hauptfigur dient
+Dieses Konzept der geschlossenen Actionwelt die rein zum Ausleben von Körperakrobatik und zur Demonstration spektakulärer Gewaltanwendungstechniken existiert fand seine Fortsetzung in den Filmen der James-Bond-Reihe und in Fernsehserien wie
+Kobra übernehmen Sie
+Dieser von realistischer Darstellung und moralischer Wertung weit entfernten Illusionstendenz stehen die Regisseure der Bewegung des New Hollywood gegenüber die in offener Form Aktion und Gewaltanwendung inszenierten
+Sie reagierten auf gesellschaftliche und politische Entwicklungen wie die Protestbewegung und den Vietnamkrieg und suchten den Kontext der Darstellung zu Fragen der Moral etwa zu den Folgen von Gewaltanwendung auf den menschlichen Körper
+Beispiele für diese realistischere und ernüchternde Herangehensweise sind Arthur Penns Bonnie und Clyde
+<num> und Sam Peckinpahs The Wild Bunch - Sie kannten kein Gesetz
+<num>
+Hochphase <num>-<num>er
+DateiAction film actorsjpeg Mit den Bruce-Lee-Filmen fand eine Ära der Überbetonung physischer Kräfte und des Körperkultes im Actionfilm ihren Anfang
+Stilmittel wie Zeitlupe und Tonverfremdungen führten zur Entwicklung und Definition des Subgenres des Martial-Arts-Films
+In den <num>er Jahren beherrschte der Actionfilm das Mainstreamkino mit Stars wie Arnold Schwarzenegger und Sylvester Stallone die durch Bodybuilding den Körperkult auf einen Höhepunkt führten
+Neben wenigen humorvollen Verfilmungen wie Indiana Jones beherrschten überwiegend reaktionäre Themen wie Rachephantasien und das stereotype Aufbauen von Feindbildern das Actionkino
+In den <num>er Jahren wurde das Genre zunehmend ironisiert und spiegelte sich selbst etwa in Filmen wie
+Last Action Hero
+John McTiernan <num> und
+True Lies
+James Cameron <num>
+McTiernans Stirb-langsam-Reihe <num> bis <num> brach ebenfalls ironisch mit dem Heldenbild des Actionfilms und ließ ihren Protagonisten dargestellt von Bruce Willis entmystifiziert als leidensfähigen Jedermann gegen das Böse siegen
+Stars wie Jackie Chan vereinnahmten den Stunt als Teil der künstlerischen Darstellung und zogen einen Teil ihrer Popularität aus der Tatsache auch gefährliche Action grundsätzlich selbst zu bewerkstelligen
+Mit The Rock - Fels der Entscheidung oder Con Air wurden für das Action-Genre relativ anspruchsvolle Werke geschaffen die sich vom aufkommenden Direct-to-Video-Billigtrend abhoben
+Weiterentwicklung
+Zudem gewannen ab den mittleren <num>ern aufwendige digitale Spezialeffekte und Stunts gegenüber einfachen Kämpfen und Schusswechseln an Bedeutung z B
+in der Mission-Impossible-Reihe mit Tom Cruise oder xXx - Triple X mit Vin Diesel
+Viele Elemente des Actionfilms wurden bereits Ende der <num>er in der mit Krieg der Sterne beginnenden ersten Trilogie von Star Wars und in etwas geringerem Maße auch Star Trek in die Science Fiction übernommen
+Ab <num> wurde der Superheldenfilm erneut populär welcher durch das Batman-Reboot oder Marvels Avengers die mit enormen tricktechnischen und finanziellen Mitteln produziert wurden
+Spätestens in den <num>ern verschwanden klassische Actionfilme als Blockbuster weitgehend aus dem Kino und Fortsetzungen wie Stirb Langsam <num> oder dem nachempfundene Filme wie White House Down waren nur durchschnittlich erfolgreich
+Eine Ausnahme stellt aber z B
+die The Expendables-Trilogie dar die als Ensemble-Filme um die populären Schauspieler Schwarzenegger Stallone Willis Jason Statham Dolph Lundgren und andere als eine Art Hommage inszeniert wurde
+Weibliche Protagonisten
+DateiFemale action hero actressesjpg Weibliche Hauptfiguren waren bis Ende der <num>er Jahre selten eine Ausnahme stellten aber die von Sigourney Weaver verkörperte Ellen Ripley der Alien-Reihe und die von Linda Hamilton verkörperte Sarah Connor in Terminator dar
+Später folgten Brigitte Nielsen Red Sonja Kate Beckinsale Underworld Uma Thurman Kill Bill Michelle Rodriguez SWAT - Die Spezialeinheit oder Halle Berry Catwoman welche meist Seite an Seite mit einem männlichen Filmpartner agierten
+Mit Wonder Woman Gal Gadot oder Rogue One Felicity Jones wurden weitere Heldinnen geschaffen
+Motive und Darstellungsformen
+Die Bewegung Grundmotiv des Films dient im Actionfilm in erster Linie Schauzwecken und hat weniger erzählerische Funktionen
+Oft werden im Actionfilm in der Art einer Nummernrevue geschlossene Sequenzeinheiten aneinandergereiht die der Zurschaustellung unterschiedlichster bewegungsgetriebener Konflikt- oder Duellsituationen dienen etwa Shootouts Verfolgungsjagden Körperkämpfe oder Explosionen
+Subjekte der Aktion sind speziell im US-amerikanischen Actionfilm häufig sich verfolgende Fahrzeuge etwa in
+Brennpunkt Brooklyn
+William Friedkin <num>
+Bullitt
+Peter Yates <num> oder
+Dirty Harry
+Don Siegel <num>
+Der dargestellten Gewalt wird häufig in wirklichkeitsfremder Weise der Realitätsbezug genommen
+Filmische Mittel wie Konvergenzmontage und Parallelmontage strukturieren diese Nummern etwa um einen Spannungsbogen in einer Last-Minute-Rescue aufzulösen
+In den Plots geht es meist um den Kampf zwischen Gut und Böse die Identifikationsfigur ist häufig ein physisch starker männlicher Held oder eine weibliche Heldin siehe beispielsweise
+Lara Croft
+derdie in der Regel eindeutige moralische Prinzipien vertritt die den ethischen und weltanschaulichen Grundlagen der westlichen Kultur entsprechen Gut gegen Böse Beschützen der Schwachen Gerechtigkeit Sühne für erlittenes Unrecht Verteidigung und Bewahrung der vertrauten Lebensweise usw Häufig fließen erzählerische Elemente aus verwandten Genres in den Actionfilm ein unter anderem aus dem Abenteuerfilm dem Kriegsfilm dem Kriminalfilm dem Psychothriller dem Horrorfilm und dem Science-Fiction-Film
+Siehe auch
+Liste von Actionfilmen Opferkamera
+Weblinks
+Schlaffe <num>er Actionhelden in der Krise - Essay <num> Seiten film-zeitde Ines Walk vom <num> Januar <num>
+DateiManglehorn <num> <num>jpg Alfredo James Al Pacino
+<num> April <num> in New York ist ein US-amerikanischer Schauspieler Filmregisseur und -produzent
+Pacino gilt für viele Kritiker und Zuschauer als einer der herausragenden Charakterdarsteller des zeitgenössischen amerikanischen Films und Theaters
+Im Laufe seiner Karriere wurde er unter anderem mit dem Oscar dem Golden Globe Award dem Tony Award und der National Medal of Arts ausgezeichnet
+Eine seiner bekanntesten Rollen ist die des Michael Corleone in der von Francis Ford Coppola inszenierten Filmtrilogie Der Pate
+Leben
+Kindheit und Jugend
+Al Pacino geboren in Manhattan ist der Sohn von Salvatore Pacino geboren in der sizilianischen Stadt Corleone und von Rose Gerard der Tochter eines italienischen Einwanderers und einer italienisch-amerikanischen Mutter die in New York geboren wurde
+Seine Eltern ließen sich scheiden als er zwei Jahre alt war
+Nach der Scheidung zogen Al und seine Mutter in die Bronx und Pacino wuchs bei seinen sizilianischen Großeltern die aus der Heimatstadt seines Vaters eingewandert waren in der New Yorker South Bronx auf
+Sein Vater Salvatore der nach Covina zog arbeitete als Versicherungsagent und besaß ein Restaurant Pacinos Lounge Das Pacinos wurde in wirtschaftlich schweren Zeiten in den frühen <num>er Jahren geschlossen heute trägt es den Namen Citrus Grill Salvatore Pacino starb am <num> Januar <num> im Alter von <num> Jahren
+Al Pacino ist der Stiefsohn der Schauspielerin und Maskenbildnerin Katherin Kovin-Pacino und hat vier Schwestern Josette eine Lehrerin die Zwillinge Roberta und Paula sowie Desiree die sein Vater in seiner vierten Ehe adoptierte
+Mit <num> Jahren wurde Pacino der Schule verwiesen und ging fortan auf die Manhattan School of Performing Arts Nebenher arbeitete er in kleineren Theatern als Platzanweiser und Kartenabreißer
+Schauspielkarriere
+Pacino interessierte sich schon als Kind für die Schauspielerei
+Er verfeinerte sein Talent an zwei renommierten New Yorker Schauspielschulen in Herbert Berghofs HB Studio und später bei Lee Strasberg im The Actors Studio
+Dort spielte er in mehreren erfolgreichen Theaterstücken wie in seinem Debütstück The Connection und in The Indian Wants the Bronx für das er mit einem Obie-Award ausgezeichnet wurde
+Filmschauspieler
+DateiAl Pacino Cannes <num>jpg Pacino wurde durch den späteren Filmproduzenten Martin Bregman bei einem Off-Broadway-Auftritt entdeckt <num> wirkte er in seiner ersten Hollywood-Produktion Ich Natalie mit
+<num> erhielt er neben Kitty Winn eine Rolle in dem Film Panik im Needle Park die ihm den Weg für die Rolle des Michael Corleone in Francis Ford Coppolas Der Pate
+<num> ebnete und ihm <num> seine erste Oscar-Nominierung einbrachte
+Nach
+Hundstage
+wurde es stiller um Pacino
+Erst in den <num>er Jahren brachte er sich durch Filme wie Brian De Palmas Scarface
+<num> und
+Sea of Love - Melodie des Todes
+<num> wieder ins Gespräch
+Nach einer erneuten Zusammenarbeit mit Coppola in
+Der Pate III
+<num> folgte der Thriller
+Heat
+<num> mit Schauspielkollege Robert De Niro
+Die männliche Hauptrolle in dem Film
+Pretty Woman
+lehnte er ab
+Seine Darstellung des AIDS-kranken Schwulenhassers Roy Cohn in der Miniserie
+Engel in Amerika
+<num> brachte ihm zahlreiche Preise ein und wurde von der Kritik hoch gelobt
+Pacino ist dafür bekannt seine Rollen bis zum Extrem auszufüllen
+Während sein Spiel in den <num>er Jahren - insbesondere in der Der Pate - dabei zumeist minimalistisch und zurückhaltend war änderte es sich mit seinem Comeback in den <num>er Jahren radikal Pacinos exaltierte Darstellungen in Filmen wie Scarface Im Auftrag des Teufels An jedem verdammten Sonntag
+oder auch
+Der Duft der Frauen
+wurden von Kritikern oftmals als Overacting bezeichnet
+Für einen Großteil des Publikums zeichnet ihn allerdings genau diese Art und Weise als einen der größten Charakterdarsteller der Gegenwart aus
+Viele seiner Filme darunter auch
+Glengarry Glen Ross der zunächst floppte zählen heute zu den Besten ihres Genres
+Theaterarbeit
+Neben seiner Karriere als Filmschauspieler arbeitet er weiterhin regelmäßig an verschiedenen Theatern - sowohl als Darsteller wie auch als Regisseur und Produzent
+Für seine Rollen in den Bühneninszenierungen von The Basic Training Of Pavlo Hummel von David Rabe und Does A Tiger Wear A Necktie von Don Petersen erhielt er jeweils einen Tony Award
+Als langjähriges Mitglied von David Wheelers Experimental Theatre Company in Boston stand er unter anderem in
+Richard III
+und Bertolt Brechts Der aufhaltsame Aufstieg des Arturo Ui
+auf der Bühne
+In New York und London spielte Pacino in David Mamets American Buffalo in New York war er der Titelheld in
+Richard III
+und spielte den Mark Anton in
+Julius Cäsar
+Außerdem stand er im Square Theatre in New York in Oscar Wildes Salome
+auf der Bühne und wirkte in der Uraufführung von Ira Levins Theaterstück Chinese Coffee mit
+In der Theatersaison <num><num> spielte Pacino in der Shakespeare in the Park-Produktion
+Der Kaufmann von Venedig
+den Shylock
+Mit der Inszenierung gewann Heather Lind die als Shylocks Tochter Jessica auftrat einen Theatre World Award für ein herausragendes Broadway-Debüt
+Eigene Projekte
+Pacinos erstes eigenständiges Projekt war <num> Looking for Richard eine dokumentarische und künstlerische Filmstudie über den Charakter von Shakespeares Richard III bei dem er Regie führte die Produktion übernahm das Drehbuch schrieb und die Hauptrolle spielte
+Pacino war auch Produzent Hauptdarsteller und Koautor des Independent-Kurzfilms The Local Stigmatic einer Verfilmung des gleichnamigen Theaterstücks von Heathcote Williams das sowohl im New Yorker Museum of Modern Art als auch im Public Theatre aufgeführt wurde
+DateiAl Pacino Roma Film Fest croppedjpg
+Auszeichnungen und Ämter
+Al Pacino war insgesamt acht Mal für einen Oscar nominiert
+Seine erste Nominierung erhielt er <num> für seine Rolle des Michael Corleone in Der Pate von Francis Ford Coppola
+Danach folgten Nominierungen für
+und Gerechtigkeit für alle Der Pate - Teil II Hundstage Serpico Dick Tracy
+und
+Glengarry Glen Ross
+<num> wurde er schließlich für seine Rolle als Lt Colonel Frank Slade in
+Der Duft der Frauen
+ausgezeichnet
+Für seine Rolle in dem Film
+Asphalt-Blüten
+erhielt er <num> bei den Filmfestspielen in Cannes die Auszeichnung als bester Darsteller
+Am <num> Juni <num> erhielt er im Kodak Theatre in Los Angeles den AFI Life Achievement Award des American Film Institute für sein Lebenswerk
+Zusammen mit Ellen Burstyn und Harvey Keitel sitzt Pacino im Präsidium des Actors Studio
+Am <num> September <num> erhielt er den Le Coultre Glory to the Filmmaker Award Der Preis ehrt bei den Filmfestspielen von Venedig alljährlich die Arbeit eines bemerkenswerten zeitgenössischen Filmschaffenden
+Am <num> Februar <num> erhielt er die Goldene Kamera für sein Lebenswerk
+<num> wurde er in die American Academy of Arts and Sciences gewählt
+Privatleben
+Al Pacino war nie verheiratet
+Er hat drei Kinder eine Tochter mit Jan Tarrant und Zwillinge Tochter und Sohn
+<num> mit Beverly DAngelo
+Synchronstimme
+Al Pacino wurde im Lauf der Jahrzehnte von verschiedenen deutschen Sprechern synchronisiert
+Nachdem er im ersten Jahrzehnt seiner Karriere in der Regel von Lutz Mackensy gesprochen wurde u a
+Der Pate I und II Serpico Hundstage übernahm mit Scarface <num> Frank Glaubrecht die Synchronisation des Schauspielers
+Seit <num> ist Glaubrecht alleiniger Sprecher Heat City Hall Insomnia etc und er kann mittlerweile als Pacinos Standardstimme bezeichnet werden
+In den frühen <num>er Jahren wurde Pacino auch von Joachim Kammer Dick Tracy Gottfried Kramer Der Pate <num> und Klaus Kindler Carlitos Way gesprochen
+Filmografie
+Darsteller
+<num> Der Einsatz The Recruit
+<num> Liebe mit Risiko - Gigli Gigli
+<num> Engel in Amerika Angels in America Fernsehserie
+<num> Der Kaufmann von Venedig The Merchant of Venice
+<num> Das schnelle Geld Two for the Money
+<num> <num> Minuten <num> Minutes
+<num> Oceans <num> Oceans Thirteen
+<num> Kurzer Prozess - Righteous Kill Righteous Kill
+<num> Salomaybe
+<num> Ein Leben für den Tod You Dont Know Jack
+<num> Ein Cop mit dunkler Vergangenheit - The Son of No One
+<num> Wilde Salome
+<num> Jack und Jill Jack and Jill
+<num> Stand Up Guys
+<num> Der Fall Phil Spector Phil Spector
+<num> Manglehorn
+<num> Der letzte Akt The Humbling
+<num> Mr Collins zweiter Frühling Danny Collins
+<num> Ruf der Macht - Im Sumpf der Korruption Misconduct
+<num> The Pirates of Somalia
+<num> Hangman - The Killing Game Hangman
+<num> Paterno Fernsehfilm
+<num> Once Upon a Time in Hollywood
+Regisseur
+<num> Al Pacinos Looking for Richard Looking for Richard
+<num> Chinese Coffee
+<num> Salomaybe
+<num> Wilde Salome
+<num> Salomé
+Produzent
+<num> The Local Stigmatic Kurzfilm
+<num> Al Pacinos Looking for Richard Looking for Richard
+<num> The Humbling
+Drehbuchautor
+<num> Al Pacinos Looking for Richard Looking for Richard
+<num> Wilde Salome
+Auszeichnungen
+Oscar
+<num> Nominierung als bester Nebendarsteller Der Pate
+<num> Nominierung als bester Hauptdarsteller Serpico
+<num> Nominierung als bester Hauptdarsteller Der Pate - Teil II
+<num> Nominierung als bester Hauptdarsteller Hundstage
+<num> Nominierung als bester Hauptdarsteller und Gerechtigkeit für alle
+<num> Nominierung als bester Nebendarsteller Dick Tracy
+<num> Bester Hauptdarsteller Der Duft der Frauen
+<num> Nominierung als bester Nebendarsteller Glengarry Glen Ross
+Golden Globe Award
+<num> Nominierung bester Hauptdarsteller - Drama Der Pate
+<num> Bester Hauptdarsteller - Drama Serpico
+<num> Nominierung als bester Hauptdarsteller - Drama Der Pate - Teil II
+<num> Nominierung als bester Hauptdarsteller - Drama Hundstage
+<num> Nominierung als bester Hauptdarsteller - Drama Bobby Deerfield
+<num> Nominierung als bester Hauptdarsteller - Drama und Gerechtigkeit für alle
+<num> Nominierung als bester Hauptdarsteller - Komödie oder Musical Daddy
+Daddy
+Fünf Nervensägen und ein Vater
+<num> Nominierung als bester Hauptdarsteller - Drama Scarface
+<num> Nominierung als bester Hauptdarsteller - Drama Sea of Love - Melodie des Todes
+<num> Nominierung als bester Hauptdarsteller - Drama Der Pate - Teil III
+<num> Nominierung als bester Nebendarsteller Dick Tracy
+<num> Bester Hauptdarsteller - Drama Der Duft der Frauen
+<num> Nominierung als bester Nebendarsteller Glengarry Glen Ross
+<num> Cecil B DeMille Award für sein Lebenswerk
+<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Engel in Amerika
+<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Ein Leben für den Tod
+<num> Nominierung als bester Hauptdarsteller - Komödie oder Musical Danny Collins
+British Academy Film Award
+<num> Nominierung als bester Nachwuchsdarsteller Der Pate
+<num> Nominierung als bester Hauptdarsteller Serpico
+<num> Bester Hauptdarsteller Hundstage
+<num> Nominierung als bester Nebendarsteller Dick Tracy National Board of Review
+<num> Bester Nebendarsteller Der Pate
+<num> Bester Hauptdarsteller Serpico Emmy
+<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Engel in Amerika
+<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Ein Leben für den Tod Screen Actors Guild Awards
+<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Engel in Amerika
+<num> Bester Hauptdarsteller - Mini-Serie oder TV-Film Ein Leben für den Tod National Society of Film Critics
+<num> Bester Hauptdarsteller Der Pate American Film Institute
+<num> AFI Life Achievement Award Goldene Himbeere
+<num> Nominierung als schlechtester Darsteller für Revolution
+<num> Nominierung als schlechtester Nebendarsteller für Gigli
+<num> Nominierung als schlechtester Darsteller für <num> Minutes und Righteous Kill
+<num> Schlechtester Nebendarsteller für Jack und Jill
+<num> Schlechtestes Leinwandpaar Adam Sandler und entweder Katie Holmes Al Pacino oder Adam Sandler für Jack und Jill Goldene Kamera
+<num> Auszeichnung Lebenswerk international
+Weblinks
+- Interview mit Bruno Lester in der Frankfurter Rundschau <num> Januar <num> S <num>
+- Würdigung Al Pacinos zum <num> Geburtstag in Spiegel Online <num> April <num>
+Einzelnachweise
+httpswwwnzzchrobert_de_niro_und_al_pacino_langweilen_sich-<num> httpswwwschwarzkopf-verlagnetstorep<num>AL_PACINOhtml httpswwwtv-mediaattop-storysal-pacino-<num>-geburtstag httpswwwmoviepilotdepeopleal-pacino httpwwwwhoswhodebioalfredo-james-pacinohtml urlhttpwwwplaybillcomnewsarticle<num>-Ellen-Barkin-Patina-Miller-John-Larroquette-Jim-Parsons-Tony-Sheldon-and-More-Win-Theatre-World-Awards
+wayback<num>
+textEllen Barkin Patina Miller John Larroquette Jim Parsons Tony Sheldon and More Win Theatre World Awards Playbillcom online englisch abgerufen am <num> Oktober <num> vgl Auszeichnungsliste der Biennale bei labiennaleorg abgerufen am <num> Juni <num> englisch
+DateiAlkohol - Alcoholsvg DateiAlcohol generalsvg Alkohole
+eigentlich feines Antimonpulver sind organische chemische Verbindungen die eine oder mehrere an unterschiedliche aliphatische Kohlenstoffatome gebundene Hydroxygruppen -O-H besitzen Der Unterschied zwischen Alkoholen und anderen Verbindungen mit OH-Gruppen z B
+Enole Halbacetale oder Carbonsäuren als Teil der funktionellen Gruppe ist dass in Alkoholen jedes Kohlenstoffatom das eine OH-Gruppe trägt sp<num>-hybridisiert sein muss und außer der Hydroxygruppe nur noch an Kohlenstoff- oder Wasserstoffatomen gebunden sein darf
+Nur dieser Bindungszustand entspricht dem Oxidationszustand eines normalen Alkanols
+Wenn die Hydroxygruppe an ein nicht-sp<num>-hybridisiertes Kohlenstoffatom gebunden ist das Teil eines aromatischen Ringes ist so werden diese Verbindungen als Phenole bezeichnet und zählen nicht zu den Alkoholen
+Während Alkohole schwächer sauer sind als Wasser und mit einem pKs-Wert von ca <num> zu den sehr schwachen Säuren zählen gehören normale Phenole mit einem pKs-Wert von <num> bereits zu den schwachen Säuren
+Nomenklatur und Einteilung
+Der Name einfacher Alkohole ergibt sich als Zusammensetzung aus dem Namen des ursprünglichen Alkans und der Endung
+Zusätzlich wird die Position der OH-Gruppe durch eine vorangestellte Zahl verdeutlicht zum Beispiel
+Eine veraltete bis <num> gültige Bezeichnung für Alkohole ist - nach einem Vorschlag von Hermann Kolbe -
+Carbinole
+Die Stoffgruppe der Alkohole wird nach verschiedenen Kriterien Zahl der Nichtwasserstoffnachbarn Wertigkeit Vorhandensein von Doppel-Dreifachbindungen und Kettenlänge eingeteilt
+DateiPrim sec tert Alcohols V<num>png
+Zahl der Nichtwasserstoffnachbarn
+Man unterscheidet Alkohole nach der Zahl der C- und H-Atome an dem C-Atom der funktionellen Gruppe an das auch die Hydroxygruppe gebunden ist
+Bei primären Alkoholen sind an dieses C-Atom neben einem C-Atom zwei H-Atome bei sekundären Alkoholen neben zwei C-Atomen ein H-Atom und bei tertiären Alkoholen neben drei C-Atomen kein Wasserstoffatom gebunden
+Ein Sonderfall ist der Alkohol mit nur einem C-Atom das Methanol das neben der Hydroxygruppe nur drei Wasserstoffatome am C-Atom der funktionellen Gruppe trägt
+Wertigkeit der Alkohole
+Ist mehr als eine Hydroxygruppe an verschiedenen C-Atomen in einem Alkoholmolekül vorhanden wird deren Anzahl durch Einfügen einer der Anzahl der Hydroxygruppen entsprechenden griechischen Silbe -di- -tri- usw vor der Endung
+angegeben und man spricht von mehrwertigen Alkoholen
+Ein
+ist das
+Trivialname Ethylenglycol ein
+das
+Trivialname Glycerin
+Die Zahl vor der Endung
+gibt die Position der funktionellen Gruppen an
+Dies gilt auch für einwertige Alkohole zum Beispiel
+Trivialname Isopropanol
+Ethanol pngStrukturformel des Ethanols<num>-propandiol numberedsvgStrukturformel <num>-propandiol numberedsvgStrukturformel
+Doppel- bzw Dreifachbindungen
+In Bezug auf das Vorhandensein von Doppel- bzw Dreifachbindungen in der Kette der C-Atome unterscheidet man Alkanole abgeleitet von Alkanen Alkenole abgeleitet von Alkenen und Alkinole abgeleitet von Alkinen
+Für den Fall dass die OH-Gruppe an ein sp<num>-hybridisiertes Kohlenstoffatom gebunden ist hat man es mit einem anderen Oxidationszustand und damit mit einer anderen Stoffgruppe zu tun nämlich mit den meist instabilen Enolen
+Allyl-alcoholpngStrukturformel des Allylalkohols <num>-Propen-<num>-ol Strukturformel von <num>-Butin-<num>-diolsvgStrukturformel des Butindiols L-Ascorbic acidsvgStrukturformel der Ascorbinsäure eines Endiols
+Kettenlänge
+Über die Kettenlänge werden Alkohole ebenfalls unterschieden
+Die Bezeichnung
+Fettalkohole
+verwendet man für Alkohole mit endständiger primärer
+mit gerader Kette und einer Länge von sechs Hexanol bis hin zu <num> Behenylalkohol Kohlenstoffatomen Sie werden meist durch Reduktion der
+aus Fettsäuren gewonnen
+Die höheren primären Alkohole mit <num> bis <num> Kohlenstoffatome bezeichnet man als Wachsalkohole
+Physikalische Eigenschaften
+Niedrigmolekulare Alkohole sind Flüssigkeiten die einen charakteristischen Geruch und einen brennenden Geschmack besitzen
+Höhere Alkohole sind meist feste Verbindungen mit nur schwach ausgeprägtem Geruch
+Aufgrund von intermolekularen Wasserstoffbrückenbindungen besitzen die Alkohole im Vergleich zu Kohlenwasserstoffen gleicher Molekülmasse relativ hohe Schmelz- und Siedepunkte Wichtigstes gemeinsames Merkmal der Alkohole ist die Hydrophilie
+Diese Eigenschaft nimmt mit zunehmender Länge des Alkylrestes ab und mit der Anzahl der Hydroxygruppen zu
+Besonders die kurzkettigen Alkohole werden aufgrund ihres amphiphilen Charakters oft als Lösungsmittel verwendet
+Hohe Siedepunkte
+DateiH-bonding alcoholsvg DateiDiagramm-Abhängigkeit des Sdp von Anzahl OH-Gruppenpng Sauerstoff ist elektronegativer als Wasserstoff und Kohlenstoff d h er zieht Elektronen stärker an als diese
+Das führt zu einer unsymmetrischen Verteilung der Elektronen entlang der
+man spricht von einer polaren Bindung es bildet sich ein molekularer Dipol aus
+Diese Dipole können untereinander Wasserstoffbrückenbindungen ausbilden die die Anziehung der einzelnen Moleküle untereinander drastisch verstärken
+Dies führt für Alkohole zu relativ hohen Siedepunkten gegenüber den um eine Methyleneinheit verlängerten Homologen ihrer Stammverbindung die eine annähernd gleiche molarer Masse besitzen
+So hat beispielsweise das unpolare Ethan C<num>H<num> M
+<num> einen Siedepunkt von -<num> C während Methanol CH<num>OH M
+<num> diesen erst bei <num> C erreicht
+Zusammenfassend
+Im Vergleich zu Alkanen mit einer vergleichbaren molaren Masse haben Alkohole einen höheren Schmelz- und Siedepunkt da die Hydroxygruppe OH-Gruppe Wasserstoffbrückenbindungen ausbildet
+Je mehr Hydroxygruppen ein Molekül aufweist desto mehr Wasserstoffbrückenbindungen können ausgebildet werden und desto höher ist der Siedepunkt
+Zwischen den Alkylresten bilden sich zusätzlich Van-der-Waals-Kräfte aus
+Deswegen steigt der Siedepunkt mit der Länge des Alkylrestes
+Da die Stärke der Van-der-Waals-Wechselwirkungen nicht nur von der Größe des Alkylrestes sondern auch von dessen Oberfläche abhängig ist weisen stark verzweigte eher kugelförmige Moleküle mit einer mittelständigen Hydroxygruppe einen niedrigeren Siedepunkt als unverzweigte langgestreckte primäre Alkohole auf
+Hydrophilie
+Die OH-Gruppe ist ebenfalls in der Lage Wasserstoffbrückenbindungen mit Wasser einzugehen
+Sie erhöht damit die Hydrophilie die Wasserlöslichkeit der Verbindung
+Organische Alkylreste selbst sind nicht wasserlöslich also hydrophob
+Die Wasserlöslichkeit sinkt daher mit der Größe des organischen Anteils und steigt mit der Zahl der Hydroxygruppen
+Die Propanole und tert-Butanol sind bei Raumtemperatur noch in jedem Verhältnis mit Wasser mischbar alle langkettigeren Alkohole lösen sich nur noch in zunehmend kleinen Mengen
+Größere Mengen gelöster anorganischer Salze können auch bei den kurzkettigen Alkoholen eine Phasentrennung bewirken Salzfracht
+Zusammenfassend
+Die Hydroxygruppe eines Alkohols ist aufgrund der ungleichen Ladungsverteilung polar
+Somit ist die Fähigkeit derselben auch zu ebenfalls polaren Wassermolekülen Wasserstoffbrückenbindungen ausbilden zu können für die gute Löslichkeit vor allem kurzkettiger Alkohole verantwortlich
+Je mehr Hydroxygruppen ein Alkohol aufweist desto mehr Wasserstoffbrücken können diese mit dem Wasser ausbilden
+Daher steigt mit wachsender Anzahl der hydrophilen Hydroxygruppen die Wasserlöslichkeit
+Diesem Effekt wirkt allerdings der hydrophobe also wasserabweisende unpolare Alkylrest entgegen Je länger er ist desto geringer ist die Wasserlöslichkeit des Alkohols
+Acidität und Deprotonierung
+Mit einem pK-Wert Säurestärke von etwa <num> sind Alkohole schwächer sauer als Wasser und reagieren somit in wässriger Lösung näherungsweise neutral
+Die Acidität von Alkoholen nimmt in der Reihe von Methanol über primäre sekundäre und tertiäre Alkohole ab
+Es ist möglich Alkohole mit starken Basen wie z B
+Hydridanionen oder durch Reaktion mit Natrium unter Entwicklung von Wasserstoff zu deprotonieren
+Die dabei entstehenden
+Alkoholate
+können dann als stark nucleophile Anionen für weitere Reaktionen eingesetzt werden
+Es ist auch möglich Alkohole in gewissem Umfang mit starken Säuren zu protonieren DateiMethanol saeure basesvg
+Spektroskopie
+Im IR-Spektrum von Alkoholen ist deutlich die breite Bande der O-H-Valenzschwingung im Bereich von <num>-<num> cm-<num> zu erkennen
+Die Breite des Peaks wird durch Wasserstoffbrückenbindungen mit Wassermolekülen verursacht und ist in Spektren von wasserfreien Alkoholen in einem engeren Bereich von <num>-<num> cm-<num> zu finden
+Chemische Eigenschaften
+Reaktion mit konzentrierter Schwefelsäure
+Unterhalb von <num> C bildet sich der Ester der Schwefelsäure
+Bei etwa <num> C findet die Kondensationsreaktion zu einem Ether statt
+Oberhalb von <num> C werden primäre Alkohole zu Alkenen dehydratisiert
+Eliminierung
+Selenoxid-Eliminierung
+Die Selenoxid-Eliminierung ist eine milde Variante der Eliminierung
+Veresterung
+Mit Carbonsäuren reagieren Alkohole unter Wasserabgabe zu Estern diese Reaktion wird auch Veresterung genannt
+Diese Reaktion wird durch Säuren katalysiert
+Oxidation
+Primäre Alkohole lassen sich zu Aldehyden und Carbonsäuren sekundäre Alkohole zu Ketonen oxidieren
+Tertiäre Alkohole lassen sich nicht weiter oxidieren es sei denn unter Zerstörung des Kohlenstoffgerüsts
+Zur Oxidation von primären Alkoholen zur Carbonsäure können ChromVI-haltige Oxidationsmittel eingesetzt werden wie sie z B
+bei der Jones-Oxidation Anwendung finden
+Als chromfreies weniger giftiges Reagenz steht wässriges Rutheniumtetroxid zur Verfügung
+Die Oxidation eines primären Alkohols kann unter Verwendung bestimmter ChromVI-Verbindungen wie dem Collins-Reagenz auch nur bis zur Stufe des Aldehyds erfolgen
+Entscheidend ist dass wasserfreie Lösungsmittel eingesetzt werden
+Ist kein Wasser anwesend kann keine Hydratisierung zum geminalen Diol des Aldehyds Aldehydhydrate stattfinden
+ateiAlkohol - Aldehyd - Carbonsäuresvg
+Da lösliche Chromate sehr giftig sind sowie karzinogene und mutagene Eigenschaften besitzen wurden alternative Methoden zur Oxidation von Alkoholen entwickelt
+Eine häufig zur Anwendung kommende Methode ist die Swern-Oxidation mit aktiviertem Dimethylsulfoxid Fast alle Methoden eignen sich ebenfalls für die Oxidation sekundärer Alkohole zu Ketonen
+Die folgende Aufzählung liefert eine Übersicht der wichtigsten Methoden
+Oxidation zur Carbonsäurezum Keton
+Jones-Oxidation ChromVI-oxid in Schwefelsäure unter Anwesenheit von Aceton
+Kaliumdichromat in Schwefelsäure
+Rutheniumtetroxid
+Oxidation zum Aldehydzum Keton
+Collins-Reagenz CrO<num>py<num> in Dichlormethan
+Corey-Reagenz Pyridiniumchlorochromat PCC
+Cornforth-Reagenz Pyridiniumdichromat PDC
+Anelli-Oxidation kat TEMPO stöch
+NaOCl
+Dess-Martin-Oxidation Dess-Martin-Periodinan
+Ley-Oxidation kat TPAP stöch NMO
+Pfitzner-Moffatt-Oxidation DMSO DCC
+Swern-Oxidation DMSO Oxalylchlorid NEt<sub><num><sub>
+Acetalbildung
+Mit Aldehyden reagieren Alkohole in Gegenwart saurer Katalysatoren zu Halbacetalen bzw Acetalen
+Verwendung
+Viele Alkohole sind wichtige Lösungsmittel die sowohl in der Industrie als auch im Haushalt eingesetzt werden die mengenmäßig wichtigsten sind Methanol Ethanol <num>-Propanol und -Butanol
+Im Jahr <num> wurden weltweit etwa <num> Mio Tonnen dieser alkoholischen Lösungsmittel nachgefragt
+Nachweis
+Umsetzung mit metallischem Natrium
+Wenn man zu einer flüssigen Alkoholprobe Natrium hinzufügt so entsteht Wasserstoff welchen man mit der Knallgasprobe nachweisen kann
+Diese Methode gilt zwar als Alkoholnachweis ist jedoch nicht eindeutig da alle ausreichend protischen Substanzen zum Beispiel Carbonsäuren anorganische Säuren oder Wasser die gleiche Reaktion eingehen
+Alcotest
+Der Umsatz von Alkoholen mit Dichromaten in schwefelsaurer Lösung ist geeignet um Alkohole quantitativ nachzuweisen und wurde früher in den Alcotest-Röhrchen eingesetzt
+Das Nachweisprinzip beruht auf dem Farbumschlag von gelb-orange saure Dichromatlösung nach grün ChromIII-Ionen und kann spektralphotometrisch gemessen werden
+Certest
+Eine weitere Möglichkeit besteht in der Umsetzung mit AmmoniumcerIV-nitrat
+Hierbei wird eine konzentrierte Lösung von AmmoniumcerIV-nitrat mit einer verdünnten Lösung der unbekannten Substanz versetzt
+Enthält die unbekannte Substanz Alkohol-Gruppen färbt sich das Gemisch rot manchmal auch grün
+Enthält die Substanz Phenole fällt ein brauner Niederschlag aus
+Der Grund für diese Farbreaktion ist eine Komplexbildung genauer gesagt eine Ligandensubstitution bei der ein AlkoholPhenol mit dem Sauerstoffatom am CerIV koordiniert
+Durch die Veränderung der Ligandensphäre verändert sich die Farbe des CerIV von hellgelb zu rotgrünbraun
+Leicht oxidierbare AlkoholePhenole können einen negativen Nachweis ergeben indem sie das CerIV zu CerIII reduzieren
+Lucas-Probe
+Der Nachweis des Substitutionsgrades eines Alkohols also ob es sich dabei um einen primären sekundären oder tertiären Alkohol handelt erfolgt über nucleophile Substitution der OH-Gruppe gegen Chlorid durch die Lucas-Probe
+Die Substitution hat zur Folge dass sich die entstehende Substanz nicht mehr in Wasser löst und damit eine eigene Phase ausbildet
+Dabei ist die Geschwindigkeit dieser Phasenbildung entscheidend
+Tertiäre Alkohole reagieren bei Raumtemperatur sofort
+Sekundäre Alkohole reagieren nach etwa fünf Minuten
+Primäre Alkohole reagieren ausschließlich unter Erwärmen
+Voraussetzung für diesen Test ist dass sich der ursprüngliche Alkohol in Wasser löst
+Auch darf keine andere unter den Reaktionsbedingungen substituierbare Gruppe vorliegen
+Spektroskopie und Derivatisierung
+Die eindeutige Identifizierung eines unbekannten Alkohols erfolgt entweder spektroskopisch oder durch Synthese eines charakteristischen Derivates das einen Schmelzpunkt hat der von den Schmelzpunkten gleicher Derivate ähnlicher Alkohole gut zu unterscheiden ist
+Oftmals werden sie über Ester der
+oder der
+identifiziert
+Hierzu wird die zu analysierende Substanz in Gegenwart geringer Mengen Schwefelsäure umgesetzt
+Die Schmelzpunkte dieser Derivate sind in der Regel scharf
+Die Derivate der
+besitzen in der Regel höhere Schmelzpunkte als die der
+Sie werden dann bevorzugt gewählt wenn der Schmelzpunkt mit der
+zu niedrig ist und keine genaue Bestimmung mehr möglich wird
+Liste wichtiger Alkohole mit Schmelz- und Siedepunkten
+Liste wichtiger Alkohole mit Schmelz- und Siedepunkten
+omologe Reihe der einwertigen primären linearen unverzweigten AlkoholeC-AtomeMolare Masse
+gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
+CSiedetemperatur
+CLöslichkeit
+gl-<num>MethanolHolzgeist Methylalkohol -<num><num>Siegfried Hauptmann Organische Chemie <num> Auflage VEB Deutscher Verlag für Grundstoffindustrie Leipzig <num> ISBN <num>-<num>-<num>-<num> S <num>
+<num>EthanolAlkohol Ethylalkohol Weingeist -<num><num> <num>
+<num>Propan-<num>-oln-Propylalkohol -<num><num> <num>Butan-<num>-oln-Butylalkohol -<num><num>Pentan-<num>-oln-Amylalkohol -<num>Hans Beyer und Wolfgang Walter Organische Chemie S Hirzel Verlag Stuttgart <num> Auflage <num> S <num> ISBN <num>-<num>-<num>-<num><num>Hexan-<num>-oln-Hexylalkohol -<num><num>Hans Beyer und Wolfgang Walter Organische Chemie S Hirzel Verlag Stuttgart <num> Auflage <num> S <num> ISBN <num>-<num>-<num>-<num><num>Heptan-<num>-ol
+-<num>Hans Rudolf Christensen Grundlagen der organischen Chemie Verlag Sauerländer Aarau <num> Auflage <num> S <num><num>Octan-<num>-ol
+-<num><num><num>Nonan-<num>-ol
+-<num> ZVG<num>CAS<num>-<num>-<num>Datum<num> April <num>-<num><num>Name<num>-NonanolDatum <num> November <num>Decan-<num>-ol <num> ZVG<num>CAS<num>-<num>-<num>Datum<num> Januar <num><num>Undecan-<num>-ol <num>Auflage<num> Titel Kapitel<num> Startseite<num> Endseite<num>Dodecan-<num>-olLaurylalkohol<num>Tridecan-<num>-ol <num>Auflage<num> Titel Kapitel<num> Startseite<num> Endseite<num>Tetradecan-<num>-olMyristylalkohol<num>-<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>Pentadecan-<num>-ol <num>Hexadecan-<num>-olCetylalkohol<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num>
+<num>Octadecan-<num>-olStearylalkohol<num>-<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num>
+<num>Hexacosan-<num>-olCerylalkohol<num>-<num> <num> Pa<num>
+<num>Triacontan-<num>-olMyricylalkohol<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num> <num>Einwertige Alkohole sekundär und tertiär primär mit verzweigten KettenC-AtomeMolare Masse
+gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
+CSiedetemperatur
+CLöslichkeit
+gl-<num>Propan-<num>-olIsopropylalkohol Isopropanol -<num><num> <num>Butan-<num>-olSekundärer Butylalkohol -<num><num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>-Methylpropan-<num>-olIsobutylalkohol -<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>-Methylpropan-<num>-olTertiärer Butylalkohol Trimethylcarbinol<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num> <num>Pentan-<num>-olsek-n-Amylalkohol -<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>Pentan-<num>-olDiethylcarbinol -<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num> <num> C<num>-Methylbutan-<num>-ol
+-<num>Robert C Weast Hrsg CRC Handbook of Chemistry and Physics <num>st Student Edition <num> CRC Press Baton Rouge Florida S C-<num> ISBN <num>-<num>-<num>-<num><num>-Methylbutan-<num>-olIsoamylalkohol -<num><num>-Methylbutan-<num>-ol
+-<num> <num>-Methylbutan-<num>-ol
+<num> <num><num>-Dimethylpropan-<num>-olneo-Pentylalkohol tertiärer Amylalkohol -<num>Mehrwertige AlkoholeC-AtomeMolare Masse
+gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
+CSiedetemperatur
+CLöslichkeit
+gl-<num>Ethan-<num>-diolEthylenglycol <num>-Glycol -<num><num> <num>Propan-<num>-diolPropylenglycol -<num> <num>Propan-<num>-diolTrimethylenglycol -<num> <num>Butan-<num>-diol<num>-Butylenglycol -<num> <num>Butan-<num>-diol<num>-Butylenglycol < -<num> <num>Butan-<num>-diolTetramethylenglycol<num> <num>Butan-<num>-diol<num>-Butylenglycol<num> meso<num> meso <num>Pentan-<num>-diolPentamethylenglycol -<num> <num>Hexan-<num>-diolHexamethylenglycol<num>-<num>-<num>Octan-<num>-diolOctamethylenglycol<num>-<num>
+<num>-<num> <num> hPa <num>Nonan-<num>-diolNonamethylenglycol<num>-<num>Decan-<num>-diolDecamethylenglycol<num>Propan-<num><num>-triolGlycerin Glycerol<num> Weitere AlkoholeC-AtomeMolare Masse
+gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
+CSiedetemperatur
+CLöslichkeit
+gl-<num>Cyclopentanol
+-<num><num>-<num>-<num>CyclopentanolDatum<num> Juli <num> oder früher<num>Cyclohexanol <num><num><num>Prop-<num>-en-<num>-olAllylalkohol -<num> <num><num>But-<num>-en-<num>-olCrotylalkohol -<num>-Butin-<num>-ol -<num><num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>-<num>-Hexin-<num>-ol<num>Phenylmethanol HydroxymethylbenzolBenzylalkohol -<num><num>Cyclohexylmethanol<num>-<num>-Octin-<num>-ol<num>-Octin-<num>-ol<num>-Phenylethan-<num>-ol <num>-Hydroxyethylbenzol C<num>H<num>CHOHCH<num>
+α-Phenylethylalkohol<num>-Phenylethan-<num>-ol <num>-Hydroxyethylbenzol C<num>H<num>CH<num>CH<num>OH β-Phenylethylalkohol -<num>-Decanol<num>-Decanol -<num>-<num>-tert-Butylbenzylalkohol<num>-<num>Diphenylmethanol C<num>H<num><num>CHOHDiphenyltricarbinol Benzhydrol<num>Triphenylmethanol C<num>H<num><num>COHTriphenylcarbinol<num> ><num>Zum Vergleich das Phenol und Alkohole mit ähnlichen molaren MassenC-AtomeMolare Masse
+gmol-<num>Systematischer NameTrivialnameSchmelzpunkt
+CSiedetemperatur
+CLöslichkeit
+gl-<num>PhenolCarbolsäure Benzenol
+<num><num>Pentan-<num>-oln-Amylalkohol -<num><num>Hexan-<num>-oln-Hexylalkohol -<num><num>Cyclopentanol
+-<num>Cyclohexanol <num><num>Anmerkung Doppelbindungenbei Siedepunkt Die Substanz zersetzt sich vor Erreichen des Siedepunktes
+Werte in Klammern geben den Siedepunkt bei <num> hPa Druck an bei Löslichkeit unbegrenzt mit Wasser mischbar
+Bei einzelnen Werten kann es in der Literatur zu Abweichungen kommen
+Siehe auch
+Alkoholpulver
+Einzelnachweise
+Weblinks
+Schulversuche zum Thema Alkohole Brockhaus ABC Chemie VEB F A Brockhaus Verlag Leipzig <num> S <num> Science Vision Jg <num> Nr <num> März <num>
+Wissenschaft-Online-Lexika Eintrag zu AlkanoleAlkohole im Lexikon der Chemie abgerufen am <num> Juli <num> Paula Yurkanis Bruice Organische Chemie Pearson Education Inc <num> <num> Auflage S <num> ISBN <num>-<num>-<num>-<num>-<num> Paula Yurkanis Bruice Organische Chemie Pearson Education Inc <num> <num> Auflage S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num>Ceresana
+Markstudie Lösungsmittel
+<num> Auflage UC-<num> April <num> Paula Yurkanis Bruice Organische Chemie Pearson Education Inc <num> <num> Auflage S <num> ISBN <num>-<num>-<num>-<num>-<num> NA
+Aluminium im angloamerikanischen Sprachraum vielfach auch Aluminum ist ein chemisches Element mit dem Elementsymbol Al und der Ordnungszahl <num> Im Periodensystem gehört Aluminium zur dritten Hauptgruppe und zur <num> IUPAC-Gruppe der Borgruppe die früher auch als Gruppe der Erdmetalle bezeichnet wurde
+Es gibt zahlreiche Aluminiumverbindungen
+Aluminium ist ein silbrig-weißes Leichtmetall
+In der Erdhülle ist es nach Sauerstoff und Silicium das dritthäufigste Element und in der Erdkruste das häufigste Metall
+In der Werkstofftechnik werden mit Aluminium alle Werkstoffe auf Basis des Elementes Aluminium verstanden
+Dazu zählt Reinaluminium mindestens <num>
+Al Reinstaluminium min <num>
+Al und insbesondere die Aluminiumlegierungen die Festigkeiten besitzen die mit Stahl vergleichbar sind bei nur einem Drittel seiner Dichte
+Entdeckt wurde Aluminium das in der Natur fast ausschließlich in Form von chemischen Verbindungen vorkommt im frühen <num> Jahrhundert
+Im frühen <num> Jahrhundert setzte die industrielle Massenproduktion ein
+Die Gewinnung erfolgt in Aluminiumhütten ausgehend von dem Mineral Bauxit zunächst im Bayer-Verfahren mit dem Aluminiumoxid gewonnen wird und anschließend im Hall-Héroult-Prozess einer Schmelzflusselektrolyse bei der Aluminium gewonnen wird
+<num> wurden weltweit <num> Mio Tonnen Aluminiumoxid Al<num>O<num> produziert Daraus hat man <num> Mio
+Tonnen Primäraluminium gewonnen
+Das Metall ist sehr unedel und reagiert an frisch angeschnittenen Stellen bei Raumtemperatur mit Luft und Wasser zu Aluminiumoxid
+Dies bildet aber sofort eine dünne für Luft und Wasser undurchlässige Schicht Passivierung und schützt so das Aluminium vor Korrosion
+Reines Aluminium weist eine geringe Festigkeit auf bei Legierungen ist sie deutlich höher
+Die elektrische und thermische Leitfähigkeit ist hoch weshalb Aluminium für leichte Kabel und Wärmetauscher verwendet wird
+Eines der bekanntesten Produkte ist Alufolie
+Weitere sind Bauteile in Fahrzeugen und Maschinen elektrische Leitungen Rohre Dosen und Haushaltsgegenstände
+Das Aluminiumrecycling erreicht weltweit Raten von etwa <num>
+Geschichte
+<num> vermutete Lavoisier als erster dass es sich bei der <num> von Marggraf aus einer Alaunlösung gewonnenen Alaunerde alumina abgeleitet von lateinisch
+Alaun um das Oxid eines bislang unbekannten Elements handle
+Dessen Darstellung glückte schließlich <num> dem Dänen Hans Christian Ørsted durch Reaktion von Aluminiumchlorid AlCl<num> mit Kaliumamalgam wobei Kalium als Reduktionsmittel diente
+Davy der sich lange Zeit ebenfalls an der Darstellung des neuen Elements versucht hatte führte ab <num> die Namensvarianten alumium aluminum und aluminium ein von welchen die letzten beiden im Englischen bis heute nebeneinander fortbestehen
+<num> gelang es Friedrich Wöhler mit der gleichen Methode wie Ørsted jedoch unter Verwendung metallischen Kaliums als Reduktionsmittel reineres Aluminium zu gewinnen
+Henri Étienne Sainte-Claire Deville verfeinerte den Wöhler-Prozess im Jahr <num> und publizierte ihn <num> in einem Buch
+Durch diesen verbesserten Prozess stieg die Ausbeute bei der Aluminiumgewinnung und in der Folge fiel der Preis des Aluminiums der zuvor höher als jener von Gold gewesen war innerhalb von zehn Jahren auf ein Zehntel
+<num> wurde unabhängig voneinander durch Charles Martin Hall und Paul Héroult das nach ihnen benannte Elektrolyseverfahren zur Herstellung von Aluminium entwickelt der Hall-Héroult-Prozess
+<num> entwickelte Carl Josef Bayer das nach ihm benannte Bayer-Verfahren zur Isolierung von reinem Aluminiumoxid aus Bauxiten
+Aluminium wird noch heute nach diesem Prinzip großtechnisch hergestellt
+Am Ende des <num> Jahrhunderts stand das Metall in solchem Ansehen dass man daraus gefertigte Metallschiffe auf den Namen Aluminia taufte
+Vorkommen
+Aluminium ist mit einem Anteil von <num> Gewichtsprozent nach Sauerstoff und Silicium das dritthäufigste Element der Erdkruste und damit das häufigste Metall
+Allerdings kommt es aufgrund seines unedlen Charakters praktisch ausschließlich in gebundener Form vor
+Die größte Menge befindet sich chemisch gebunden in Form von Alumosilicaten in denen es in der Kristallstruktur die Position von Silicium in Sauerstoff-Tetraedern einnimmt
+Diese Silicate sind zum Beispiel Bestandteil von Ton Gneis und Granit
+Seltener wird Aluminiumoxid in Form des Minerals Korund und seiner Varietäten Rubin rot und Saphir farblos verschiedenfarbig gefunden
+Die Farben dieser Kristalle beruhen auf Beimengungen anderer Metalloxide
+Korund hat mit fast <num> Prozent den höchsten Aluminiumanteil einer Verbindung
+Einen ähnlich hohen Aluminiumanteil haben die noch selteneren Minerale Akdalait etwa <num> Prozent und Diaoyudaoit etwa <num> Prozent
+Insgesamt sind bisher Stand <num> <num> aluminiumhaltige Minerale bekannt
+Das einzige wirtschaftlich wichtige Ausgangsmaterial für die Aluminiumproduktion ist Bauxit
+Vorkommen befinden sich in Südfrankreich Les Baux Guinea Bosnien und Herzegowina Ungarn Russland Indien Jamaika Australien Brasilien und den Vereinigten Staaten
+Bauxit enthält ungefähr <num> Prozent Aluminiumhydroxid AlOH<num> und AlOOH etwa <num> Prozent Eisenoxid Fe<num>O<num> und Siliciumdioxid SiO<num>
+Bei der Herstellung unterscheidet man Primäraluminium auch Hüttenaluminium genannt das aus Bauxit gewonnen wird und Sekundäraluminium aus Aluminiumschrott
+Die Wiederverwertung benötigt nur etwa <num> Prozent der Energie der Primärgewinnung
+Aluminium als Mineral
+Infolge der Passivierung kommt Aluminium in der Natur sehr selten auch elementar gediegen vor
+Erstmals entdeckt wurde Aluminium <num> durch B V Oleinikov A V Okrugin N V Leskova in Mineralproben aus der Billeekh Intrusion und dem Dyke OB-<num> in der Republik Sacha Jakutien im russischen Föderationskreis Ferner Osten
+Insgesamt sind weltweit bisher rund <num> Fundorte Stand <num> für gediegen Aluminium bekannt so unter anderem in Aserbaidschan Bulgarien der Volksrepublik China Guangdong Guizhou Jiangsu und Tibet und in Venezuela
+Zudem konnte gediegen Aluminium in Gesteinsproben vom Mond das die Sonde der Luna-<num>-Mission vom Krater Apollonius mitbrachte nachgewiesen werden
+Aufgrund der extremen Seltenheit hat gediegen Aluminium zwar keine Bedeutung als Rohstoffquelle als gediegen vorkommendes Element ist Aluminium dennoch von der International Mineralogical Association IMA als eigenständiges Mineral anerkannt Interne Eingangs-Nr
+der IMA <num>-<num>a Gemäß der Systematik der Minerale nach Strunz <num> Auflage wird Aluminium unter der System-Nummer <num>AA<num> Elemente - Metalle und intermetallische Verbindungen - Kupfer-Cupalit-Familie - Kupfergruppe eingeordnet
+In der veralteten <num> Auflage der Strunzschen Mineralsystematik ist Aluminium dagegen noch nicht aufgeführt
+Nur im zuletzt <num> aktualisierten Lapis-Mineralienverzeichnis das sich aus Rücksicht auf private Sammler und institutionelle Sammlungen noch an dieser Form der System-Nummerierung orientiert erhielt das Mineral die System- und Mineral-Nr
+IA<num>-<num> Die vorwiegend im englischsprachigen Raum verwendete Systematik der Minerale nach Dana führt das Element-Mineral unter der System-Nr
+<num><num>
+In der Natur kommt gediegen Aluminium meist in Form körniger Mineral-Aggregate und Mikronuggets vor kann in seltenen Fällen aber auch tafelige Kristalle bis etwa einen Millimeter Größe entwickeln
+Frische Mineralproben sind von metallisch glänzender silberweißer Farbe
+An der Luft dunkeln die Oberflächen durch Oxidierung nach und wirken grau
+Auf der Strichtafel hinterlässt Aluminium einen dunkelgrauen Strich
+Je nach Fundort enthält Aluminium oft Fremdbeimengungen von anderen Metallen Cu Zn Sn Pb Cd Fe Sb oder tritt eingewachsen in beziehungsweise mikrokristallin verwachsen mit Hämatit Ilmenit Magnetit Moissanit und Pyrit beziehungsweise Jarosit auf
+Typmaterial das heißt Mineralproben aus der Typlokalität des Minerals wird im Geologischen Museum der Akademie der Wissenschaften in Jakutsk in der russischen Teilrepublik Sacha Jakutien aufbewahrt
+Gewinnung
+Primäraluminium Herstellung aus Mineralien
+DateiAluminium - Trend Förderungsvg
+Aluminiummetall wird elektrolytisch aus einer Aluminiumoxidschmelze hergestellt
+Da diese aus den auf der Erde allgegenwärtigen Alumosilicaten nur schwer isoliert werden kann erfolgt die großtechnische Gewinnung aus dem relativ seltenen silikatärmeren Bauxit
+Zur Gewinnung von reinem Aluminiumoxid aus Silikaten gibt es seit langem Vorschläge deren Umsetzung allerdings bis heute nicht wirtschaftlich möglich ist
+Das im Erz enthaltene Aluminiumoxid-hydroxid-Gemisch wird zunächst mit Natronlauge aufgeschlossen Bayer-Verfahren Rohrreaktor- oder Autoklaven-Aufschluss um es von Fremdbestandteilen wie Eisen- und Siliciumoxid zu befreien und wird dann überwiegend in Wirbelschichtanlagen aber auch in Drehrohröfen zu Aluminiumoxid Al<num>O<num> gebrannt
+Der trockene Aufschluss Deville-Verfahren hat dagegen keine Bedeutung mehr
+Dabei wurde feinstgemahlenes ungereinigtes Bauxit zusammen mit Soda und Koks in Drehrohröfen bei rund <num> C kalziniert und das entstehende Natriumaluminat anschließend mit Natronlauge gelöst
+DateiSchmelzflusselektrolyse von Aluminiumsvg Die Herstellung des Metalls erfolgt in Aluminiumhütten durch Schmelzflusselektrolyse von Aluminiumoxid nach dem Kryolith-Tonerde-Verfahren Hall-Héroult-Prozess
+Zur Herabsetzung des Schmelzpunktes wird das Aluminiumoxid zusammen mit Kryolith geschmolzen Eutektikum bei <num> C Bei der Elektrolyse entsteht an der den Boden des Gefäßes bildenden Kathode Aluminium und an der Anode Sauerstoff der mit dem Graphit Kohlenstoff der Anode zu Kohlenstoffdioxid und Kohlenstoffmonoxid reagiert
+Die Graphitblöcke welche die Anode bilden brennen so langsam ab und werden von Zeit zu Zeit ersetzt
+Die Graphitkathode Gefäßboden ist gegenüber Aluminium inert
+Das sich am Boden sammelnde flüssige Aluminium wird mit einem Saugrohr abgesaugt
+DateiAluwagenjpg DateiTovarna glinice in aluminija Kidričevo - kupi aluminija <num>jpg
+Aufgrund der hohen Bindungsenergie durch die Dreiwertigkeit des Aluminiums ist der Prozess recht energieaufwändig
+Pro produziertem Kilogramm Rohaluminium müssen <num> bis <num> Kilowattstunden an elektrischer Energie eingesetzt werden
+Eine Reduzierung des Strombedarfs ist nur noch in geringem Ausmaß möglich weil die Potentiale für energetische Optimierungen weitgehend erschlossen sind Aluminiumherstellung ist daher nur in der Nähe preiswert zur Verfügung stehender Elektroenergie wirtschaftlich beispielsweise neben Wasserkraftwerken wie in Rheinfelden oder ehemals in Ranshofen unweit des Inns
+Die nachfolgende Tabelle zeigt die Aluminiumproduktion und die maximal mögliche Produktionsleistung der Hüttenwerke nach Ländern
+Siehe auch Liste der größten Aluminiumproduzenten
+Sekundäraluminium Herstellung durch Aluminium-Recycling
+Um Aluminium zu recyceln werden Aluminiumschrotte und Krätzen in Trommelöfen eingeschmolzen
+Krätze ist ein Abfallprodukt bei der Verarbeitung von Aluminium und bei der Herstellung von Sekundäraluminium
+Krätze ist ein Gemisch aus Aluminiummetall und feinkörnigen Oxidpartikeln und wird beim Schmelzen von Aluminium bei <num> C aus dem Aluminiumoxid der normalen Aluminiumkorrosion und als Oxidationsprodukt Oxidhaut beim Kontakt von flüssigem Aluminium mit Luftsauerstoff gebildet
+Damit beim Aluminiumgießen keine Aluminiumoxidpartikel in das Gussteil gelangen wird die Krätze durch Kratzvorrichtungen von der Oberfläche des Metallbads abgeschöpft
+Um die Bildung von Krätze zu verhindern wird die Oberfläche der Schmelze mit Halogenidsalzen rund zwei Drittel NaCl ein Drittel KCl und geringe Mengen Calciumfluorid CaF<num> abgedeckt siehe dazu Aluminiumrecycling
+Dabei entsteht als Nebenprodukt Salzschlacke die noch ca <num> Prozent Aluminium enthält die entsprechend aufbereitet als Rohstoff für mineralische Glasfasern dient
+Allerdings steht das Sekundäraluminium im Ruf dass beim Recycling pro Tonne jeweils <num> bis <num> Kilogramm Salzschlacke verunreinigt mit Dioxinen und Metallen entsteht deren mögliche Wiederverwertung aber Stand der Technik ist
+Eigenschaften
+Physikalische Eigenschaften
+DateiAluminum Spectrajpg DateiAluminium bar surface etchedjpg DateiMacroetched AluminiumJPG
+Mikrostruktur
+Aluminium erstarrt ausschließlich in einem kubisch flächenzentrierten Raumgitter in der
+Der Gitterparameter beträgt bei Reinaluminium <num> nm
+entspricht <num> Å bei <num> Formeleinheiten pro Elementarzelle
+Leerstellen kommen mit einer Dichte von <num>
+<num>-<num> bei <num> C vor bei Raumtemperatur sind es nur noch <num>-<num>
+Durch Abschrecken können auch größere Leerstellendichten bei Raumtemperatur vorkommen was für einige Eigenschaften von Aluminiumwerkstoffen von Bedeutung ist da die Leerstellen die Diffusion begünstigen
+Durch Umformen bei Raumtemperatur kann die Leerstellendichte auf <num>-<num> erhöht werden
+Die Versetzungsdichte liegt bei <num>-<num> einem für Metalle typischen Bereich und führt zur guten Umformbarkeit von Aluminium
+Stapelfehler konnten bei Aluminium nicht nachgewiesen werden was mit der hohen Stapelfehlerenergie von <num> bis <num> <num>-<num> Jcm erklärt wird
+Dies führt dazu dass die Festigkeitsteigerung beim Kaltwalzen und -schmieden nur gering ausfällt und manche Aluminiumwerkstoffe sogar anschließend zur Entfestigung neigen
+Dichte
+Mit einer Dichte von <num> gcm etwa ein Drittel von Stahl ist Aluminium ein typisches Leichtmetall was es als Werkstoff für den Leichtbau interessant macht
+Die Dichte der Legierungen weicht meist nur um etwa <num>
+bis -<num>
+ab
+Spezielle Legierungen mit Lithium haben eine <num>
+geringere Dichte
+Aluminium zählt somit zu den leichtesten Werkstoffen übertroffen nur noch von Magnesium
+Mechanische Eigenschaften
+Aluminium ist ein relativ weiches und zähes Metall
+Die Zugfestigkeit von absolut reinem Aluminium liegt bei <num> Nmm die Streckgrenze bei <num> Nmm und die Bruchdehnung bei <num>
+während bei handelsüblich reinem Aluminium die Zugfestigkeit bei <num> Nmm liegt die Streckgrenze bei <num> Nmm und die Bruchdehnung bei <num>
+Die Zugfestigkeit seiner Legierungen liegt dagegen bei bis zu <num> Nmm Legierung <num>
+Sein Elastizitätsmodul liegt bei etwa <num> GPa einem häufig angegebenen Wert
+Für Reinaluminium wird ein Wert von <num> GPa angegeben
+die Werte schwanken jedoch von <num> bis <num> GPa
+Der G-Modul liegt bei <num> kNmm die Querkontraktionszahl Poissonzahl bei <num>
+Thermische Eigenschaften
+Die Schmelztemperatur liegt bei <num> C und die Siedetemperatur bei <num> C
+Die Schmelztemperatur ist deutlich niedriger als die von Kupfer <num> C Gusseisen <num> C und Eisen <num> C was Aluminium zu einem guten Gusswerkstoff macht
+Bei einer Sprungtemperatur von <num> K wird reines Aluminium supraleitend
+Die Wärmeleitfähigkeit liegt mit <num> WK m relativ hoch
+Die Wärmeleitfähigkeit von Kupfer liegt zwar etwa doppelt so hoch dafür ist die Dichte etwa viermal größer weshalb Aluminium für Wärmetauscher in Fahrzeugen genutzt wird Der Wärmeausdehnungskoeffizient ist durch den recht niedrigen Schmelzpunkt mit <num> µmm-<num>K-<num> recht hoch
+Die Schwindung also die Volumenabnahme beim Erstarren liegt bei <num>
+Elektrische Eigenschaften
+Da thermische und elektrische Leitfähigkeit bei Metallen von denselben Mechanismen dominiert werden ist Aluminium mit
+auch ein sehr guter elektrischer Leiter
+In der Rangfolge der Elemente mit der größten spezifischen Leitfähigkeit steht Aluminium wie auch bei der Wärmeleitfähigkeit hinter Silber Kupfer und Gold an vierter Stelle
+Durch die Kombination von hohem spezifischem Leitwert geringer Dichte hoher Verfügbarkeit und im Vergleich zu anderen Materialien geringen Kosten ist Aluminium in der Elektrotechnik - speziell in der Energietechnik wo große Leiterquerschnitte benötigt werden - neben Kupfer zum wichtigsten Leitermaterial geworden
+Magnetische Eigenschaften
+Aluminium ist paramagnetisch wird also von Magneten angezogen der Effekt ist jedoch sehr schwach ausgeprägt
+Die Magnetische Suszeptibilität liegt bei Raumtemperatur bei <num>
+<num>-<num> mkg womit Aluminium praktisch gesehen unmagnetisch ist
+Chemische Eigenschaften
+DateiAlkorrosionwebm Das reine Leichtmetall Aluminium hat aufgrund einer sich sehr schnell an der Luft bildenden dünnen Oxidschicht ein stumpfes silbergraues Aussehen
+Diese passivierende Oxidschicht macht reines Aluminium bei pH-Werten von <num> bis <num> sehr korrosionsbeständig sie erreicht eine Dicke von etwa <num> µm
+Diese Oxidschicht schützt auch vor weiterer Oxidation ist aber bei der elektrischen Kontaktierung und beim Löten hinderlich
+Sie kann durch elektrische Oxidation Eloxieren oder auf chemischem Weg verstärkt werden
+Die Oxidschicht kann mittels Komplexbildungsreaktionen aufgelöst werden
+Einen außerordentlich stabilen und wasserlöslichen Neutralkomplex geht Aluminium in neutraler chloridischer Lösung ein
+Folgende Reaktionsgleichung veranschaulicht den Vorgang
+Dies geschieht vorzugsweise an Stellen wo die Oxidschicht des Aluminiums bereits geschädigt ist
+Es kommt dort durch Bildung von Löchern zur Lochfraßkorrosion
+Kann die chloridische Lösung dann an die freie Metalloberfläche treten so laufen andere Reaktionen ab
+Aluminium-Atome können unter Komplexierung oxidiert werden
+Liegen in der Lösung Ionen edlerer Metalle vor so werden sie reduziert und am Aluminium abgeschieden
+Auf diesem Prinzip beruht die Reduktion von Silberionen die auf der Oberfläche von angelaufenem Silber als Silbersulfid vorliegen hin zu Silber
+Aluminium reagiert heftig mit wässriger Natriumhydroxidlösung NaOH und etwas weniger heftig mit wässriger Natriumcarbonatlösung unter Bildung von Wasserstoff
+Diese Reaktion wird in chemischen Rohrreinigungsmitteln ausgenutzt
+Die Reaktion von Aluminium mit NaOH läuft in zwei Schritten ab der Reaktion mit Wasser und die Komplexierung des Hydroxids zu Natriumaluminat
+Bei der Reaktion mit Wasser
+entsteht zunächst Aluminiumhydroxid
+In der Regel wird anschließend die Oberfläche getrocknet dabei wird das Hydroxid in das Oxid umgewandelt
+Dies passiert jedoch nicht bei der Reaktion von Aluminium in wässriger Natronlauge
+Nun folgt der <num> Schritt die Komplexierung des Hydroxids zu Natriumaluminat
+Durch die Komplexierung wird das gallertartige Hydroxid wasserlöslich und kann von der Metalloberfläche abtransportiert werden
+Dadurch ist die Aluminiumoberfläche nicht mehr vor dem weiteren Angriff des Wassers geschützt und Schritt <num> läuft wieder ab
+Mit dieser Methode lassen sich - ebenso wie bei der Reaktion von Aluminium mit Säuren - pro zwei Mol Aluminium drei Mol Wasserstoffgas herstellen
+Mit Brom reagiert Aluminium bei Zimmertemperatur unter Flammenerscheinung
+Hierbei ist zu beachten dass das entstehende Aluminiumbromid mit Wasser unter Bildung von Aluminiumhydroxid und Bromwasserstoffsäure reagiert
+Mit Quecksilber bildet Aluminium ein Amalgam
+Wenn Quecksilber direkt mit Aluminium zusammenkommt d h wenn die Aluminiumoxidschicht an dieser Stelle mechanisch zerstört wird frisst Quecksilber Löcher in das Aluminium unter Wasser wächst dann darüber Aluminiumoxid in Gestalt eines kleinen Blumenkohls
+Daher wird Quecksilber in der Luftfahrt als Gefahrgut und ätzende Flüssigkeit gegenüber Aluminiumwerkstoffen eingestuft
+Auch mit Salzsäure reagiert Aluminium sehr heftig unter Wasserstoffentwicklung von Schwefelsäure wird es langsam aufgelöst
+In Salpetersäure wird es passiviert
+In Pulverform Partikelgröße kleiner <num> µm ist Aluminium vor allem dann wenn es nicht phlegmatisiert ist aufgrund seiner großen Oberfläche sehr reaktiv
+Aluminium reagiert dann mit Wasser unter Abgabe von Wasserstoff zu Aluminiumhydroxid
+Feinstes nicht phlegmatisiertes Aluminiumpulver wird auch als Pyroschliff bezeichnet
+Nicht phlegmatisierter Aluminiumstaub ist sehr gefährlich und entzündet sich bei Luftkontakt explosionsartig von selbst
+Isotope
+In der Natur kommt ausschließlich das Isotop <num>Al vor Aluminium gehört damit zu den Reinelementen
+Dieses Isotop das stabil ist und im Kern <num> Neutronen und <num> Protonen enthält absorbiert keine Neutronen weshalb Aluminium auch in Kernreaktoren genutzt wird
+Alle anderen Isotope werden künstlich erzeugt und sind radioaktiv
+Das stabilste dieser Isotope ist <num>Al mit einer Halbwertszeit von einer Million Jahren
+Durch Elektroneneinfang oder Beta-Zerfall entsteht daraus <num>Mg durch Einfangen eines Neutrons und anschließenden Gamma-Zerfall <num>Al
+Die Isotope <num>Al bis <num>Al Außer <num>Al und <num>Al haben Halbwertszeiten zwischen wenigen Sekunden und einigen hundert Sekunden
+<num>Al zerfällt mit einer Halbwertszeit von nur <num> Sekunden
+Aluminiumlegierungen
+Aluminiumlegierungen sind Legierungen die überwiegend aus Aluminium bestehen
+Für andere Legierungen die Aluminium enthalten siehe Abschnitt Weitere Anwendungen
+Aluminium kann mit zahlreichen Metallen legiert werden um bestimmte Eigenschaften zu fördern oder andere ungewünschte Eigenschaften zu unterdrücken
+Bei einigen Legierungen ist die Bildung der schützenden Oxidschicht Passivierung stark gestört wodurch die daraus gefertigten Bauteile teils korrosionsgefährdet sind
+Nahezu alle hochfesten Aluminiumlegierungen sind von dem Problem betroffen
+Es gibt Aluminiumknetlegierungen die zur Weiterverarbeitung durch Walzen Schmieden und Strangpressen gedacht sind und Gusswerkstoffe
+Diese werden in Gießereien verwendet
+Im Allgemeinen werden Aluminiumlegierungen in die zwei große Gruppen der Knet- und Gusslegierungen eingeteilt
+Aluminiumgusslegierungen
+Typische Aluminiumgusslegierungen enthalten Silicium als Hauptlegierungselement AlSi es gibt aber auch Sorten mit Kupfer oder Magnesium als Gusslegierungen
+Aluminiumknetlegierungen sie haben einen Anteil von etwa <num>
+und werden weiter unterteilt nach dem Hauptlegierungselementen in Reinaluminium mit Aluminiumgehalten von <num>
+bis <num>
+Sie sind sehr leicht zu bearbeiten haben geringe Festigkeit und gute Korrosionsbeständigkeit
+Aluminium-Kupfer-Legierungen AlCu Sie haben mittlere bis hohe Festigkeit sind aushärtbar aber korrosionsanfällig und schlecht schweißbar
+Sie können Zusätze von Magnesium oder Mangan enthalten
+Aluminium-Mangan-Legierungen AlMn Sie haben geringe bis mittlere Festigkeit sind korrosionsbeständig und gut zu verarbeiten
+Aluminium-Magnesium-Legierungen AlMg ohne AlMgSi Sie haben mittlere Festigkeiten sind nicht aushärtbar korrosionsbeständig gut umformbar und schweißbar
+Die meisten Sorten enthalten zusätzlich noch Mangan AlMgMn
+Aluminium-Magnesium-Silicium-Legierungen AlMgSi Sie haben mittlere bis hohe Festigkeiten sind gut zu bearbeiten durch Schweißen und Strangpressen aushärtbar und korrosionsbeständig
+Aluminium-Zink-Magnesium-Legierungen AlZnMg Kupferfreie Sorten haben mittlere bis hohe Festigkeiten und sind gut schweißbar
+Kupferhaltige Sorten AlZnMgCu haben hohe Festigkeiten - im Falle <num> über <num> MPa - sind nicht durch Schmelzschweißen jedoch gut durch Zerspanen Fräsen Bohren zu bearbeiten
+Sonderlegierungen beispielsweise Aluminium-Lithium-Legierungen mit besonders geringer Dichte oder Automatenlegierungen die besonders gut zerspanbar sind
+Außerdem wird unterschieden zwischen naturharten Legierungen - welche sich durch eine Wärmebehandlung nicht härten lassen - und aushärtbaren
+Typische naturharte Aluminiumknetlegierungen sind AlMg AlMn AlMgMn AlSi
+Aushärtbare Knetlegierungen - Festigkeitssteigerung durch Ausscheidungshärtung von Legierungselementen bei einer zusätzlichen Alterungsglühung bei <num> bis <num> C
+Typische aushärtbare Aluminiumknetlegierungen sind AlMgSi AlCuMg AlZnMg
+Die erste hochfeste aushärtbare Aluminiumlegierung AlCuMg bekam <num> die Handelsbezeichnung Duraluminium kurz Dural genannt
+Wirtschaftliche Bedeutung
+Aluminium ist nach Stahl der zweitwichtigste metallische Werkstoff
+<num> wurden weltweit <num> Mio Tonnen produziert
+DateiAl-Cu-spotpricesvg Der Aluminiumpreis bewegte sich am Weltmarkt seit <num> um den Wert von <num> Dollar pro Tonne Reinheit von <num>
+Er ist jedoch relativ volatil <num> fiel er auf um die <num> Dollar pro Tonne während er <num> wieder bei annähernd <num> Dollar lag
+Verwendung
+Konstruktionswerkstoff allgemein
+DateiAldruckgussjpg Aluminium weist eine hohe spezifische Festigkeit auf
+Verglichen mit Stahl sind Bauteile aus Aluminium bei gleicher Festigkeit etwa halb so schwer weisen jedoch ein größeres Volumen auf Deshalb wird es gern im Leichtbau verwendet also dort wo es auf geringe Masse ankommt die zum Beispiel bei Transportmitteln zum geringeren Treibstoffverbrauch beiträgt vor allem in der Luft- und Raumfahrt
+Auch im Kraftfahrzeugbau gewann es aus diesem Grund an Bedeutung hier standen früher der hohe Materialpreis die schlechtere Schweißbarkeit sowie die problematische Dauerbruchfestigkeit und die Verformungseigenschaften bei Unfällen geringes Energieaufnahmevermögen in der sogenannten Knautschzone im Wege
+Die Haube des Washington-Denkmals ein <num> kg schweres Gussstück galt bis <num> als eines der größten Aluminiumwerkstücke Beim Bau von kleinen und mittleren Schiffen und Booten wird die Korrosionsbeständigkeit von Aluminium gegenüber Salzwasser geschätzt Der Fahrzeugbau inklusive Schiffen Flugzeugen und Schienenfahrzeugen machte <num> mit ca <num> Prozent den größten Anteil an der weltweiten Verwendung von Aluminium aus
+In Aluminiumlegierungen werden Festigkeiten erreicht die denen von Stahl nur wenig nachstehen
+Daher ist die Verwendung von Aluminium zur Gewichtsreduzierung überall dort angebracht wo Materialkosten eine untergeordnete Rolle spielen
+Insbesondere im Flugzeugbau und in der Weltraumtechnik sind Aluminium und Duraluminium weit verbreitet
+Der größte Teil der Struktur heutiger Verkehrsflugzeuge wird aus Aluminiumblechen verschiedener Stärken und Legierungen genietet
+Fahrzeugbau
+Bei Fahrzeugen spielt deren Masse eine Rolle Je leichter ein Fahrzeug ist desto geringer ist der Treibstoffverbrauch
+In Deutschland werden knapp <num>
+des Aluminiums im Fahrzeugbau verwendet Stand <num>
+Autos
+Bei Autos werden Aluminiumwerkstoffe verwendet für verschiedene Motorkomponenten - darunter der Motorblock die Zylinderkolben für die spezielle Kolbenlegierungen existieren die Zylinderköpfe - wo vor allem die geringe Wärmeausdehnung und Korrosionsanfäligkeit sowie die hohe Warmfestigkeit ausschlaggebend sind zusammen mit der guten Gießbarkeit da diese Komponenten üblicherweise gegossen werden
+Weitere Anwendungen bei Fahrzeugen sind für Gehäuse von Getrieben als Wärmeabschirmung und als Wärmetauscher - bei den letzten beiden in Form von Reinaluminium
+Im Fahrwerk wird Aluminium genutzt als Schmiedeteile für Hinterachsen Achsträger Querlenker und Räder
+In der Karosserie wird Aluminium verwendet für Türen Motorhauben Stoßfänger und Kotflügel sowie in der Rohwagenstruktur
+Nutzfahrzeuge
+Bei Nutzfahrzeugen wird Aluminium angewandt für Bordwände Ladebordwände Aufbauten zur Ladungssicherung Druckluftbehälter Treibstofftanks und als Unterbauschutz
+Der Leichtbau mit Aluminium wird bei Nutzfahrzeugen stark durch die gesetzliche Maximallast pro Achse beeinflusst Bei geringerem Fahrzeuggewicht ist eine höhere Nutzlast möglich
+Schienenfahrzeuge
+Auch bei Schienenfahrzeugen wird reichlich Aluminium verwendet
+Voraussetzung waren dafür zwei wichtige andere Entwicklungen Bestimmte Schweißverfahren die für Aluminiumwerkstoffe geeignet sind WIG-Schweißen
+MIG-Schweißen in den <num>ern und das Strangpressen von Großprofilen
+Die Verwendung von Aluminium hat die gesamte Bauweise von Schienenfahrzeugen verändert
+Bis etwa <num> waren Konstruktionen aus Stahlrohren üblich danach vermehrt verschweißte Profile aus Aluminium
+Flugzeuge
+Bereits in der Anfangsphase der Luftfahrt wurden Aluminiumwerkstoffe genutzt <num> beispielsweise Magnalium für die Beschläge eines Flugzeuges das noch größtenteils aus Holz Draht und Tuch bestand
+Das erste flugfähige Ganzmetallflugzeug stammt aus dem Jahre <num> bestand allerdings aus Stahlblechen in Schalenbauweise
+Die entscheidende Entwicklung zur Verwendung von Aluminium im Flugzeugbau stammt von <num> von Alfred Wilm der mit dem Duraluminium eine aushärtbare Aluminium-Kupfer-Legierung fand die sehr hohe Festigkeiten aufweist und sich daher ausgezeichnet für den Leichtbau eignet
+Genutzt werden für Flugzeuge AlCu und AlZnMg
+Die Gesamtmasse von Flugzeugen geht zu <num>
+auf Aluminium zurück
+Die Verbindung der aus Blechen gestanzten geschnittenen oder getriebenen aus dem Vollen gefrästen oder aus Profilen bestehenden Werkstücke erfolgt meist durch Nieten da die meistverwendeten Werkstoffe schlecht schweißbar sind
+Elektrotechnik
+Elektrische Leitungen
+DateiKurzschlussljpg Aluminium ist ein guter elektrischer Leiter
+Es weist nach Silber Kupfer und Gold die vierthöchste elektrische Leitfähigkeit aller Metalle auf
+Ein Leiter aus Aluminium hat bei gegebenem elektrischen Widerstand eine kleinere Masse aber ein größeres Volumen als ein Leiter aus Kupfer
+Daher wird meistens dann Kupfer als elektrischer Leiter verwendet wenn das Volumen eine dominante Rolle spielt wie beispielsweise bei den Wicklungen in Transformatoren
+Aluminium hat dann als elektrischer Leiter Vorteile wenn das Gewicht eine wesentliche Rolle spielt beispielsweise bei den Leiterseilen von Freileitungen Aus dem Grund der Gewichtsreduktion werden auch in Flugzeugen wie dem Airbus A<num> Aluminiumkabel verwendet
+Aluminium wird unter anderem auch zu Stromschienen in Umspannwerken und zu stromführenden Gussteilen verarbeitet
+Für Elektroinstallationen gibt es kupferkaschierte Aluminiumkabel der Kupferüberzug ist zur Verbesserung der Kontaktgabe
+In diesem Anwendungsbereichen sind primär Rohstoffpreise entscheidend da Aluminium preisgünstiger als Kupfer ist
+Für Oberleitungen bei elektrischen Bahnen ist es dagegen aufgrund seiner schlechten Kontakt- und Gleiteigenschaften ungeeignet in diesem Bereich wird trotz des höheren Gewichts primär Kupfer eingesetzt
+Beim Kontaktieren unter Druck ist Aluminium problematisch da es zum Kriechen neigt
+Außerdem überzieht es sich an Luft mit einer Oxidschicht
+Nach längerer Lagerung oder Kontakt mit Wasser ist diese isolierende Schicht so dick dass sie vor der Kontaktierung beseitigt werden muss
+Vor allem im Kontakt mit Kupfer kommt es zu Bimetallkorrosion
+Bei ungeeigneten Kontaktierungen in Klemmen kann es bei Aluminiumleitern in Folge zu Ausfällen und Kabelbränden aufgrund sich lösender Kontakte kommen
+Crimpverbindungen mit passenden Hülsen und Werkzeugen sind jedoch sicher
+Als Zwischenlage zwischen Kupfer und Aluminium können Verbindungsstücke aus Cupal die Kontaktprobleme vermeiden
+Hervorzuheben ist das geringe Absinken der spezifischen elektrischen Leitfähigkeit von Aluminium bei Zusatz von Legierungsbestandteilen wohingegen Kupfer bei Verunreinigungen eine deutliche Verringerung der Leitfähigkeit zeigt
+Elektronik
+DateiTransistoroffenjpg Die Elektronikindustrie setzt Aluminium aufgrund der guten Verarbeitbarkeit und der guten elektrischen und Wärme-Leitfähigkeit ein
+In integrierten Schaltkreisen wurde bis in die <num>er-Jahre ausschließlich Aluminium als Leiterbahnmaterial eingesetzt
+Bis in die <num>er-Jahre wurde es auch als Material für die Steuerelektrode Gate von Feldeffekttransistoren mit Metall-Isolator-Halbleiter-Struktur MOSFET beziehungsweise MOS-FET verwendet Neben dem geringen spezifischen Widerstand sind für die Verwendung die gute Haftung auf und geringe Diffusion in Siliciumoxiden Isolationsmaterial zwischen den Leiterbahnen sowie die einfache Strukturierbarkeit mithilfe von Trockenätzen ausschlaggebend
+Seit Anfang der <num>er-Jahre wird Aluminium jedoch zunehmend durch Kupfer als Leiterbahnmaterial ersetzt auch wenn dafür aufwendigere Strukturierungsverfahren vgl Damascene- und Dual-Damascene-Prozess und Diffusionsbarrieren notwendig sind Der höheren Fertigungsaufwand wird durch den geringeren spezifischen Widerstand der im Fall von kleinen Strukturen bei Aluminium viel früher signifikant ansteigt und anderen Eigenschaften z B
+Elektromigrationverhalten überwogen und die Aluminium-Prozesse konnte die gestiegenen Anforderungen Taktfrequenz Verlustleistung etc in mit hohen Frequenzen arbeitenden Schaltkreisen nicht mehr genügen siehe auch RC-Glied
+Aluminium wird jedoch weiterhin auch in mikroelektronischen Produkten verwendet so wird es wegen seiner guten Kontaktierbarkeit durch andere Metalle in den letzten Leiterbahnebenen eingesetzt um den elektrischen Kontakt zu den bei der Flip-Chip-Montage eingesetzten Lotkügelchen herzustellen
+Ähnlich verhält es sich bei Leistungshalbleitern bei denen in der Regel alle Leiterbahnebenen aus Aluminium bestehen
+Allgemein und insbesondere bei Leistungshalbleitern wird das Material für Bonddrähte Verbindungsdrähte zwischen Chip und Gehäuseanschluss verwendet
+Mit der Einführung der High-kMetal-Gate-Technik hat Aluminium nach gut <num> Jahren Abstinenz auch im Bereich des Gates an Bedeutung gewonnen und wird neben anderen als Material zur Einstellung der Austrittsarbeit eingesetzt
+Verpackung und Behälter
+DateiMoka<num>jpg
+In der Verpackungsindustrie wird Aluminium zu Getränke- und Konservendosen sowie zu Aluminiumfolie verarbeitet
+Dabei macht man sich die Eigenschaft der absoluten Barrierewirkung gegenüber Sauerstoff Licht und anderen Umwelteinflüssen zunutze
+Ausschlaggebend für die Verwendung von Aluminium als Verpackung ist nicht die geringe Dichte sondern die gute Verarbeitbarkeit durch Walzen und die Ungiftigkeit Dünne Folien werden in Stärken von sechs Mikrometern hergestellt und dann zumeist in Verbundsystemen eingesetzt beispielsweise in Tetra Paks
+Kunststofffolien können durch Bedampfen mit Aluminium mit einer dünnen Schicht versehen werden welche dann eine hohe aber nicht vollständige Barrierefunktion aufweist
+Grund dieser Barrierewirkung ist nicht das reine Aluminium sondern die Passivschicht aus Böhmit
+Wird diese verletzt so kann Gas ungehindert durch den Werkstoff Aluminium strömen
+Genutzt werden meist Reinaluminium AlMn Legierungen mit Mangan und AlMg Legierungen mit Magnesium
+Aus Aluminium werden auch Kochtöpfe und andere Küchengeräte wie die klassische italienische Espressokanne sowie Reise- und Militär-Geschirr hergestellt
+Aluminium wird für eine Vielzahl von Behältern und Gehäusen verarbeitet da es sich gut durch Umformen bearbeiten lässt
+Gegenstände aus Aluminium werden häufig durch eine Eloxalschicht vor Oxidation und Abrieb geschützt
+<num> entfielen <num>
+der europäischen Aluminiumverwendung auf Verpackungen
+Tolkki<num>jpgGetränkedose
+Optik und Lichttechnik
+DateiImage-Metal-reflectancepng Aluminium wird aufgrund seines hohen Reflexionsgrades als Spiegelbeschichtung von Oberflächenspiegeln unter anderem in Scannern Kraftfahrzeug-Scheinwerfern und Spiegelreflexkameras aber auch in der Infrarotmesstechnik eingesetzt
+Es reflektiert im Gegensatz zu Silber auch Ultraviolettstrahlung
+Aluminium-Spiegelschichten werden meist durch eine Schutzschicht vor Korrosion und Kratzern geschützt
+Architektur und Bauwesen
+Betonherstellung
+Aluminiumpulver und Aluminiumpasten werden zur Herstellung von Porenbeton eingesetzt Man verwendet Verbindungen wie Aluminiumhydroxysulfat Aluminiumdihydroxyformiat oder amorphes Aluminiumhydroxid als alkalifreie Spritzbetonbeschleuniger
+Konstruktions- und Funktionswerkstoffe
+Aluminium wird als Konstruktionswerkstoff für tragende Teile von Bauwerken und als Funktionswerkstoff als dekorative korrisionsbeständige Teile verwendet
+Neben der Witterungsbeständigkeit ist vor allem die gute Verarbeitbarkeit ausschlaggebend insbesondere bei handwerklicher Fertigung
+Das Baugewerbe ist der Hauptabnehmer für Aluminiumprofile
+Genutzt wird Aluminium hauptsächlich für Fensterrahmen Türen und Elemente von Fassaden
+Besonders bekannt ist die Fassade des Imperial War Museums in Manchester
+Genutzt werden vor allem die Aluminium-Mangan-Legierungen die geringe Festigkeit und gute Korrosionsbeständigkeit haben
+Teilweise wird Aluminium auch für den Brückenbau angewandt wo sonst der Stahlbau vorherrscht
+Für den konstruktiven Ingenieurbau werden Legierungen mit höherer Festigkeit genutzt darunter AlMg und AlSi Bleche und Verbundplatten aus Aluminiumlegierungen erreichen Brandschutzklassen von nicht brennbar bis normal entflammbar Ein Wohnungsbrand entwickelt im Vollbrand <num> C Hitze was ungeachtet der Brandschutzklasse Löcher in die Aluminiumlegierung brennt die zwischen <num> C und <num> C nach unten fließt oder tropft
+Imperial War Museum <num>croppedjpgDas Imperial War Museum von AußenLibeskindSpaceFrameTowerjpgDachkonstruktion aus Aluminium beim Imperial War MuseumAluminium heat reflector with hole melted through by high temperaturesjpgAluminiumblech punktuell über <num> C erhitzt
+Weitere Anwendungen
+In der Raketentechnik besteht der Treibstoff von Feststoffraketen zu maximal <num> Prozent aus Aluminiumpulver das bei seiner Verbrennung viel Energie freisetzt Aluminium wird in Feuerwerken s a
+Pyrotechnik verwendet wo es je nach Körnung und Mischung für farbige Effekte sorgt
+Auch in Knallsätzen findet es oft Verwendung
+Bei der Aluminothermie wird Aluminium zur Gewinnung anderer Metalle und Halbmetalle verwendet indem das Aluminium zur Reduktion der Oxide genutzt wird
+Ein wichtiges Verfahren der Aluminothermie ist die Thermitreaktion bei der Aluminium mit EisenIII-oxid umgesetzt wird
+Bei dieser stark exothermen Reaktion entstehen Temperaturen bis zu <num> C und flüssiges Eisen das zum aluminothermischen Schweißen genutzt wird z B
+zum Fügen von Bahngleisen
+Weitere Anwendungen der Reduktionswirkung von Aluminium werden für Laborzwecke ermöglicht indem Aluminiumamalgam verwendet wird
+Aluminium dient als Pigment für Farben Silber- oder Goldbronze
+Farbig eloxiert ist es Bestandteil vieler Dekorationsmaterialien wie Flitter Geschenkbänder und Lametta
+Zur Beschichtung von Oberflächen wird es beim Aluminieren verwendet
+Mit Aluminium werden Heizelemente von Bügeleisen und Kaffeemaschinen umpresst
+Bevor es gelang Zinkblech durch Titanzusatz als so genanntes Titanzink verarbeitbar zu machen wurde Aluminiumblech für Fassaden- und Dachelemente siehe Leichtdach sowie Dachrinnen eingesetzt
+Wegen seiner hohen Wärmeleitfähigkeit wird Aluminium als Werkstoff für stranggepresste Kühlkörper und wärmeableitende Grundplatten verwendet
+Aluminium-Elektrolytkondensatoren verbauen Aluminium als Elektrodenmaterial und Gehäusewerkstoff weiters wird es zur Herstellung von Antennen und Hohlleitern verwendet
+Aluminium kommt in einigen Legierungen vor
+Neben den Aluminiumlegierungen die überwiegend aus Aluminium bestehen kommt es noch vor in den Kupferlegierungen Aluminiumbronze Aluminiummessing Isabellin zu etwa gleichen Teilen Al und Kupfer in der Devardaschen Legierung als Hauptlegierungselement für Magnesiumlegierungen sowie in Alnico und Sendust zwei Eisenlegierungen mit besonderen magnetischen Eigenschaften
+In vielen Titanlegierungen kommt ebenfalls Aluminium vor insbesondere in Ti-<num>Al-<num>V der Sorte die etwa <num>
+aller Titanlegierungen ausmacht Dort ist Aluminium mit <num> Massenprozent enthalten
+Verarbeitung
+Bei der Verarbeitung wird unterschieden ob es sich um Gusslegierungen handelt oder um Knetlegierungen
+Gusslegierungen werden in Gießereien verarbeitet und in Formen gegossen die schon vollständig oder weitgehend der Form der Endprodukte entsprechen
+Danach erfolgt eine Endbearbeitung durch Schleifen
+Gusslegierungen werden häufig aus Schrott erschmolzen
+Knetlegierungen werden in den Hüttenwerken zu Barren vergossen und anschließend dort gewalzt um Platten Bleche Stangen und Folien herzustellen
+Aus dicken Platten und anderen massiven Rohteilen werden durch Zerspanen Fräsen Bohren und Drehen Einzelteile hergestellt
+Andere massive Rohteile können durch Schmieden zu Einzelstücken verarbeitet werden oder durch Strangpressen zu Profilen
+Letzteres kommt bei Aluminium besonders häufig vor
+Bleche werden durch Stanzen Biegen und Tiefziehen verarbeitet
+Danach werden die Einzelteile durch Schweißen Nieten Löten und ähnliche Verfahren verbunden
+Gießen
+DateiMaterialprobe BBSjpg DateiDatenschieber für den Aluminium Gussjpg
+Das Gießen von Aluminium wird als Aluminiumguss bezeichnet
+Es gehört aufgrund seines vergleichsweise geringen Schmelzpunktes von <num> C Gusseisen etwa <num> C Stahl <num> C bis <num> C und seiner guten Gießbarkeit zu den häufig in der Gießerei verwendeten Werkstoffen
+AlSi spezielle Gusslegierungen mit Silicium haben sogar Schmelzpunkte um <num> C Der Massenanteil von Aluminium aller in Gießereien erzeugten Produkte beträgt etwa <num>
+Gusseisen <num>
+Stahlguss <num>
+und ist damit in der Gießerei das mit Abstand wichtigste Nichteisenmetall NE-Metalle noch vor Kupfer mit <num>
+Der Anteil am NE-Metallguss von Aluminium beträgt etwa <num>
+In Deutschland wurden <num> etwa <num> Tonnen Aluminium in Gießereien verarbeitet Etwa <num>
+des Nichteisenmetall-Gusses wird von der Automobilbranche abgenommen
+Aus dem niedrigen Schmelzpunkt folgt ein geringer Energieeinsatz beim Schmelzvorgang sowie eine geringere Temperaturbelastung der Formen Aluminium eignet sich grundsätzlich für alle Gussverfahren insbesondere für Druckguss beziehungsweise Aluminiumdruckguss mit denen auch kompliziert geformte Teile gefertigt werden können
+In der Gießerei werden besondere Aluminiumgusslegierungen verarbeitet größtenteils die Aluminium-Silicium-Legierungen
+In den Hüttenwerken werden dagegen meist Knetlegierungen erzeugt die zur Weiterbearbeitung durch Walzen Schmieden und Fließpressen gedacht sind
+Diese werden in den Hüttenwerken vergossen zu Barren Blockguss oder zu Rundbarren die theoretisch endlos sein können Strangguss
+Seit den <num>er-Jahren kommt der Strangguss vermehrt zum Einsatz
+Dafür gibt es spezielle Anlagen die bis zu <num> Rundbarren gleichzeitig herstellen können mit Gießlängen zwischen <num> und <num> Metern teils bis zu <num> Metern
+Die Durchmesser liegen bei <num> bis <num> mm
+Bleche werden manchmal hergestellt durch Gießen direkt auf eine Walze die die Schmelze kühlt
+Das Rohblech wird danach direkt kaltgewalzt ohne Warmwalzen was Kosten von bis zu <num>
+spart
+Umformende Verfahren
+Etwa <num> Prozent des Aluminiums wird durch Umformen bearbeitet Hierzu zählt unter anderem das Walzen Schmieden Strangpressen und Biegen
+Rein- und Reinstaluminium lässt sich wegen der niedrigen Festigkeit gut umformen und verfestigt sich bei Kaltumformung wobei große Formänderungen möglich sind
+Die Verfestigung lässt sich durch Rekristallisationsglühen beseitigen
+Knetlegierungen mit AlMg und AlMn erreichen ihre höhere Festigkeit durch die Legierungselemente und durch Kaltverformung
+Die aushärtbaren Legierungen AlMgSi AlZnMg AlCuMg und AlZnMgCu scheiden bei Umformung festigkeitssteigernde Phasen aus sie lassen sich relativ schwierig umformen
+Walzen
+Gegossene Barren werden häufig durch Walzen weiterverarbeitet entweder zu dicken Platten die anschließend durch Fräsen zu Endprodukten werden zu Blechen die durch Stanzen und Biegen weiterverarbeitet werden oder zu Folien
+Beim Walzen ändert sich die Mikrostruktur der Werkstoffe Kleine kugelförmige Bestandteile die häufig nach dem Gießen vorliegen werden plattgedrückt und in die Länge gezogen
+Das Gefüge wird dadurch einerseits feiner und gleichmäßiger andererseits aber auch Richtungsabhängig
+Die Kapazität einer Aluminium-Warmwalzanlage liegt bei etwa <num> Tonnen pro Jahr
+Verarbeitet werden Barren mit bis zu <num> Tonnen Masse
+Sie haben Abmessungen von bis zu <num> Metern Länge <num> Metern Breite und <num> cm Dicke
+Noch größere Barren können technisch verarbeitet werden die Gefügequalität nimmt dann aber ab
+Nach dem Warmwalzen liegt der Werkstoff meist mit Dicken von etwa <num> bis <num> mm vor
+Anschließend folgt das Kaltwalzen auf Enddicke
+Kaltwalzwerke haben Kapazitäten von <num> bis <num> Jahrestonnen
+Verbundwerkstoffe können durch Walzplattieren hergestellt werden
+Dabei wird ein- oder zweiseitig eine Schicht aus einem anderen Werkstoff aufgebracht
+Häufig wird auf korrosionsanfälliges Kernmaterial eine Schicht aus korrosionsbeständigem Reinaluminium aufgebracht
+Strangpressen
+DateiExtruded aluminium section x<num>jpg Aluminium lässt sich durch Strangpressen in komplizierte Konstruktionsprofile formen hierin liegt ein großer Vorteil bei der Fertigung von Hohlprofilen z B
+für Fensterrahmen Stäbe Balken Kühlkörperprofilen oder in der Antennentechnik
+Die Herstellung von Halbzeug oder Bauteilen geschieht aus Vormaterial wie etwa Walzbarren Blech oder Zylindern
+Aluminiumlegierungen lassen sich deutlich besser strangpressen als andere Werkstoffe weshalb ein großer Teil des Aluminiums mit diesem Verfahren verarbeitet wird
+Dabei wird das Ausgangsmaterial durch ein hohles Werkzeug gepresst
+Es entsteht Endlosmaterial das in der gewünschten Länge abgesägt wird
+Es können auch komplizierte Querschnitte hergestellt werden beispielsweise Hohlprofile oder welche mit Hinterschneidungen
+Der Querschnitt ist allerdings über die Länge konstant
+Mit hochfesten Legierungen sind große Mindestwanddicken erforderlich und das Pressen dauert lange weshalb eher die mittelfesten aushärtbaren Legierungen bevorzugt werden
+Die Aushärtung wird meist direkt im Anschluss durchgeführt
+Beim Strangpressen wird der Werkstoff auf Temperaturen von etwa <num> bis <num> C erwärmt um die Umformbarkeit zu erhöhen was gleichzeitig zum Lösungsglühen genutzt wird
+Direkt nach dem Strangpressen wird das Werkstück durch Luft oder Wasser starkt abgekühlt und so abgeschreckt was zu höheren Festigkeiten führt
+Sonstige
+Ein Mischverfahren aus Gießen und Schmieden ist Cobapress welches speziell für Aluminium ausgelegt ist und häufig in der Automobilbranche genutzt wird
+Moderne Walzwerke sind sehr teuer aber auch sehr produktiv
+Spanende Verfahren
+DateiSchruppenDrehenjpg
+Zum Zerspanen zählt das Drehen Bohren und Fräsen
+Aluminiumwerkstoffe sind gut spanbar Ihre genauen Eigenschaften hängen jedoch von der Legierung und Gefügezustand ab
+Zu beachten ist dass die bei der Bearbeitung auftretenden Temperaturen schnell im Bereich des Schmelzpunktes liegen können
+Bei gleichen Schnittparametern wie bei Stahl resultiert bei Aluminium allerdings eine geringere mechanische und thermische Belastung
+Als Schneidstoff wird oft Hartmetall für untereutektische oder Diamant für die stark verschleißenden übereutektischen Legierungen verwendet Insbesondere die Bearbeitung von eloxierten Werkstücken erfordert harte Werkzeuge um Verschleiß durch die harte Eloxalschicht zu vermeiden
+Die beim Schleifen von Aluminium entstehenden Schleifstäube können zu einem erhöhten Explosionsrisiko führen
+Schweißen und Löten
+Grundsätzlich sind alle Aluminium-Werkstoffe zum Schweißen geeignet wobei jedoch reines Aluminium zu Poren in der Schweißnaht neigt Außerdem neigt die Aluminiumschmelze zu Reaktionen mit der Atmosphäre weshalb fast immer unter Schutzgas geschweißt wird
+Gut geeignet sind das MIG- und Plasmaschweißen sowie das WIG-Schweißen
+Bei Letzterem wird bei Nutzung von Wechselstrom das Edelgas Argon als Schutzgas verwendet und bei Gleichstrom Helium
+Für das Laserschweißen eignen sich sowohl Kohlendioxid- als auch Festkörperlaser allerdings nicht für alle Legierungen
+Wegen der hohen Wärmeleitfähigkeit erstarrt die Schmelze sehr schnell sodass die Schweißnaht zu Poren und Rissen neigt
+Das Widerstandspunktschweißen erfordert verglichen mit Stahl höhere elektrische Ströme und kürzere Schweißzeiten sowie teilweise spezielle Geräte da die handelsüblichen Schweissgeräte für Stahl nicht dafür geeignet sind
+Für das Elektronenstrahlschweißen eignen sich alle Legierungen jedoch neigen Magnesium und Zinn zum Verdampfen während des Schweißvorgangs Lichtbogenhandschweißen wird nur noch selten verwendet meist zur Gussnachbesserung
+Löten gestaltet sich wegen der sich bildenden Oxidschicht an Luft schwierig
+Genutzt werden sowohl Hart- als auch Weichlöten mit speziellen Flussmitteln
+Alternativ kann Aluminium auch ohne Flussmittel mit Ultraschall gelötet werden dabei wird die Oxidschicht mechanisch während des Lötvorganges aufgebrochen
+Aluminium in Natur und Organismen
+Aluminium im menschlichen Körper
+Aluminium ist kein essentielles Spurenelement und gilt für die menschliche Ernährung als entbehrlich Im menschlichen Körper befinden sich durchschnittlich etwa <num> bis <num> Milligramm Aluminium Diese verteilen sich zu ungefähr <num> Prozent auf das Lungengewebe zu <num> Prozent auf die Weichteile und zu weiteren <num> Prozent auf die Knochen
+Aluminium ist damit ein natürlicher Bestandteil des menschlichen Körpers
+<num> bis <num> Prozent der üblicherweise in Lebensmitteln aufgenommenen Menge von Aluminium <num> bis <num> mg pro Tag werden unresorbiert über den Kot wieder ausgeschieden
+Chelatbildner Komplexbildner wie Citronensäure können die Resorption auf <num> bis <num> Prozent steigern
+Auch die Aufnahme von Aluminiumsalzen über den Magen-Darm-Trakt ist gering sie variiert aber in Abhängigkeit von der chemischen Verbindung und ihrer Löslichkeit dem pH-Wert und der Anwesenheit von Komplexbildnern
+Man schätzt dass <num>
+beziehungsweise <num>
+des in der Nahrung beziehungsweise im Trinkwasser erhaltenen Aluminiums im Magen-Darm-Trakt absorbiert werden Die Eliminierung von in den Organismus gelangten wasserlöslichen Aluminiumsalzen erfolgt innerhalb weniger Tage vorwiegend durch die Nieren über den Urin weniger über den Kot Bei Dialysepatienten mit einer eingeschränkten Nierenfunktion besteht daher ein erhöhtes Risiko einer Akkumulation im Körper mit toxischen Effekten etwa Knochenerweichungen und Schäden des Zentralnervensystems zusätzlich sind Dialysepatienten aufgrund für sie notwendiger pharmazeutischer Produkte Phosphatbinder einer höheren Aluminiumzufuhr ausgesetzt Aluminium das nicht über die Nieren ausgeschieden wird gelangt in die Knochen Dort wird es vergleichsweise sehr langsam eliminiert so dass man durch Modelschätzungen annimmt dass etwa <num>-<num>
+der reorbierten Dosis sich im Körper anhäufen In einem Leben häuft man etwa <num> mg Aluminium im Körper an
+Im Blut ist Al<num> überwiegend zu etwa <num>
+an Transferrin gebunden
+<num> Prozent liegen als AlPO<num>OH- <num> Prozent als Citrat-Komplex <num> Prozent als AlOH<num> und <num> Prozent als AlOH<num>- vor Das Blut Neugeborener enthält bereits Aluminiumionen die aus dem materalen Kreislauf stammen Die Serumkonzentrationen von etwa <num>-<num> μgl entspricht in etwa der von Erwachsenen
+Pflanzen
+Aluminium in Form verschiedener Salze Phosphate Silikate ist Bestandteil vieler Pflanzen und Früchte denn gelöste Al-Verbindungen werden durch Regen aus den Böden von den Pflanzen aufgenommen bei Säurebelastung der Böden infolge sauren Regens
+ist dies vermehrt der Fall siehe dazu auch Waldschäden
+Ein großer Teil des Bodens auf der Welt ist chemisch sauer
+Liegt der pH-Wert unter <num> werden Al<num>-Ionen von den Wurzeln der Pflanzen aufgenommen
+Dies ist bei der Hälfte des bebaubaren Lands auf der Welt der Fall
+Die Ionen schädigen insbesondere das Wurzelwachstum der Feinwurzeln
+Wenn die Pflanze nicht Aluminium-tolerant ist steht sie dann unter Stress
+Zahlreiche Enzyme und signalübertragende Proteine sind betroffen die Folgen der Vergiftung sind noch nicht vollständig bekannt
+In sauren metallhaltigen Böden ist Al<num> das Ion mit dem größten Potenzial zur Schädigung
+Von der Modellpflanze
+Arabidopsis
+sind Transgene bekannt die deren Aluminium-Toleranz heraufsetzen und auch bei Kulturpflanzen sind tolerante Sorten bekannt
+Der saure Regen hat beispielsweise in Schweden in den <num>er-Jahren die Seen übersäuert wodurch mehr Al<num>-Ionen in Lösung gingen und empfindliche Fische verendeten Auch in Norwegen wurde dieser Zusammenhang bei einem Forschungsprojekt in den <num>er-Jahren festgestellt
+Bei pH-Werten über <num> ist Aluminium als polymeres Hydroxykation an der Oberfläche von Silicaten gebunden
+Bei pH-Werten von <num> bis <num> steigt Anteil von mobilen Kationen
+Bei Erhöhung der Schwefelsäurekonzentration durch sauren Regen bildet sich Aluminiumhydroxysulfat
+In Lebensmitteln
+Die meisten Lebensmittel enthalten in Spurenmengen auch Aluminium
+Unverarbeitete pflanzliche Lebensmittel enthalten durchschnittlich weniger als <num> mgkg in der Frischmasse
+Dabei streuen die Werte aufgrund unterschiedlicher Sorten Anbaubedingungen und Herkunft in erheblichem Maße So weisen beispielsweise Salat und Kakao deutlich höhere Durchschnittswerte auf
+Schwarzer Tee kann Gehalte von bis zu <num> mgkg in der Trockenmasse aufweisen
+Beim Kochen oder Aufbewahren in Aluminiumgeschirr oder in Alufolie kann es außer bei sauren Lebensmitteln nach einer Schätzung zu einer maximalen zusätzlichen Aufnahme von <num> mgTagPerson kommen
+Bei sauren Lebensmitteln wie Sauerkraut oder auch Tomaten können aufgrund der Säurelöslichkeit wesentlich höhere Werte erreicht werden
+Trink- und Mineralwässer weisen mit durchschnittlich <num>-<num> mgl im Gegensatz zur Nahrung geringe Gehalte auf und stellen somit nur einen kleinen Beitrag zur täglichen Aluminium-Aufnahme
+Die Trinkwasserverordnung legt einen Grenzwert von <num> mgl fest
+Trinkwasser darf in Deutschland Österreich und der Schweiz keine höheren Werte aufweisen
+Nach einer Schätzung nimmt der erwachsene Europäer im Durchschnitt zwischen <num> und <num> mg Aluminium pro Tag über die Nahrung auf Dies entspricht einer wöchentlichen Aufnahme von <num> bis <num> mg Aluminium pro kg Körpergewicht bei einem <num> kg schweren Erwachsenen
+Die großen Unsicherheiten beruhen auf den unterschiedlichen Ernährungsgewohnheiten und der variablen Gehalte an Aluminium in den Lebensmitteln auch innerhalb eines Landes aufgrund verschiedener Erhebungen Falls Säuglinge mit Fertignahrung ernährt werden kann die Aluminiumkonzentration im Blut bei <num> μgl liegen Eine mögliche gesundheitliche Schädigung ist nicht bekannt
+Die Europäische Behörde für Lebensmittelsicherheit Efsa legt eine tolerierbare wöchentliche Aufnahme TWI von <num> mg Aluminium pro kg Körpergewicht fest
+Aluminium ist als Lebensmittelzusatzstoff unter der Bezeichnung E <num> ausschließlich als Farbmittel für Überzüge von Zuckerwaren und als Dekoration von Kuchen und Keksen erlaubt
+Weiterhin ist Aluminium zum Färben von Arzneimitteln und Kosmetika zugelassen
+Bei der Untersuchung von Laugengebäck Brezeln Stangen Brötchen aus Bäckereien wurde Aluminium nachgewiesen das in das Lebensmittel gelangt wenn bei der Herstellung von Laugengebäck Aluminiumbleche verwendet werden
+Während Bier in Aluminiumfässern transportiert wird hat sich für den Weintransport der Werkstoff Aluminium nicht durchgesetzt
+Ein kurzfristiger Kontakt schadet nicht doch können nach längerem Kontakt Weinfehler in Geruch und Geschmack oder als Trübung auftreten vor allem beim offenen Stehen an der Luft
+Toxizität
+Bei eingeschränkter Nierenfunktion und bei Dialyse-Patienten führt die Aufnahme von Aluminium zu progressiver Enzephalopathie Gedächtnis- und Sprachstörungen Antriebslosigkeit und Aggressivität durch Untergang von Hirnzellen und zu fortschreitender Demenz zu Osteoporose Arthritis mit Knochenbrüchen und zu Anämie
+weil Aluminium dieselben Speichereiweiße wie Eisen besetzt
+Dies wurde in den <num>er Jahren bei langjährigen Hämodialysepatienten durch starke Aluminiumzufuhr beobachtet Dialysis Encephalopathy Syndromeimp
+Speziell im Hinblick auf die Verwendung in Deodorants und Lebensmittel-Zusatzstoffen werden die gesundheitlichen Auswirkungen von Aluminium kontrovers diskutiert
+So wurde Aluminium mehrfach kontrovers als Faktor im Zusammenhang mit der Alzheimer-Krankheit in Verbindung gebracht
+Laut einer Studie des Bundesinstituts für Risikobewertung BfR vom Juli <num> wurde im allgemeinen Fall zum Zeitpunkt der Erstellung der Studie aufgrund der vergleichsweise geringen Menge kein Alzheimer-Risiko durch Aluminium aus Bedarfsgegenständen erkannt jedoch sollten vorsorglich keine sauren Speisen in Kontakt mit Aluminiumtöpfen oder -folie aufbewahrt werden Eine Neubewertung erfuhr im Februar <num> die Verwendung von aluminiumhaltigen Deodorants und Kosmetikartikel durch das Bundesinstitut für Risikobewertung Aluminiumsalze aus solchen Produkten können durch die Haut aufgenommen werden und die regelmäßige Benutzung über Jahrzehnte hinweg könnte möglicherweise zu gesundheitlichen Beeinträchtigungen beitragen
+Die britische Alzheimer-Gesellschaft mit Sitz in London vertritt den Standpunkt dass die bis <num> erstellten Studien einen kausalen Zusammenhang zwischen Aluminium und der Alzheimer-Krankheit nicht überzeugend nachgewiesen haben Dennoch gibt es einige Studien wie z B
+die PAQUID-Kohortenstudie in Frankreich mit einer Gesundheitsdatenauswertung von <num> Personen im Alter ab <num> Jahren seit <num> bis zur Gegenwart in welchen eine Aluminium-Exposition als Risikofaktor für die Alzheimer-Krankheit angegeben wird
+Demnach wurden viele senile Plaques mit erhöhten Aluminium-Werten in Gehirnen von Alzheimer-Patienten gefunden
+Es ist jedoch unklar ob die Aluminium-Akkumulation eine Folge der Alzheimer-Krankheit ist oder ob Aluminium in ursächlichem Zusammenhang mit der Alzheimer-Krankheit zu sehen ist Die Deutsche Alzheimer Gesellschaft sieht keinen überzeugenden Zusammenhang zwischen Aluminium-Aufnahme und Alzheimer-Krankheit
+Aluminium gehört zu den nicht essentiellen Spurenelementen bei der Toxizität kommt es im Wesentlichen auf die Menge an <num> mgl Aluminium im Blut gilt als Normalwert Werte über <num> mgl sprechen für übermäßige Belastung und Werte über <num> mgl im Blut gelten als toxisch
+Aspekte der Ökobilanz
+DateiAluminium foamjpg DateiRecycling-Code-<num>svg
+Die Herstellung von Aluminium ist sehr energieaufwendig
+Allein für die Schmelzflusselektrolyse zur Gewinnung eines Kilogramms Aluminium werden je nach Errichtungsdatum und Modernität der Anlage zwischen <num> und <num> kWh elektrische Energie benötigt Bei der Stromerzeugung für die Produktion von einem Kilogramm Aluminium werden im deutschen Kraftwerkspark <num> kg CO<num> freigesetzt im weltweiten Durchschnitt etwa <num> kg
+Es ist aber auch zu bedenken dass aufgrund des Kostenfaktors Energie die Elektrolyse verstärkt an Orten erfolgt an denen auf billige CO<num>-emissionsarme Wasserkraft zurückgegriffen werden kann wie etwa in Brasilien Kanada Venezuela oder Island Allerdings ist auch bei Verwendung von Elektrizität aus vollständig regenerativen Energien die Produktion von Aluminium nicht CO<num>-frei da der bei der Schmelzflusselektrolyse entstehende Sauerstoff mit dem Kohlenstoff der Elektroden zu CO<num> reagiert
+Die Verbrauchswerte für Roh-Aluminium erhöhen sich durch Transport- und Verarbeitungsanteile für das Wiederaufschmelzen Gießen Schleifen Bohren Polieren etc auf ca <num> kg CO<num> pro kg Aluminium-Konsumgut
+Die europaweite Recyclingrate von Aluminium liegt bei <num> Prozent
+In Österreich gelangen laut einer Studie aus dem Jahr <num> <num> Tonnen Aluminium pro Jahr über Verpackungen in den Konsum ebenso gelangen <num> Tonnen Aluminium ohne Wiederverwertung in den Hausmüll dabei sind unter anderem auch die Aluminiumhaushaltsfolien eingerechnet die nicht als Verpackung gelten
+<num> Prozent der Verpackungen im Restmüll sind Aluminiumgetränkedosen
+Diese liegen nach der Müllverbrennung in der Asche noch metallisch vor und machen in Europa durchschnittlich <num> Prozent der Asche aus In der EU werden durchschnittlich <num> Prozent des in der Bodenasche enthaltenen Aluminiums zurückgewonnen
+Durch den Abbau des Erzes Bauxit werden große Flächen in Anspruch genommen die erst nach einer Rekultivierung wieder nutzbar werden
+Um eine Tonne Aluminium herzustellen werden vier Tonnen Bauxit benötigt
+Dies erzeugt zehn Tonnen Abraum Zudem entstehen bei der Herstellung des Aluminiumoxids nach dem Bayer-Verfahren ca drei Tonnen von eisenreichem alkalischen Rotschlamm der kaum wiederverwertet wird und dessen Deponierung oder sonstige Entsorgung große Umweltprobleme aufwirft siehe entsprechende Abschnitte unter
+Rotschlamm
+und
+Bauxitbergbau in Australien
+Positiv ist hingegen die gute Wiederverwendbarkeit von Aluminium hervorzuheben wobei die Reststoffe streng getrennt erfasst und gereinigt werden müssen Aluminiumrecycling Recycling-Code-<num> ALU Aluminium ist dabei besser rezyklierbar als Kunststoffe wegen Downcycling bei nicht sortenreiner Erfassung jedoch etwas schlechter wiederverwertbar als Stahl
+Beim Aluminiumrecycling wird nur <num> Prozent der Energiemenge der Primärproduktion benötigt Durch Leichtbau mit Aluminiumwerkstoffen beispielsweise Aluminiumschaum Strangpressprofile wird Masse von beweglichen Teilen und Fahrzeugen gespart was zur Einsparung von Treibstoff führen kann
+Aluminium ist durch seine Selbstpassivierung korrosionsbeständiger als Eisen und erfordert daher weniger Korrosionsschutzmaßnahmen
+Nachweis
+Aluminiumsalze weist man durch Glühen mit verdünnter Kobaltnitratlösung CoNO<num><num> auf der Magnesia-Rinne nach
+Dabei entsteht das Pigment Thénards Blau ein Cobaltaluminiumspinell mit der Formel CoAl<num>O<num>
+Es wird auch Kobaltblau oder Cobaltblau Dumonts Blau Coelestinblau Cobaltaluminat oder - nach dem Entdecker des Pigments Josef Leithner - Leithners Blau genannt
+Nachweis mittels Kryolithprobe
+Die Probelösung wird alkalisch gemacht um Aluminium als Aluminiumhydroxid AlOH<num> zu fällen
+Der Niederschlag wird abfiltriert und mit einigen Tropfen Phenolphthalein versetzt dann gewaschen bis keine Rotfärbung durch Phenolphthalein mehr vorhanden ist
+Wenn anschließend festes Natriumfluorid NaF auf den Niederschlag gestreut wird verursachen Hydroxidionen die bei der Bildung von Kryolith Na<num>AlF<num> freigesetzt werden eine erneute Rotfärbung des Phenolphthaleins
+Nachweis als fluoreszierender Morinfarblack
+DateiAluminium-Morin-Reaktionsvg Die Probe wird mit Salzsäure HCl versetzt und eventuell vorhandenes Aluminium somit gelöst
+Anschließend wird die Probelösung mit Kaliumhydroxid KOH stark alkalisch gemacht
+Gibt man nun einige Tropfen der Probelösung zusammen mit der gleichen Menge Morin-Lösung auf eine Tüpfelplatte und säuert anschließend mit konzentrierter Essigsäure Eisessig CH<num>COOH an so ist unter UV-Strahlung λ
+<num> nm eine grüne Fluoreszenz beobachtbar
+Der Nachweis ist dann sicher wenn diese Fluoreszenz bei Zugabe von Salzsäure wieder verschwindet
+Grund hierfür ist dass AlIII in neutralen sowie essigsauren Lösungen in Verbindung mit Morin eine fluoreszierende kolloidale Suspension bildet
+Verbindungen
+DateiCorundum-<num>jpg DateiHybridschaltungjpg DateiKaaliumi maarjase monikristallid<num>JPG
+Aluminiumoxid Al<num>O<num> englisch alumina auch als Tonerde oder Korund bekannt liegt als weißes Pulver oder in Form sehr harter Kristalle vor
+Es ist das Endprodukt des Bayer-Verfahrens und dient in erster Linie als Ausgangsmaterial für die Aluminiumgewinnung Schmelzflusselektrolyse
+Es wird darüber hinaus als Schleif- oder Poliermittel und für Uhrensteine Ziehsteine und Düsen verwendet
+In keramischer Form dient es als Isolierstoff Konstruktionskeramik als Substratmaterial für Dickschichtschaltkreise als Grundplatte von Leistungshalbleitern und in transparenter Form als Entladungsgefäß von Natriumdampf-Hochdrucklampen
+Aluminiumhydroxid AlOH<num> wird ebenfalls nach dem Bayer-Verfahren gewonnen und ist das wichtigste Ausgangsmaterial zur Erzeugung anderer Al-Verbindungen vor allem für Aluminate
+Als reines Produkt wird es als Füllstoff und zum Brandschutz in Kunststoffen und Beschichtungen eingesetzt
+Aluminiumchlorid Polyaluminiumchlorid und Aluminiumsulfat werden vor allem als Flockungsmittel in der Wasseraufbereitung Abwasserreinigung und der Papierindustrie eingesetzt
+Natriumaluminat NaAlOH<num> wird ebenfalls als Flockungsmittel verwendet und ist weiterhin Rohstoff für die Zeolith-Produktion Titandioxid-Beschichtung und Calciumaluminatsulfat-Herstellung
+Zeolithe Alumosilikate als Ionenaustauscher in Lebensmitteln und in Waschmitteln zur Wasserenthärtung
+Alaune Kaliumaluminiumsulfat KAlSO<num><num><num>H<num>O
+Wegen seiner adstringierenden Wirkung als Rasierstift eingesetzt zum Stillen von kleinen Blutungen
+Aluminiumdiacetat bekannt als essigsaure Tonerde für entzündungshemmende Umschläge
+Aluminiumorganische Verbindungen wie etwa Triethylaluminium werden im großtechnischen Maßstab als Katalysatoren in der Polyethylen-Herstellung eingesetzt
+Ein weiteres Anwendungsgebiet ist die Halbleitertechnik
+Hier werden flüchtige Aluminiumalkyle Trimethylaluminium Triethylaluminium etc als Vorstufen zur CVD chemical vapor deposition von Aluminiumoxid verwendet das man als Isolator und Ersatz für das nicht ausreichend isolierende Siliciumdioxid einsetzt
+Aluminiumoxynitrid ist ein transparenter keramischer Werkstoff
+Aluminiumnitrid ist ein Konstruktions- und Isolationswerkstoff und zeichnet sich durch sehr hohe Wärmeleitfähigkeit bei Raumtemperatur aus
+Außerdem könnte die hohe Bandlücke die Anwendung als Wide-Bandgap-Halbleiter ermöglichen
+Lithiumaluminiumhydrid LiAlH<num> ist ein starkes Reduktionsmittel welches weitverbreitet bei der Synthese organischer Verbindungen ist
+Phosphate Aluminiumphosphate sind Aluminiumsalze der Phosphorsäure
+Aufgrund der Eigenschaft der Phosphorsäure beziehungsweise des Phosphat-Anions PO<num> <num>- unter bestimmten Bedingungen Wasser abzuspalten und infolgedessen zu polymerisieren sind verschiedene Aluminiumphosphate bekannt Aluminiumorthophosphat AlPO<num>
+Aluminiummetaphosphat AlPO<num><num>
+Monoaluminiumphosphat AlH<num>PO<num><num>
+Aluminiumpolyphosphat
+In der Natur treten Aluminiumphosphate meist in Form von Doppelsalzen auf
+Beispiele hierfür sind etwa der Wavellit Al<num>PO<num><num>F OH<num>
+<num>H<num>O oder der Türkis ein Mischphosphat aus Kupfer und AluminiumEisen CuAlFe<num>PO<num><num>OH<num>
+<num> H<num>O
+Unter besonderen Bedingungen tritt Aluminium auch einwertig auf
+Diese Verbindungen werden zur Gewinnung von hochreinem Aluminium genutzt Subhalogeniddestillation
+Siehe auch
+Liste der Aluminiumhütten
+Liste der größten Aluminiumproduzenten
+Literatur
+Zur Geschichte
+Hans Joliet Hrsg Aluminium - Die ersten hundert Jahre VDI Verlag <num> ISBN <num>-<num>-<num>-<num>
+Deutsche Fachliteratur
+Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage
+Springer <num> ISBN <num>-<num>-<num>-<num>-<num>
+Aluminium-Taschenbuch
+Aluminium-Verlag Düsseldorf Band <num> Grundlagen und Werkstoffe <num> Auflage <num>
+Band <num> Umformen von Aluminium-Werkstoffen Gießen von Aluminium-Teilen Oberflächenbehandlung von Aluminium Recycling und Ökologie <num> Auflage <num> <num> S
+Band <num> Weiterverarbeitung und Anwendung <num> Auflage <num> <num> S
+Luitgard Marschall Aluminium
+Metall der Moderne
+Oekom München <num> ISBN <num>-<num>-<num>-<num>-<num>
+Englische Fachliteratur
+George E Totten D Scott MacKenzie Handbook of Aluminum
+Marcel Dekker Yew York Basel Band <num> Physical Metallurgy and Processes
+<num> <num> S
+Band <num> Alloy Production and Materials Manufacturing
+<num> <num> S
+Joseph R Davis Hrsg Aluminum and Aluminum Alloys
+<num> Auflage <num> <num> S
+Weblinks
+MATERIAL ARCHIV Aluminium - Umfangreiche Materialinformationen und Bilder
+Newsseite des Gesamtverbands der Aluminiumindustrie
+Lars Fischer
+Wie gefährlich ist Aluminium
+Spektrumde <num> Juli <num>
+Einzelnachweise
+Norman N Greenwood Alan Earnshaw Chemie der Elemente Wiley-VCH Weinheim <num> ISBN <num>-<num>-<num>-<num> N A Figurowski Die Entdeckung der chemischen Elemente und der Ursprung ihrer Namen in deutscher Übersetzung von Leo KorniljewErnst Lemke Moskau <num> ISBN <num>-<num>-<num>-<num> S <num> Norman N Greenwood Alan Earnshaw Chemistry of the Elements <num> Auflage Butterworth-Heinemann <num> ISBN <num>-<num>-<num>-<num> S <num>
+auf Webmineral englisch Fundortliste für Aluminium beim Mineralienatlas und bei Mindat IMACNMNC List of Mineral Names November <num> PDF <num> MB Aluminium siehe S <num> IMACNMNC List of Mineral Names <num> PDF <num> MB Aluminium siehe S <num> Rudolf Debar Die Aluminium-Industrie <num> Auflage Springer <num> S <num> ff
+PDF Seminararbeit <num> kB S <num> Matthias Dienhart
+PDF <num> MB Dissertation Rheinisch-Westfälischen Technischen Hochschule Aachen Juni <num> S <num> Rainer Quinkertz Optimierung der Energienutzung bei der Aluminiumherstellung Dissertation Rheinisch-Westfälische Technische Hochschule Aachen <num> S <num>-<num> R Feige G Merker
+PDF Udo Boin Thomas Linsmeyer Franz Neubacher Brigitte Winter Stand der Technik in der Sekundäraluminiumerzeugung im Hinblick auf die IPPC-Richtlinie Österreichisches Umweltbundesamt Wien <num> ISBN <num>-<num>-<num>-<num> umweltbundesamtat PDF Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> D R Askeland Materialwissenschaft Spektrum Heidelberg <num> ISBN <num>-<num>-<num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> <num> Der Technologie-Leitfaden von ELB
+In Eloxalwerk Ludwigsburg
+Website des Luftfahrt-BundesamtesGeorge E Totten D Scott MacKenzie Handbook of Aluminum Band <num> Physical Metallurgy and Processes Marcel Dekker Yew York Basel <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num>-<num> Aluminium-Taschenbuch - Band <num> <num> Auflage Aluminium-Verlag Düsseldorf <num> S <num> Preisindex an der London Metall Exchange D R Askeland Materialwissenschaft Spektrum Heidelberg <num> S <num> D R Askeland Materialwissenschaft Spektrum Heidelberg <num> S <num> world-aluminiumorg The Global Aluminium Industry <num> years from <num> PDF <num> kB abgerufen am <num> November <num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num>vgl
+Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num>Verheilung von Aluminium
+Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num> httpswwwspotlightmetalcomhow-environmentally-friendly-is-the-european-aluminium-industry-gal-<num>p<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> NA Bernd Leitenberger
+In Bernd Leitenbergers Web Site Aluminium auf Feuerwerk-Wiki wwwfeuerwerknet Eberhard Roos Karl Maile Werkstoffkunde für Ingenieure <num> bearbeitete Auflage <num> Springer S <num> A Herbert Fritz Günter Schulze Fertigungstechnik <num> Auflage Springer Berlin <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> Rüdiger Bähr Urformen in Molitor Grote Herold Karpuschewski Einführung in die Fertigungslehre Shaker <num> S <num> Heiko Lickfett Wirtschaftliche Bedeutung der Gießereiindustrie in Andreas Bühring-Polaczek Walter Michaeli Günter Spur Hrsg Handbuch Urformen Hanser <num> S <num>-<num> Bernhard Ilschner Robert F Singer Werkstoffwissenschaften und Fertigungstechnik Eigenschaften Vorgänge Technologien <num> Auflage Springer Berlin <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Fritz Klocke Wilfried König Fertigungsverfahren <num> Umformen <num> Auflage Springer Heidelberg S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Friedrich Ostermann Anwendungstechnologie Aluminium <num> Auflage Springer <num> S <num>-<num> Eberhard Roos Karl Maile Werkstoffkunde für Ingenieure Grundlagen Anwendung Prüfung <num> Auflage Springer Berlin <num> S <num> Wilfried König Fritz Klocke Fertigungsverfahren <num> Drehen Bohren Fräsen <num> Auflage Springer <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> Thorsten Zurell Absaugung von Aluminium-Schleifstäuben und -Schweißrauchen im Automobilbau mit ex-geschützten Filtersystemen In
+Gefahrstoffe - Reinhalt Luft <num> Nr <num><num> <num> S <num>-<num> Udo M Spornitz Anatomie und Physiologie Lehrbuch und Atlas für Pflege- und Gesundheitsfachberufe Springer Berlin <num> ISBN <num>-<num>-<num>-<num>-<num> Wilfried Puwein Das Waldsterben in Österreich und seine ökonomischen Folgen Nr <num> <num> wifoacat PDF <num> kB Aluminium in Lebensmitteln lebensmittelorg Safety of aluminium from dietary intake - Scientific Opinion of the Panel on Food Additives Flavourings Processing Aids and Food Contact Materials AFC In
+The EFSA Journal <num> <num> S <num>-<num> doi<num>jefsa<num> Aluminium in der Datenbank für Lebensmittelzusatzstoffe Chemisches und Veterinäruntersuchungsamt Karlsruhe
+PDF <num> H Eschnauer Die Verwendung von Aluminium in der Weinwirtschaft Vitis <num> <num> S <num>-<num> zitiert von S <num> vitis-veade PDF <num> kB H E Müller W Dünnleder W Mühlenberg R Ruckdeschel Legionellen - ein aktives Problem der Sanitärhygiene <num> Auflage expert-Verlag ISBN <num>-<num>-<num>-<num>-<num> S <num>
+H J Gitelman Physiology of Aluminum in Man In Aluminum and Health CRC Press <num> ISBN <num>-<num>-<num>-<num> S <num>
+Bundesinstitut für Risikobewertung Hrsg
+PDF <num> kB <num> Juli <num> Bundesinstitut für Risikobewertung Hrsg
+PDF <num> kB <num> Februar <num>
+The Alzheimers Society Abgerufen am <num> Januar <num> H Lüllmann K Mohr M Wehling L Hein Pharmakologie und Toxikologie Thieme Verlag <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
+auf staufenbielde
+PDF S <num> Hans Daxbeck Adolf Merl Eva Ritter Paul H Brunner Analyse der Flüsse des lizenzierten Aluminiums in Österreich Technische Universität Wien Institut für Wassergüte und Abfallwirtschaft <num> rmaat PDF International Aluminium Journal Nr <num> <num> S <num> ff International Aluminium Journal Nr <num> <num> S <num> Uwe Kerkow Jens Martens Axel Müller
+PDF Aachen Bonn Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> Manfred Sietz Stefan Seuring Ökobilanzierung in der betrieblichen Praxis Eberhard Blottner Taunusstein <num> S <num>
+In The Economist <num> J Strähle E Schweda Jander
+Blasius - Lehrbuch der analytischen und präparativen anorganischen Chemie <num> Auflage Hirzel Stuttgart <num> ISBN <num>-<num>-<num>-<num> S <num>
+Antimon
+von lateinisch Antimonium vermutlich von arabisch al-ithmîdun
+Antimonsulfid bzw Stibnit ist ein chemisches Element mit dem Elementsymbol Sb von
+Grau-Spießglanz und der Ordnungszahl <num> Im Periodensystem steht es in der <num> Periode und der <num> Hauptgruppe bzw <num> IUPAC-Gruppe oder Stickstoffgruppe
+In der stabilen Modifikation ist es ein silberglänzendes und sprödes Halbmetall
+Name Geschichte
+Es wird auch vermutet dass der Name auf das spätgriechische anthemon dt Blüte zurückgeht
+Damit sollten die stängelartigen Kristalle von Antimonsulfid beschrieben werden die büschelförmig erschienen und wie eine Blüte aussähen
+Im <num> Jahrhundert findet sich der lateinische Begriff für die mineralische Arzneidroge antimonium
+zur innerlichen Therapie von Krankheiten dann bei Constantinus Africanus
+Im <num> Jahrhundert ging der Name Antimon als Bezeichnung auf das Metall über
+Die koptische Bezeichnung für das Schminkpuder Antimonsulfid ging über das Griechische in das Lateinische stibium über
+Die vom schwedischen Mediziner und Chemiker Jöns Jakob Berzelius Vater der modernen Chemie benutzte Abkürzung Sb wird noch heute als Elementsymbol genutzt
+Eine späte legendäre Volksetymologie die von Samuel Johnson in seinem Wörterbuch verewigt wurde besagt dass der deutsche Mönch Basilius Valentinus die Beobachtung machte dass Schweine durch die Aufnahme von Antimon schnell fett wurden
+Er probierte dies auch an seinen Ordensbrüdern aus woraufhin diese allerdings starben sodass der Begriff antimoine antimönchisch geprägt wurde aus dem später Antimon entstanden sei
+Als Typlokalität für gediegenes Antimon gilt die Silbermine in der schwedischen Gemeinde Sala im Västmanland Allerdings war metallisches Antimon schon den Chinesen und Babyloniern bekannt
+Einige seiner Verbindungen wurden schon in der Bronzezeit als Zuschlag zu Kupfer verwendet um Bronze herzustellen Funde von Velem-St
+Vid in Ungarn
+Vorkommen
+DateiAntimony-<num>jpg Antimon ist ein selten vorkommendes Element
+Da es in der Natur auch gediegen das heißt in elementarer Form gefunden werden kann wird es von der International Mineralogical Association IMA unter der System-Nr <num>CA<num> als Mineral anerkannt
+Weltweit konnte gediegenes Antimon bisher Stand <num> an rund <num> Fundorten nachgewiesen werden
+So unter anderem in mehreren Regionen von Australien in den bolivianischen Departements La Paz und Potosí Minas Gerais in Brasilien Schwarzwald Fichtelgebirge Oberpfälzer Wald Odenwald und im Harz in Deutschland Seinäjoki in Finnland mehreren Regionen von Frankreich Lombardei Piemont Sardinien und Trentino-Südtirol in Italien einigen Regionen von Kanada einigen Regionen von Österreich Ost- und Westsibirien und Ural in Russland neben Västmanland noch Dalarna Gästrikland Närke Södermanland Värmland und Västerbotten in Schweden in einigen Regionen der Slowakei Böhmen und Mähren in Tschechien sowie in vielen Regionen der USA Eine der weltweit bedeutendsten Lagerstätten für gediegen Antimon und Antimonerze ist der Murchison greenstone belt in der Murchison Range von Südafrika
+Bisher sind <num> Antimon-Minerale bekannt Stand <num> Industriell genutzt wird überwiegend das Sulfid-Mineral Stibnit Sb<num>S<num> Grauspießglanz mit einem Gehalt von maximal <num>
+Sb
+Das Mineral mit dem höchsten Sb-Gehalt in einer chemischen Verbindung ist die natürliche Antimon-Arsen-Legierung Paradocrasit max <num>
+Allerdings kommt sie mit nur drei Fundorten im Gegensatz zum Stibnit rund <num> Fundorte sehr viel seltener vor
+Weitere Quellen für Antimon sind die Minerale Valentinit Sb<num>O<num> Weißspießglanz Breithauptit NiSb Antimonnickel Nickelantimonid Kermesit Sb<num>S<num>O Rotspießglanz und Sb<num>S<num> Goldschwefel
+Gewinnung und Darstellung
+DateiAntimon - Trend Förderungsvg Technisch wird Antimon aus dem Antimonglanz gewonnen
+Ein Verfahren beruht auf dem Abrösten und der Reduktion mit Kohlenstoff Röstreduktionsverfahren
+Eine andere Möglichkeit besteht darin die Reduktion mit Eisen durchzuführen Niederschlagsverfahren
+Weltweit wurden zu Beginn des <num> Jahrhunderts zwischen <num> und <num> Tonnen pro Jahr an Antimon gefördert
+Seit <num> hat sich damit die Fördermenge mehr als verzehnfacht
+<num>
+der Antimonproduktion findet in China statt Stand <num>
+Eigenschaften
+Modifikationen
+Antimon kann in drei verschiedenen Modifikationen auftreten wobei metallisches bzw graues Antimon die beständigste Modifikation ist
+Unter Normalbedingungen kristallisiert Antimon trigonal in rhomboedrischer Aufstellung in der nach der Hermann-Mauguin-Symbolik beschriebenen Raumgruppe
+mit den Gitterparametern a
+<num> pm und c
+<num> pm sowie sechs Formeleinheiten pro Elementarzelle
+Durch Abschrecken von Antimondampf an kalten Flächen entsteht amorphes schwarzes und sehr reaktives Antimon welches sich durch Erhitzen wieder in metallisches Antimon umwandelt
+Durch elektrolytische Herstellung entsteht explosives Antimon das beim Ritzen explosionsartig aufglühend und funkensprühend in metallisches Antimon übergeht
+Diese Form enthält jedoch immer etwas Chlor und kann nicht als Modifikation betrachtet werden Gelbes Antimon ist ebenfalls keine eigenständige Modifikation sondern eine hochpolymere chemische Verbindung mit Wasserstoff
+Physikalische Eigenschaften
+Metallisches Antimon ist silberweiß stark glänzend blättrig-grobkristallin
+Es lässt sich aufgrund seiner Sprödigkeit leicht zerkleinern
+Elektrische und thermische Leitfähigkeit sind gering
+Chemische Eigenschaften
+Mit naszierendem Wasserstoff reagiert Antimon zum instabilen Antimonhydrid SbH<num>
+Von Luft und Wasser wird Antimon bei Raumtemperatur nicht angegriffen
+Oberhalb des Schmelzpunkts verbrennt es in Luft mit bläulich-weißer Flamme zu AntimonIII-oxid
+In heißen konzentrierten Mineralsäuren löst es sich auf
+Mit den Halogenen reagiert es schon bei Raumtemperatur heftig zu den entsprechenden Halogeniden
+In Verbindungen liegt Antimon überwiegend in den Oxidationsstufen <num> und <num> vor
+In Metallantimoniden wie Kaliumantimonid K<num>Sb bildet es Sb<num>--Ionen
+Isotope
+Es existieren zwei stabile Antimon-Isotope <num>Sb und <num>Sb
+Verwendung
+Legierungen
+Der überwiegende Teil des hergestellten Antimons wird zu Legierungen verarbeitet und zeigt dabei folgende Eigenschaften
+Es dient zur Härtung von Blei- und Zinnlegierungen
+Im Gegensatz zu den meisten anderen Metallen dehnt es sich beim Abkühlen der Schmelze aus infolge Umwandlung in eine andere Modifikation Der Antimongehalt kann so eingestellt werden dass solche Legierungen beim Abkühlen nicht schrumpfen oder sich sogar etwas ausdehnen bei in Gießformen hergestellten Teilen presst sich das Metall dadurch beim Erstarren in alle Ecken und Winkel so dass auch komplizierte Formen und stark gemusterte Oberflächen lunkerfrei hergestellt werden können
+Wichtige Legierungen
+Blei-Antimon-Legierungen Hartblei Letternmetall Lagermetall Akkumulatoren-Blei Bleimantel für Erdkabel
+Zinn-Antimon-Legierungen Britanniametall Lagermetall
+Herstellung von Halbleitern z B
+durch Dotierung von Silicium zur Herstellung von III-V-Verbindungshalbleitern
+Zinn-Antimon-Kupferlegierungen Babbit-Metall für Lagermetalle
+Zinn-Antimon-Kupfer-Bleilegierungen für Zinngeschirr und andere Gebrauchsartikel aus Zinn
+so genanntes Lötzinn oder Weichlot
+Aluminium-Antimon Gallium-Antimon Indium-Antimon für Infrarot- und Hall-Effekt-Geräte
+Schrumpffreie Antimon-Legierungen für Präzisionsguss
+Medizin
+Antimon bzw ein aus Antimonerz gewonnenes Präparat wurde im <num> und <num> Jahrhundert zu einem iatrochemischen Leitarzneimittel war aber - wie auch andere paracelsische Medikamente - umstritten und in Frankreich zwischen <num> und <num> auch verboten
+Brechweinstein wurde lange als brechreizerregendes Mittel verwendet Antimonpille heute wird es noch manchmal verwendet um den Mageninhalt von Vögeln zu untersuchen
+Sowohl Schistosomiasis als auch Trypanosomen
+wurden beginnend Anfang des <num> Jahrhunderts mit Brechweinstein Kaliumantimonyltartrat bekämpft
+Brechweinstein wurde hergestellt indem man für einen Tag Wein in einem Antimonbecher lagerte und diesen dann austrank
+Inzwischen kommen effektivere und verträglichere Medikamente zur Anwendung
+Antimonpräparate werden meist als weniger toxische pentavalente Formen zur medikamentösen Therapie der Leishmaniose
+und Schistosomiasis eingesetzt allerdings in entwickelten Ländern nicht mehr als Mittel der ersten Wahl
+Hierbei hemmt Antimon das Enzym Phosphofructokinase das den geschwindigkeitsbestimmenden Schritt der Glykolyse darstellt
+Weiteres
+DateiStreichholzjpg
+Bestandteil von Sprengstoffzündern und bleihaltiger Munition
+Antimontrisulfid in Bremsbelägen von Fahrzeugen
+AntimonV-sulfid
+zur Herstellung Vulkanisieren von rotem Kautschuk Beispiel Labor-Gummischläuche
+als roter Bestandteil des Zündkopfes in Streichhölzern
+früher als Augenschminken und in der Augenheilkunde Augenerweiterer
+Antimonchromat als gelbes Farbpigment
+Antimonoxide Katalysator zur Herstellung von Polyester und PET AntimonIII-oxid
+als Weißpigment zur Färbung von Polystyrol Polyethylen und Polypropylen
+Herstellung weißer Glasuren und Fritten Läuterung von Bleiglas
+mit Zinn dotiert als transparent-leitfähige Beschichtung ATO Antimon-Tin-Oxide beispielsweise auf Gläsern zur Herstellung von Displays oder in elektrisch leitfähigen Pigmenten Minatec für Fußbodenbeläge zur Ableitung elektrostatischer Aufladungen
+in Pigmenten Lazerflair für die Laser-Markierung von Kunststoffteilen wegen der starken Absorption von Infrarot-Strahlung üblicher Markierungslaser NdYAG
+in Tarnanstrichen wegen der starken Infrarot-Absorption
+als Flammschutzmittel und als Bestandteil von flammfesten und flammhemmenden Farben Kunststoffen und Textilien für Kabelumhüllungen Autositzbezüge Vorhangstoffe Kinderbekleidung u Ä
+Antimonsalze als Bestandteil von Pestiziden Beizen und Feuerwerksartikeln
+Scheidemittel für Gold Zur Ausfällung von Silber aus Goldschmelze
+Toxizität
+Antimon kann bereits bei Ingestion von <num> bis <num> mg tödlich sein
+In der Toxikologie sind drei Antimon-Formen bekannt von denen das gasförmige Antimonhydrid Stiban SbH<num> die gefährlichste Form ist die eine massive Hämolyse induziert
+Nach der Toxizität folgt Brechweinstein mit dreiwertigem trivalentem Antimon während fünfwertiges Antimon am wenigsten toxisch ist
+Das trivalente Antimon wird innerhalb der ersten zwei Stunden nach der Einnahme zu <num>
+in rote Blutkörperchen aufgenommen und damit vorwiegend in stark durchbluteten Organen angereichert
+Die Exkretion erfolgt vorwiegend durch Bindung an Glutathion über die Galle mit entsprechend hohem enterohepatischen Kreislauf und nur ein geringer Teil wird über die Nieren ausgeschieden
+Kaliumantimonyltartrat wird zu <num>
+innerhalb des ersten Tages nach Aufnahme ausgeschieden die übrigen <num>
+aufgrund einer langsameren Eliminationskinetik über <num> Tage
+Es wird vermutet dass Antimon ähnlich wie Arsen die Funktion des Pyruvatdehydrogenase-Komplexes hemmt und somit zu einem Mangel des intrazellulären Energieträgers Adenosintriphosphat ATP führt
+Dabei kommt es zur Bildung von Chelatkomplexen zwischen dem Antimon und Thiol-Gruppen der entsprechenden Enzyme
+Im Körper wirkt es in zahlreichen Organen toxisch so im Verdauungstrakt in der Leber in den Nieren im Herz und im Zentralnervensystem
+Die höchste Konzentration erreicht Antimon in der Leber wo es zu einer Hepatitis bis hin zum Leberversagen kommen kann
+Am Herzen kommt es zu EKG-Veränderungen mit Inversion und Verminderung der T-Welle und verlängertem QT-Intervall
+Ein akutes Nierenversagen kann zur temporären oder permanenten Hämodialyse führen
+Therapeutisch erfolgt bei einer Antimon-Vergiftung neben unterstützenden Maßnahmen wie Infusionstherapie sowohl zum Ausgleich des Flüssigkeitsverlustes durch das Erbrechen als auch zum Schutz der Nieren und engmaschiger Überwachung der Vitalfunktionen und des EKGs die Gabe von Aktivkohle N-Acetylcystein als Vorläufer des Glutathions zur vermehrten Sekretion und eines Chelatbildners z B
+Dimercaprol
+Ergebnisse aus Untersuchungen deuten darauf hin dass Antimonverbindungen Haut und Schleimhäute reizen
+Diese Verbindungen lösen sich vermutlich aus Kunststoff und Textilien
+Sicherheitshinweise und Grenzwerte
+Von den Antimonverbindungen sind seitens der EU Antimonfluorid als giftig T und die Chloride als ätzend C eingestuft außerdem als umweltgefährlich N alle anderen Antimonverbindungen als gesundheitsschädlich Xn und umweltgefährlich N Antimon selbst ist dort nicht aufgeführt laut Sicherheitsdatenblatt ist es als reizend gekennzeichnet
+Die Internationale Agentur für Krebsforschung IARC stuft AntimonIII-oxid als möglicherweise krebserzeugende Substanz ein
+In der EU gilt für Trinkwasser ein Grenzwert von <num> µgl
+Untersuchungen von in PET-Flaschen abgefüllten Fruchtsäften für die keine Richtlinien existieren ergaben Antimonkonzentrationen bis zu <num> µgl in unverdünnten Saftkonzentraten
+Antimon wurde <num> von der EU gemäß der Verordnung EG Nr <num><num> REACH im Rahmen der Stoffbewertung in den fortlaufenden Aktionsplan der Gemeinschaft CoRAP aufgenommen
+Hierbei werden die Auswirkungen des Stoffs auf die menschliche Gesundheit bzw die Umwelt neu bewertet und ggf Folgemaßnahmen eingeleitet
+Ursächlich für die Aufnahme von Antimon waren die Besorgnisse bezüglich Exposition von Arbeitnehmern hoher aggregierter Tonnage hohes Risikoverhältnis Risk Characterisation Ratio RCR und weit verbreiteter Verwendung sowie der möglichen Gefahr durch krebsauslösende Eigenschaften
+Die Neubewertung läuft seit <num> und wird von Deutschland durchgeführt
+Nachweis
+DateiFlammenfärbungSbpng Vorproben
+Flammenfärbung Flamme fahlblau wenig charakteristische Phosphorsalzperle Farblos gestört durch alle Elemente die eine farbige Perle erzeugen
+Nachweisreaktion
+Reduktion durch unedle Metalle zum Beispiel Eisen Zink oder Zinn
+In nicht zu sauren Lösungen reduzieren unedle Metalle Antimon-Kationen SbIII SbV und SbIIIV zu metallischem Antimon
+<num> Sb<num>
+<num> Fe
+<num> Sb
+<num> Fe<num>
+Die auf Antimon zu prüfende Substanz wird in salzsaure Lösung gegeben und mit Eisenpulver versetzt
+Es entsteht ein schwarzer flockiger Niederschlag aus metallischem Antimon in der Lösung oder direkt am Eisen
+Auch der Nachweis an einem Eisennagel ist möglich
+Dabei ist eine schwarze Ablagerung am Nagel ein Nachweis für Antimon welches sich hier elementar niedergeschlagen hat
+Die Marshsche Probe gestattet einen eindeutigen Nachweis von Antimon
+Wenn die pyrolytisch abgeschiedene Substanz dunkel glänzender Spiegel sich nicht in ammoniakalischem Wasserstoffperoxid löst sind Arsen und Germanium als mögliche Alternativen ausgeschlossen
+Die hochempfindliche Bestimmung winziger Antimonspuren erfolgt durch die Hydridtechnik der Atomspektrometrie
+Hierbei wird im Prinzip die Marshsche Probe mit der Atomabsorptionsspektrometrie gekoppelt
+Die Matrixeffekte der Probelösung lassen sich dadurch sehr wirksam unterdrücken
+Eine weitere Methode besteht darin eine wässrige Lösung in der Antimonionen enthalten sind mit Rhodamin-B-Lösung zu versetzen
+Es bildet sich ein farbiger Komplex der mit Isopropylether extrahierbar ist
+Dieser Nachweis ist allerdings recht unspezifisch da auch Gold- Cadmium- Gallium Thallium- Uran- und Wolfram-ionen farbige Komplexe bilden
+Verbindungen
+Antimonwasserstoff auch Monostiban SbH<num> genanntGiftiges Gas das sich aus Antimon und einwirkenden Säuren bildet
+Distiban Sb<num>H<num>
+Halogenverbindungen
+AntimonV-fluorid SbF<num> bildet nach VSEPR eine quadratische Pyramide aus und hybridisiert dabei zu sp<num>d
+AntimonV-chlorid SbCl<num>
+AntimonIII-fluorid SbF<num>
+AntimonIII-chlorid SbCl<num>
+AntimonIII-bromid SbBr<num>
+AntimonIII-iodid SbI<num>
+Sauerstoffverbindungen
+AntimonIII-oxid Antimontrioxid Sb<num>O<num>
+AntimonIIIV-oxid Antimontetroxid Sb<num>O<num>
+AntimonV-oxid Antimonpentaoxid Sb<num>O<num>
+antimonige SäureAntimontrihydroxid H<num>SbO<num>SbOH<num>
+antimonige SäureAntimonIII-Säure SbOOH bzw HSbO<num>
+Antimonsäure HSbOH<num>
+Schwefelverbindungen
+Antimontrisulfid auch Antimonglanz genannt Sb<num>S<num>Grauschwarze metallisch glänzende Stängel
+Ausgangsstoff zur Herstellung metallischen Antimons
+Löslich in starken Säuren
+Verwendung für Streichhölzer Rubingläser und Tarnanstriche Reflexion von IR-Licht
+Antimonpentasulfid früher als Goldschwefel bezeichnet Sb<num>S<num>
+Sonstige Verbindungen
+AntimonV-chloridfluorid SbCl<num>F Katalysator für die Herstellung von Polytetrafluorethylen Teflon
+Aluminiumantimonid AlSb
+Galliumantimonid GaSb
+Indiumantimonid InSb
+Literatur
+Willem Frans Daems Stimmi - Stibium - Antimon
+Eine substanzhistorische Betrachtung
+Weleda-Schriftenreihe <num>
+Arlesheim Schwäbisch Gmünd <num>
+Weblinks
+Mineralienatlas Antimon Wiki
+Chemie im Alltag Mozart - Opfer einer Antimonvergiftung
+Einzelnachweise
+Willem F Daems Zu Helmut Gebelein Alchemie München Eugen Diederichs <num> In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num> Doris Schwarzmann-Schafhauser Antimonstreit In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num> S <num> Mindat - Sala Silver Mine Sala Västmanland Sweden IMACNMNC List of Mineral names - Antimony englisch PDF <num> MB S <num> Mindat - Localities for Antimony englisch
+auf wwwgeoscienceorgza englisch Webmineral - Mineral Species sorted by the element Sb Antimony Mindat - Paradocrasite Mindat - Stibnite ddcartetv Lautenschläger u a Taschenbuch der Chemie
+Verlag Harri Deutsch Frankfurt am Main <num> Ulrich Arndt Der Magnet der Weisen - Alchemistische Transmutation des Antimon In Paracelsus November <num>
+S <num>-<num> Online-Version Wolf-Dieter Müller-Jahncke Christoph Friedrich Geschichte der Arzneimitteltherapie Deutscher Apothekerverlag Stuttgart <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> Doris Schwarzmann-Schafhauser Antimonstreit In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num> S <num> Katja Bauer
+In
+badische-zeitungde
+<num> Juni <num> Wendy Macías Konstantopoulos Michele Burns Ewald Daniel S Pratt Case <num>-<num> A <num>-Year-Old Man with Intractable Vomiting after Ingestion of an Unknown Substance In
+New England Journal of Medicine <num> <num> S <num>-<num> Bundesamt für Gesundheit Schweiz BAG
+PDF <num> August <num> Hollemann-Wiberg Lehrbuch der anorganischen Chemie <num> Auflage S <num>
+Argon griechisch
+träge ist ein chemisches Element mit dem Symbol Ar bis <num> nur A und der Ordnungszahl <num> Im Periodensystem steht es in der <num> Hauptgruppe bzw der <num> IUPAC-Gruppe und zählt daher zu den Edelgasen
+Wie die anderen Edelgase ist es ein farbloses äußerst reaktionsträges einatomiges Gas
+In vielen Eigenschaften wie Schmelz- und Siedepunkt oder Dichte steht es zwischen dem leichteren Neon und dem schwereren Krypton
+Argon ist das häufigste auf der Erde vorkommende Edelgas der Anteil an der Atmosphäre beträgt etwa <num>
+Damit ist Argon der dritthäufigste Bestandteil der Erdatmosphäre nach Stickstoff und Sauerstoff
+Dies ist großteils auf den Zerfall des Kaliumisotops <num>K zurückzuführen bei dem <num>Ar entsteht
+Argon war das erste Edelgas das als Stoff entdeckt und gewonnen wurde daher der Name der im Grunde zu jedem Edelgas passt
+Helium von griechisch helios für Sonne wurde vorher lediglich spektroskopisch im Sonnenlicht sowie in irdischen Proben nachgewiesen und Neon erst später entdeckt
+Argon wurde <num> von Lord Rayleigh und William Ramsay durch fraktionierte Destillation von flüssiger Luft gefunden
+Als preiswertestes Edelgas wird Argon in großen Mengen als Schutzgas etwa beim Schweißen und in der Produktion von manchen Metallen aber auch als Füllgas von Glühlampen verwendet
+Geschichte
+DateiJohn William Struttjpg Einen ersten Hinweis auf das später entdeckte Argon fand Henry Cavendish der <num> die Reaktivität der Luft erforschte
+Er erzeugte elektrische Entladungen in einer bestimmten Menge Luft die mit Sauerstoff im Verhältnis von <num> angereichert war
+Stickstoff und Sauerstoff reagierten miteinander und die entstandenen Stickoxide konnten ausgewaschen werden
+Dabei blieb stets ein kleiner Rest nicht-reagierten Gases zurück
+Cavendish erkannte jedoch nicht dass es sich dabei um ein anderes Element handelte und setzte seine Experimente nicht fort
+Nachdem John William Strutt <num> Baron Rayleigh <num> die Dichte von aus Luft isoliertem Stickstoff bestimmt hatte fiel ihm auf dass aus Ammoniak gewonnener Stickstoff eine niedrigere Dichte aufwies
+Es gab verschiedene Spekulationen zu diesem Befund so meinte James Dewar es müsse sich um ein N<num> also ein Stickstoff-Analogon zu Ozon handeln
+Rayleigh wiederholte Cavendishs Experimente indem er in einer luftgefüllten Glaskugel elektrische Funken erzeugte und so Stickstoff und Sauerstoff zur Reaktion brachte
+Nach Bestätigung von Cavendishs Ergebnis eines unreaktiven Rückstandes untersuchte William Ramsay diesen ab <num> durch Überleitung über heißes Magnesium genauer
+Da Magnesium mit Stickstoff zum Nitrid reagiert konnte er dem Gemisch weiteren Stickstoff entziehen
+Dabei stellte er eine Erhöhung der Dichte fest und fand schließlich ein bislang unbekanntes reaktionsträges Gas Am <num> Januar <num> gaben Ramsay und Rayleigh schließlich die Entdeckung des neuen Elements bekannt das sie nach dem altgriechischen argos träge Argon nannten Als William Ramsay ab <num> das aus der Luft isolierte Argon weiter untersuchte entdeckte er darin drei weitere Elemente die Edelgase Neon Krypton und Xenon
+Erste technische Anwendungen fand das Gas in der Elektroindustrie Es wurden unter anderem Gleichrichter auf der Basis der Glimmentladung in Argon hergestellt die sogenannten
+Tungar-Röhren
+Vorkommen
+Argon zählt im Universum zu den häufigeren Elementen in seiner Häufigkeit ist es vergleichbar mit Schwefel und Aluminium Es ist im Universum nach Helium und Neon das dritthäufigste Edelgas
+Dabei besteht das primordiale Argon das etwa in der Sonne oder Gasplaneten wie Jupiter gefunden wird hauptsächlich aus den Isotopen <num>Ar und <num>Ar während das dritte stabile Isotop <num>Ar dort nur in geringer Menge vorkommt
+Das Verhältnis von <num>Ar zu <num>Ar beträgt etwa <num>
+Auf der Erde ist Argon dagegen das häufigste Edelgas
+Es macht <num>
+des Volumens der Atmosphäre ohne Wasserdampf aus und ist damit nach Stickstoff und Sauerstoff der dritthäufigste Atmosphärenbestandteil Die Zusammensetzung des terrestrischen Argons unterscheidet sich erheblich von derjenigen des primordialen Argons im Weltall
+Es besteht zu über <num>
+aus dem Isotop <num>Ar das durch Zerfall des Kaliumisotops <num>K entstanden ist
+Die primordialen Isotope sind dagegen nur in geringen Mengen vorhanden
+Da das Argon durch den Kaliumzerfall in der Erdkruste entsteht findet man es auch in Gesteinen
+Beim Schmelzen von Gesteinen im Erdmantel gast das Argon aber auch das bei anderen Zerfällen entstehende Helium aus
+Es reichert sich daher vorwiegend in den Basalten der ozeanischen Erdkruste an Aus den Gesteinen wird das Argon an das Grundwasser abgegeben
+Daher ist in Quellwasser vor allem wenn es aus größerer Tiefe kommt Argon gelöst
+Gewinnung und Darstellung
+Die Gewinnung des reinen Argons erfolgt ausschließlich aus der Luft in der Regel im Rahmen der Luftverflüssigung im Linde-Verfahren
+Das Argon wird dabei nicht in der Haupt-Rektifikationskolonne des Verfahrens von den Hauptluftbestandteilen getrennt sondern in einer eigenen Argon-Kolonne
+In dieser wird durch Rektifikation zunächst Rohargon hergestellt das noch etwa <num>-<num>
+Sauerstoff und <num>
+Stickstoff enthält
+Anschließend wird das Rohargon in weiteren Stufen gereinigt
+Das Gasgemisch wird zunächst auf Raumtemperatur erwärmt und auf <num>-<num> bar verdichtet
+Um den restlichen Sauerstoff zu entfernen wird danach Wasserstoff eingespritzt der an Edelmetall-Katalysatoren mit dem Sauerstoff zu Wasser reagiert
+Nachdem dieses entfernt wurde wird in einer weiteren Kolonne das Argon das sich am unteren Ende der Kolonne anreichert vom restlichen Stickstoff getrennt so dass Argon mit einer Reinheit von <num>
+Argon <num> produziert werden kann
+Weitere Quellen für die Gewinnung von Argon sind die Produktion von Ammoniak im Haber-Bosch-Verfahren sowie die Synthesegasherstellung etwa zur Methanolproduktion
+Bei diesen Verfahren die Luft als Ausgangsstoff nutzen reichern sich Argon und andere Edelgase im Produktionsprozess an und können aus dem Gasgemisch isoliert werden
+Wie beim Linde-Verfahren werden auch hier die verschiedenen Gase durch Adsorption oder Rektifikation voneinander getrennt und so reines Argon gewonnen
+Eigenschaften
+Physikalische Eigenschaften
+DateiArgon ice <num>jpg DateiFace-centered cubicsvg
+Argon ist bei Normalbedingungen ein einatomiges farbloses und geruchloses Gas das bei <num> K -<num> C kondensiert und bei <num> K -<num> C erstarrt
+Wie die anderen Edelgase außer dem Helium kristallisiert Argon in einer kubisch dichtesten Kugelpackung mit dem Gitterparameter a
+<num> pm bei <num> K
+Wie alle Edelgase besitzt Argon nur abgeschlossene Schalen Edelgaskonfiguration
+Dadurch lässt sich erklären dass das Gas stets einatomig vorliegt und die Reaktivität gering ist
+Mit einer Dichte von <num> kgm<num> bei <num> C und <num> hPa ist Argon schwerer als Luft es sinkt also ab
+Im Phasendiagramm liegt der Tripelpunkt bei <num> K und <num> hPa der kritische Punkt bei <num> K <num> kPa sowie einer kritischen Dichte von <num> gcm<num>
+In Wasser ist Argon etwas löslich
+In einem Liter Wasser können sich bei <num> C und Normaldruck maximal <num> g Argon lösen
+Chemische Eigenschaften
+Als Edelgas reagiert Argon fast nicht mit anderen Elementen oder Verbindungen
+Bislang ist nur das experimentell dargestellte Argonfluorohydrid HArF bekannt das durch Photolyse von Fluorwasserstoff in einer Argonmatrix bei <num> K gewonnen wird und anhand neuer Linien im Infrarotspektrum identifiziert wurde
+Oberhalb von <num> K zersetzt es sich Nach Berechnungen sollten weitere Verbindungen des Argons metastabil sein und sich verhältnismäßig schwer zersetzen diese konnten jedoch experimentell bislang nicht dargestellt werden
+Beispiele hierfür sind das Chloranalogon des Argonfluorohydrides HArCl aber auch Verbindungen bei denen das Proton durch andere Gruppen ersetzt ist etwa FArCCH als organische Argonverbindung und FArSiF<num> mit einer Argon-Silicium-Bindung
+Argon bildet einige Clathrate in denen es physikalisch in Hohlräume eines umgebenden Kristalls eingeschlossen ist
+Bei -<num> C ist ein Argon-Hydrat stabil jedoch ist die Geschwindigkeit der Bildung sehr langsam da eine Umkristallisierung stattfinden muss
+Ist das Eis mit Chloroform gemischt bildet sich das Clathrat schon bei -<num> C Stabil ist auch ein Clathrat von Argon in Hydrochinon
+Isotope
+Insgesamt sind <num> Isotope sowie ein weiteres Kernisomer von Argon bekannt
+Von diesen sind drei nämlich die Isotope <num>Ar <num>Ar und <num>Ar stabil und kommen in der Natur vor
+Dabei überwiegt bei weitem <num>Ar mit einem Anteil von <num>
+am natürlichen irdischen Isotopengemisch
+<num>Ar und <num>Ar sind mit einem Anteil von <num>
+beziehungsweise <num>
+selten
+Von den instabilen Isotopen besitzen <num>Ar mit <num> Jahren und <num>Ar mit <num> Jahren die längsten Halbwertszeiten
+Alle anderen Isotope besitzen kurze Halbwertszeiten im Bereich von unter <num> ps bei <num>Ar bis <num> Tagen bei <num>Ar
+<num>Ar wird für die Altersbestimmung von Gesteinen genutzt Kalium-Argon-Datierung
+Dabei wird ausgenutzt dass instabiles <num>K das in diesen enthalten ist langsam zu <num>Ar zerfällt
+Je mehr Kalium zu Argon zerfallen ist desto älter ist das Gestein Das kurzlebige Isotop <num>Ar kann zur Überprüfung von Gasleitungen verwendet werden
+Durch das Durchleiten von <num>Ar kann die Leistungsfähigkeit einer Belüftung oder Dichtigkeit einer Leitung festgestellt werden
+Liste der Argon-Isotope
+Biologische Bedeutung
+Wie die anderen Edelgase hat Argon auf Grund der Reaktionsträgheit keine biologische Bedeutung und ist auch nicht toxisch
+In höheren Konzentrationen wirkt es durch Verdrängung des Sauerstoffs erstickend Bei Drücken von mehr als <num> bar wirkt es narkotisierend
+Verwendung
+DateiArgonjpg Als günstigstes und in großen Mengen verfügbares Edelgas wird Argon in vielen Bereichen verwendet
+Die Produktion betrug <num> weltweit etwa <num> Milliarden m bzw <num> km Der größte Teil des Argons wird als Schutzgas verwendet
+Es wird immer dann genutzt wenn der billigere Stickstoff nicht anwendbar ist
+Dazu zählen vor allem Schweißverfahren für Metalle die mit Stickstoff bei hohen Temperaturen reagieren etwa Titan Tantal und Wolfram
+Auch beim Metallinertgasschweißen und Wolfram-Inertgasschweißen die etwa beim Schweißen von Aluminiumlegierungen oder hoch legierten Stählen angewendet werden dient Argon als Inertgas
+Weiterhin wird es in der Metallurgie als Schutzgas etwa für die Produktion von Titan hochreinem Silicium oder der Schmelzraffination sowie zum Entgasen von Metallschmelzen genutzt
+Argon ist ein Lebensmittelzusatzstoff E <num> und dient als Treib- und Schutzgas bei der Verpackung von Lebensmitteln und der Weinherstellung
+Argon wird als gasförmiges Löschmittel vorwiegend für den Objektschutz vor allem bei elektrischen und EDV-Anlagen eingesetzt und wirkt dabei durch Sauerstoffverdrängung
+Für diesen Zweck wird reines Argon oder ein Gasgemisch zusammen mit Stickstoff verwendet
+In der Analytik wird Argon als Träger- und Schutzgas für die Gaschromatographie und das induktiv gekoppelte Plasma ICP-MS ICP-OES verwendet
+Glühlampen werden häufig mit Argon-Stickstoff-Gemischen gefüllt weil eine Gasfüllung die Sublimation des Glühfadens vermindert
+Argon hat dabei eine geringere Wärmeleitfähigkeit als leichtere Gase ist aber preiswerter als andere schwerere und damit noch geringer wärmeleitende Gase wie Krypton oder Xenon
+Ein Vorteil der geringeren Wärmeleitfähigkeit ist eine höhere mögliche Glühtemperatur und damit höhere Lichtausbeute
+Ebenfalls wegen der geringen Wärmeleitfähigkeit wird es als Füllgas für Isolierglasscheiben verwendet
+Auch in Gasentladungslampen dient Argon als Leuchtgas mit einer typischen violetten Farbe
+Wird etwas Quecksilber dazugegeben ändert sich die Farbe ins Blaue
+Weiterhin ist Argon das Lasermedium in Argon-Ionen-Lasern
+Im Bereich der Stahlerzeugung kommt Argon eine besonders wichtige Rolle im Bereich der Sekundärmetallurgie zu
+Mit der Argon-Spülung kann die Stahllegierung entgast und gleichzeitig homogenisiert werden speziell wird dabei der unerwünschte gelöste Stickstoff aus der Schmelze entfernt
+Beim Tauchen wird Argon - insbesondere bei der Nutzung des Heliumhaltigen Trimix als Atemgas - dazu verwendet um Trockentauchanzüge zu füllen bzw damit zu tarieren
+Hierbei wird ebenfalls die geringe Wärmeleitfähigkeit des Gases genutzt um das Auskühlen des Anzugträgers zu verzögern
+Seit Mai <num> ist Argon auf der Dopingliste der Welt-Anti-Doping-Agentur WADA
+Durch den bei der Inhalation von Argon entstehenden Sauerstoffmangel wird offensichtlich die Bildung von körpereigenem Erythropoetin EPO aktiviert
+Aus demselben Grund ist auch Xenon auf der Dopingliste
+Einzelnachweise
+Literatur
+P Häussinger R Glatthaar W Rhode H Kick C Benkmann J Weber H-J
+Wunschel V Stenke E Leicht H Stenger Noble Gases In
+Ullmanns Encyclopedia of Industrial Chemistry Wiley-VCH Weinheim <num> doi<num><num>a<num>_<num>
+Weblinks
+NA William H Brock Viewegs Geschichte der Chemie Vieweg Braunschweig <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> John Meurig Thomas Argon und das nichtinerte Paar Rayleigh und Ramsay In
+Angew Chem
+<num> <num> S <num>-<num> doi<num>ange<num>William Ramsay
+The Rare Gases of the Atmosphere Nobelpreisrede <num> Dezember <num> Fritz Von Schröter Die Bedeutung der Edelgase für die Elektrotechnik In Naturwissenschaften <num> <num> <num> S <num>-<num> doi<num>BF<num> A G W Cameron Abundances of the elements in the solar system In Space Science Reviews <num> <num> S <num>-<num> PDF P R Mahaffy H B Niemann A Alpert S K Atreya J Demick T M Donahue D N Harpold T C Owen Noble gas abundance and isotope ratios in the atmosphere of Jupiter from the Galileo Probe Mass Spectrometer In J Geophys Res <num> <num> S <num>-<num> AbstractDavid R Williams
+Earth Fact Sheet NASA Greenbelt Stand <num> Mai <num> Chris J Ballentine Geochemistry Earth holds its breath In
+Nature <num> <num> S <num>-<num> doi<num><num>a P Häussinger R Glatthaar W Rhode H Kick C Benkmann J Weber H-J Wunschel V Stenke E Leicht H Stenger Noble Gases In
+Ullmanns Encyclopedia of Industrial Chemistry Wiley-VCH Weinheim <num> doi<num><num>a<num>_<num> K Schubert Ein Modell für die Kristallstrukturen der chemischen Elemente In Acta Crystallographica Section B <num> <num> S <num>-<num> doi<num>S<num> A L Gosman R D McCarty J G Hust Thermodynamic Properties of Argon from the Triple Point to <num> K at Pressures to <num> Atmospheres In Nat Stand Ref Data Ser Nat Bur Stand <num> <num> NIST webbook Leonid Khriachtchev Mika Pettersson Nino Runeberg Jan Lundell Markku Räsänen A stable argon compound In Nature <num> <num> S <num>-<num> doi<num><num> Arik Cohen Jan Lundell R Benny Gerber First compounds with argon-carbon and argon-silicon chemical bonds In J Chem Phys <num> <num> S <num>-<num> doi<num><num> R M Barrer D J Ruzicka Non-stoichiometric clathrate compounds of water Part <num> - Kinetics of formation of clathrate phases In Transactions of the Faraday Society <num> <num> S <num>-<num> doi<num>TF<num> G Audi F G Kondev Meng Wang WJ Huang S Naimi The NUBASE<num> evaluation of nuclear properties In Chinese Physics C <num> <num> S <num>
+Volltext Sicherheitsdatenblatt Argon PDF <num> kB Linde AG Stand <num> Juni <num> Walter J Moore Dieter O Hummel Physikalische Chemie <num> Auflage de Gruyter <num> ISBN <num>-<num>-<num>-<num> S <num> Zusatzstoff-Zulassungsverordnung
+Jörg Niederstraßer
+Kapitel <num>
+PDF <num> kB Dissertation Universität Duisburg <num> Ausrüstung Argon
+bei dir-mcom abgerufen am <num> August <num>
+In Pharmazeutische Zeitung <num> Mai <num>
+Arsen
+ist ein chemisches Element mit dem Elementsymbol As und der Ordnungszahl <num> Im Periodensystem der Elemente steht es in der <num> Periode und der <num> Hauptgruppe bzw <num> IUPAC-Gruppe oder Stickstoffgruppe
+Arsen kommt selten gediegen vor meistens in Form von Sulfiden
+Es gehört zu den Halbmetallen da es je nach Modifikation metallische oder nichtmetallische Eigenschaften zeigt
+Umgangssprachlich wird auch das als Mordgift bekannte Arsenik meist einfach Arsen genannt
+Arsenverbindungen kennt man schon seit dem Altertum
+Als mutagenes Klastogen können Arsenverbindungen als Gift wirken welches Chromosomenaberrationen hervorrufen und somit karzinogene Wirkung besitzen kann
+Arsen wird zur Dotierung von Halbleitern und als Bestandteil von III-V-Halbleitern wie Galliumarsenid genutzt
+Die organische Arsenverbindung Arsphenamin Salvarsan galt trotz schwerer und schwerster Nebenwirkungen Anfang des <num> Jahrhunderts als Durchbruch in der Behandlung der Syphilis
+Heute wird Arsentrioxid als letzte Behandlungsoption in der Therapie der Promyelozytenleukämie angewendet
+Geschichte
+DateiAlbertusMagnusjpg Der Name Arsen geht unmittelbar auf
+zurück der antiken Bezeichnung des Arsenminerals Auripigment
+Sie findet sich schon bei Dioskurides im <num> Jahrhundert
+Die griechische Bezeichnung scheint ihrerseits ihren Ursprung im Altpersischen al-zarnik goldfarben Auripigment Arsen zu haben und gelangte wohl durch semitische Vermittlung ins Griechische
+Volksetymologisch wurde der Name fälschlicherweise vom gleichlautenden alt- und neu-griechischen Wort
+abgeleitet das sich etwa mit männlichstark übersetzen lässt
+Erst seit dem <num> Jahrhundert ist die Bezeichnung Arsen gebräuchlich
+Das Elementsymbol wurde <num> von Jöns Jakob Berzelius vorgeschlagen
+Der erste Kontakt von Menschen mit Arsen lässt sich aus dem <num> Jahrtausend v Chr nachweisen In den Haaren der im Gletschereis erhaltenen Mumie des volkstümlich Ötzi genannten Alpenbewohners ließen sich größere Mengen Arsen nachweisen was archäologisch als Hinweis darauf gedeutet wird dass der betroffene Mann in der Kupferverarbeitung tätig war - Kupfererze sind oft mit Arsen verunreinigt
+Im klassischen Altertum war Arsen in Form der Arsen-Sulfide Auripigment As<num>S<num> und Realgar As<num>S<num> bekannt die etwa von dem Griechen Theophrastos dem Nachfolger Aristoteles beschrieben wurden
+Auch der griechische Philosoph Demokrit hatte im <num> Jahrhundert v Chr nachweislich Kenntnisse über Arsenverbindungen
+Der Leidener Papyrus X aus dem <num> Jahrhundert nach Chr lässt darauf schließen dass sie benutzt wurden um Silber goldartig und Kupfer weiß zu färben
+Der römische Kaiser Caligula hatte angeblich bereits im <num> Jahrhundert nach Chr ein Projekt zur Herstellung von Gold aus dem goldgelben Auripigment in Auftrag gegeben
+Die Alchimisten die Arsen-Verbindungen nachweislich der Erwähnung im antiken Standardwerk
+Physica et Mystica
+kannten vermuteten eine Verwandtschaft mit Schwefel und Quecksilber
+ArsenIII-sulfid kam als Malerfarbe und Enthaarungsmittel zum Einsatz sowie zur äußerlichen als auch inneren Behandlung von Lungenkrankheiten
+DateiArsenic alchemical symbolsvg Im Mittelalter wurde Arsenik ArsenIII-oxid im Hüttenrauch staubbeladenes Abgas metallurgischer Öfen gefunden
+Albertus Magnus beschrieb um <num> erstmals die Herstellung von Arsen durch Reduktion von Arsenik mit Kohle
+Er gilt daher als Entdecker des Elements auch wenn es Hinweise darauf gibt dass das elementare Metall schon früher hergestellt wurde
+Paracelsus führte es im <num> Jahrhundert in die Heilkunde ein
+Etwa zur gleichen Zeit wurden Arsenpräparate in der chinesischen Enzyklopädie
+Pen-tsao Kang-mu
+des Apothekers Li Shi-zhen beschrieben
+Dieser Autor hebt insbesondere die Anwendung als Pestizid in Reisfeldern hervor
+Im <num> Jahrhundert wurde das gelbe Auripigment bei holländischen Malern als
+Königsgelb
+populär
+Da sich das Pigment über längere Zeiträume hinweg in ArsenIII-oxid umwandelt und von der Leinwand bröckelt entstehen Schwierigkeiten bei der Restaurierung
+Ab <num> wurden Arsenpräparate in Europa mit Erfolg als Beizmittel im Pflanzenschutz eingesetzt
+Diese Nutzung verbot man jedoch <num> wegen ihrer hohen Giftigkeit wieder
+Der Einsatz von Arsenzusätzen für den Bleiguss beruht auf der größeren Härte solcher Bleilegierungen typische Anwendung sind Schrotkugeln
+Obwohl die Giftigkeit und die Verwendung als Mordgift bekannt war ist Arsen im beginnenden <num> Jahrhundert eines der bedeutendsten Asthmamittel
+Grundlage sind anscheinend Berichte in denen den Chinesen nachgesagt wurde sie würden Arsen in Kombination mit Tabak rauchen um Lungen zu bekommen die stark wie Blasebälge seien
+Ebenfalls bis ins <num> Jahrhundert fanden Arsenverbindungen äußerlich und innerliche Anwendungen bei bösartigen Geschwülsten Hauterkrankungen und etwa in Form der Fowlerschen Tropfen bei Fieber
+Arsen wurde in Form von Kupferarsenaten in Farbmitteln wie dem Pariser Grün eingesetzt um Tapeten zu bedrucken
+Bei hoher Feuchtigkeit wurden diese Pigmente durch Schimmelpilzbefall in giftige flüchtige Arsenverbindungen umgewandelt die nicht selten zu chronischen Arsenvergiftungen führten
+Doch auch in Kriegen fand Arsen Verwendung Im Ersten Weltkrieg wurden Arsenverbindungen in chemischen Kampfstoffen Blaukreuz oder Lewisit eingesetzt
+Bei den Opfern bewirkten sie durch Angriff auf Haut und Lungen grausame Schmerzen und schwerste körperliche Schädigungen
+Vorkommen
+DateiArsen gediegen - St Andreasberg HarzJPG DateiArsenic-<num>jg<num>ajpg Arsen kommt in geringen Konzentrationen von bis zu <num> ppm praktisch überall im Boden vor
+Es ist in der Erdkruste ungefähr so häufig wie Uran oder Germanium
+In der kontinentalen Erdkruste kommt Arsen mit durchschnittlich <num> ppm vor wobei es durch seinen lithophilen Charakter
+Silikat liebend in der oberen Kruste angereichert ist <num> ppm gegenüber <num> ppm in der unteren Kruste damit liegt Arsen in der Tabelle der häufigsten Elemente an <num> Stelle
+Arsen Scherbenkobalt kommt in der Natur gediegen das heißt in elementarer Form vor und ist daher von der International Mineralogical Association IMA als eigenständiges Mineral anerkannt
+Gemäß der Systematik der Minerale nach Strunz <num> Auflage wird Arsen unter der System-Nr
+<num>CA<num> Elemente - Halbmetalle Metalloide und Nichtmetalle - Arsengruppen-Elemente <num> Auflage IB<num>-<num> eingeordnet
+Die im englischsprachigen Raum ebenfalls geläufige Systematik der Minerale nach Dana führt das Element-Mineral unter der System-Nr
+<num><num>
+Weltweit sind zurzeit Stand <num> rund <num> Fundorte für gediegenes Arsen bekannt In Deutschland wurde es an mehreren Fundstätten im Schwarzwald Baden-Württemberg im bayerischen Spessart und Oberpfälzer Wald im hessischen Odenwald in den Silberlagerstätten des Westerzgebirges Sachsen am Hunsrück Rheinland-Pfalz sowie im Thüringer Wald gefunden
+In Österreich trat Arsen an mehreren Fundstätten in Kärnten Salzburg und der Steiermark zutage
+In der Schweiz fand sich gediegen Arsen in den Kantonen Aargau und Wallis
+Weitere Fundorte sind in Australien Belgien Bolivien Bulgarien Chile China Finnland Frankreich Griechenland Irland Italien Japan Kanada Kasachstan Kirgisistan Madagaskar Malaysia Marokko Mexiko Mongolei Neuseeland Norwegen Österreich Peru Polen Rumänien Russland Schweden Slowakei Spanien Tschechien Ukraine Ungarn im Vereinigten Königreich Großbritannien und in den Vereinigten Staaten USA bekannt
+Weit häufiger kommt das Element allerdings in verschiedenen intermetallischen Verbindungen mit Antimon Allemontit und Kupfer Whitneyit sowie in verschiedenen Mineralen vor die überwiegend der Klasse der Sulfide und Sulfosalze angehören
+Insgesamt sind bisher Stand <num> <num> Arsenminerale bekannt Die höchsten Konzentrationen an Arsen enthalten dabei unter anderem die Minerale Duranusit ca <num>
+Skutterudit und Arsenolith jeweils ca <num>
+die allerdings selten zu finden sind
+Weit verbreitet sind dagegen Arsenopyrit Arsenkies Löllingit Realgar Rauschrot und Auripigment Orpiment Rauschgelb
+Weitere bekannte Minerale sind Cobaltit Kobaltglanz Domeykit Arsenkupfer Enargit Gersdorffit Nickelarsenkies Proustit Lichtes Rotgültigerz Rubinblende Rammelsbergit sowie Safflorit und Sperrylith
+Arsenate finden sich häufig in phosphathaltigen Gesteinen da sie eine vergleichbare Löslichkeit aufweisen und das häufigste Sulfidmineral Pyrit kann bis zu einigen Massenprozent Arsen einbauen
+Arsen wird heutzutage als Nebenprodukt der Verhüttung von Gold- Silber- Zinn- Kupfer- Cobalt- und weiteren Buntmetallerzen sowie bei der Verarbeitung von Phosphatrohstoffen gewonnen
+Die größten Produzenten im Jahr <num> waren China Chile Marokko und Peru
+Arsen ist nur schwer wasserlöslich und findet sich daher nur in geringen Spuren etwa <num> ppb Milliardstel Massenanteilen in Meeren und Ozeanen
+In der Luft findet man Arsen in Form von partikulärem ArsenIII-oxid
+Als natürliche Ursache dafür hat man Vulkanausbrüche identifiziert die insgesamt jährlich geschätzte <num> Tonnen in die Erdatmosphäre eintragen
+Bakterien setzen weitere <num> Tonnen in Form organischer Arsenverbindungen wie Trimethylarsin frei
+Ein großer Teil am freigesetzten Arsen entstammt der Verbrennung fossiler Brennstoffe wie Kohle oder Erdöl
+Die geschätzten Emissionen verursacht durch den Straßenverkehr und stationäre Quellen betrugen <num> in der Bundesrepublik Deutschland <num> Tonnen <num> Tonnen in den alten <num> Tonnen in den neuen Bundesländern
+Die Außenluftkonzentration von Arsen liegt zwischen <num> und <num> Nanogramm pro Kubikmeter
+Gewinnung und Darstellung
+DateiArsenbergwerkRotgueldenseejpg
+Arsen fällt in größeren Mengen als Nebenprodukt bei der Gewinnung von Kupfer Blei Cobalt und Gold an
+Dies ist die Hauptquelle für die kommerzielle Nutzung des Elements
+Es kann durch thermische Reduktion von ArsenIII-oxid mit Koks oder Eisen und durch Erhitzen von Arsenkies FeAsS oder Arsenikalkies FeAs<num> unter Luftabschluss in liegenden Tonröhren gewonnen werden
+Dabei sublimiert elementares Arsen das an kalten Oberflächen wieder in den festen Aggregatzustand zurückkehrt
+FeAsS_s -> FeS_s
+As_g
+Arsenkies zersetzt sich in Eisensulfid und elementares Arsen
+FeAs<num>_s -> FeAs_s
+As_g
+Arsenikalkies zersetzt sich in Eisenarsenid und elementares Arsen
+Für die Halbleitertechnik wird Arsen dessen Reinheit über <num> Prozent betragen muss durch Reduktion von mehrfach destilliertem ArsenIII-chlorid im Wasserstoffstrom hergestellt
+<num>AsCl<num>
+<num>H<num> -> <num>HCl
+<num>As
+Arsentrichlorid reagiert mit Wasserstoff zu Chlorwasserstoff und elementarem Arsen
+Früher wurde es auch durch Sublimation aus Lösungen in flüssigem Blei erzeugt
+Dabei wird der Schwefel der Arsen-Erze durch das Blei in Form von BleiII-sulfid gebunden
+Die hierbei erzielten Reinheiten von über <num> Prozent waren für Halbleiteranwendungen nicht ausreichend
+Eine andere Möglichkeit besteht im Auskristallisieren bei hohen Temperaturen aus geschmolzenem Arsen oder in der Umwandlung in Monoarsan einer anschließenden Reinigung sowie der Zersetzung bei <num> C in Arsen und Wasserstoff
+Eigenschaften
+DateiArsenkomplexepng DateiArsen <num>jpg Arsen bildet mit Stickstoff Phosphor Antimon und Bismut die <num> Hauptgruppe des Periodensystems und nimmt wegen seiner physikalischen und chemischen Eigenschaften den Mittelplatz in dieser Elementgruppe ein
+Arsen hat eine relative Atommasse von <num>
+Der Radius des Arsen-Atoms beträgt <num> Pikometer
+In kovalent gebundenem Zustand ist er etwas kleiner <num> Pikometer
+Aufgrund der Abgabe der äußeren Elektronen Valenzelektronen bei der Ionisierung reduziert sich der Radius beträchtlich auf <num> Pikometer As<num> das äußerste p- und das äußerste s-Atomorbital bleiben unbesetzt beziehungsweise <num> Pikometer As<num> nur das p-Orbital ist unbesetzt
+In chemischen Komplexverbindungen ist das As<num>-Kation von vier Bindungspartnern Liganden As<num> von sechs umgeben
+Arsen tritt allerdings nur sehr selten in eindeutig ionischer Form auf
+Der Wert für die Elektronegativität liegt nach Pauling auf der von <num> Metalle bis <num> Nichtmetall reichenden Skala bei <num> und ist damit mit dem Wert des Gruppennachbarn Phosphor vergleichbar
+Der Halbmetall-Charakter des Arsens zeigt sich zudem darin dass die benötigte Dissoziationsenergie von <num> kJmol also die Energie die aufgebracht werden muss um ein einzelnes Arsen-Atom aus einem Arsen-Festkörper herauszulösen zwischen der des Nichtmetalls Stickstoff <num> kJmol kovalente Bindung und des Metalls Bismut <num> kJmol metallische Bindung liegt
+Unter Normaldruck sublimiert Arsen bei einer Temperatur von <num> C geht also aus dem festen Aggregatzustand direkt in die Gasphase über
+Arsendampf ist zitronengelb und setzt sich bis ungefähr <num> C aus As<num>-Molekülen zusammen
+Oberhalb von <num> C liegen As<num>-Moleküle vor
+Arsen zeigt je nach Verbindungspartner Oxidationsstufen zwischen -<num> und <num>
+Mit elektropositiven Elementen wie Wasserstoff oder Metallen bildet es Verbindungen in denen es eine Oxidationsstufe von -<num> einnimmt
+Beispiele dafür sind Monoarsan AsH<num> und Arsenkupfer Cu<num>As
+In Verbindungen mit elektronegativen Elementen wie den Nichtmetallen Sauerstoff Schwefel und Chlor besitzt es die Oxidationsstufe <num> oder <num> erstere ist dabei gegenüber den in derselben Hauptgruppe stehenden Elementen Stickstoff und Phosphor tendenziell bevorzugt
+Modifikationen
+Arsen kommt wie andere Elemente der Stickstoffgruppe in verschiedenen allotropen Modifikationen vor
+Anders als beim Stickstoff der in Form zweiatomiger Moleküle mit kovalenter Dreifachbindung vorkommt sind die entsprechenden As<num>-Moleküle instabil und Arsen bildet stattdessen kovalente Netzwerke aus
+Graues Arsen
+DateiGrauesarsenpng Graues oder metallisches Arsen ist die stabilste Form Es hat eine Dichte von <num> gcm<num>
+Seine Kristalle sind stahlgrau metallisch glänzend und leiten den elektrischen Strom
+Betrachtet man den strukturellen Aufbau des grauen Arsens dann erkennt man Schichten aus gewellten Arsen-Sechsringen welche die Sesselkonformation einnehmen
+Darin bilden die Arsen-Atome eine Doppelschicht wenn man sich den Aufbau der Schicht im Querschnitt ansieht
+Die Übereinanderlagerung dieser Doppelschichten ist sehr kompakt
+Bestimmte Atome der nächsten darüberliegenden oder darunterliegenden Schicht sind von einem Bezugsatom fast ähnlich weit entfernt wie innerhalb der betrachteten Doppelschicht
+Dieser Aufbau bewirkt dass die graue Arsen-Modifikation wie die homologen Elemente Antimon und Bismut sehr spröde ist
+Deswegen werden diese drei Elemente häufig auch als Sprödmetalle bezeichnet
+Gelbes Arsen
+Wird Arsen-Dampf in dem Arsen gewöhnlich als As<num>-Tetraeder vorliegt schnell abgekühlt so bildet sich das metastabile gelbe Arsen mit einer Dichte von <num> gcm<num>
+Es besteht ebenfalls aus tetraedrischen As<num>-Molekülen
+Gelbes Arsen ist ein Nichtmetall und leitet infolgedessen den elektrischen Strom nicht
+Es kristallisiert aus Schwefelkohlenstoff und bildet kubische stark lichtbrechende Kristalle die nach Knoblauch riechen
+Bei Raumtemperatur und besonders schnell unter Lichteinwirkung wandelt sich gelbes Arsen in graues Arsen um
+Schwarzes Arsen
+Schwarzes Arsen selbst kann seinerseits in zwei verschiedenen Formen vorkommen
+Amorphes schwarzes Arsen entsteht durch Abkühlung von Arsen-Dampf an <num> bis <num> C warmen Oberflächen
+Es besitzt keine geordnete Struktur sondern liegt in einer amorphen glasartigen Form vor analog zum roten Phosphor
+Die Dichte beträgt <num> bis <num> gcm<num>
+Oberhalb <num> C wandelt sich das schwarze Arsen in die graue Modifikation um
+Wird glasartiges amorphes schwarzes Arsen bei Anwesenheit von metallischem Quecksilber auf <num> bis <num> C erhitzt so entsteht das metastabile
+orthorhombische schwarze Arsen das mit dem schwarzen Phosphor vergleichbar ist
+Natürlich gebildetes orthorhombisches schwarzes Arsen ist in der Natur als seltenes Mineral Arsenolamprit bekannt
+Braunes Arsen
+Bei der Reduktion von Arsenverbindungen in wässriger Lösung entstehen ähnlich wie beim Phosphor Mischpolymerisate
+Bei diesen bindet ein Teil der freien Valenzen des Arsens Hydroxygruppen -OH
+Man nennt diese Form des Arsens braunes Arsen
+Reaktionen
+Arsen reagiert heftig mit Oxidationsmitteln und Halogenen
+So verbrennt Arsen an der Luft mit bläulicher Flamme zu einem weißen Rauch von giftigem ArsenIII-oxid
+<num>As
+<num>O<num> -> <num>As<num>O<num>
+Arsen reagiert mit Sauerstoff zu ArsenIII-oxid
+Ohne äußere Wärmezufuhr findet die Reaktion mit Chlor unter Feuererscheinung zu ArsenIII-chlorid statt
+<num>As
+<num>Cl<num> -> <num>AsCl<num>
+Arsen reagiert mit Chlor zu Arsentrichlorid
+Eine weitere Oxidation ist möglich
+AsCl<num>
+Cl<num> -> AsCl<num>
+Arsentrichlorid reagiert mit Chlor zu Arsenpentachlorid
+Analoge Reaktionsgleichungen gelten für die entsprechenden Reaktionen mit Fluor
+Stark oxidierende Säuren wie konzentrierte Salpetersäure oder Königswasser wandeln Arsen in Arsensäure um
+As
+<num>HNO<num> -> <num>NO<num>
+H<num>O
+H<num>AsO<num>
+Arsen reagiert mit Salpetersäure zu Stickstoffdioxid Wasser und Arsensäure
+Ist die Oxidationsstärke weniger groß - etwa bei Verwendung von verdünnter Salpetersäure oder Schwefelsäure - entsteht Arsenige Säure
+<num>As
+<num>H<num>SO<num> -> <num>SO<num>
+<num>H<num>AsO<num>
+Arsen reagiert mit Schwefelsäure zu Schwefeldioxid und Arseniger Säure
+Unter sauren Bedingungen und bei Anwesenheit von nichtpassivierten unedlen Metallen insbesondere Zink reagiert Arsen mit dem gebildeten Wasserstoff zu Monoarsan
+Zn
+<num>H<num>O -> Zn<num>
+H<num>
+<num> H<num>O
+Zink reagiert mit Wasserstoffionen zu Zinkionen und neutralem Wasserstoff
+<num>As
+<num>H<num> -> <num>AsH<num>
+Arsen reagiert mit Wasserstoff zu Monoarsan
+Mit basischem Natriumhydroxid bildet sich das entsprechende Arsenitsalz
+<num>As
+<num>NaOH -> <num>Na<num>AsO<num>
+<num>H<num>
+Arsen reagiert mit Natriumhydroxid zu Natriumarsenit und elementarem Wasserstoff
+Isotope
+Vom Arsen sind künstlich hergestellte radioaktive Isotope mit Massenzahlen zwischen <num> und <num> bekannt
+Die Halbwertszeiten liegen zwischen <num> Millisekunden <num>As und <num> Tagen <num>As
+Natürlich vorkommendes Arsen besteht zu <num> Prozent aus dem Isotop <num>As es ist daher ein anisotopes Element
+Der entsprechende Arsen-Kern besteht also aus genau <num> Protonen und <num> Neutronen
+Physikalisch zählt man ihn daher zu den ug-Kernen u steht hier für ungerade g für gerade
+Sein Kernspin beträgt <num><num>
+Verwendung
+Arsen wird Bleilegierungen zugesetzt um ihre Festigkeit zu verbessern und das Blei gießbar zu machen
+Vor allem die fein strukturierten Platten von Akkumulatoren könnten ohne Arsen nicht gegossen werden
+Historisch war Arsen eine wichtige Zutat von Kupferlegierungen die dadurch besser verarbeitbar wurden
+Metallisches Arsen wurde früher gelegentlich zur Erzeugung mattgrauer Oberflächen auf Metallteilen verwendet um eine Alterung vorzutäuschen
+DateiWafer <num> Zoll bis <num> Zolljpg In der Elektronik spielt es als mindestens <num> Prozent reines Element für Gallium-Arsenid-Halbleiter sogenannte III-V-Halbleiter aufgrund der Kombination von Elementen aus der <num> und <num> Hauptgruppe des Periodensystems sowie für Epitaxieschichten auf Wafern in Form von Indiumarsenidphosphid und Galliumarsenidphosphid eine wesentliche Rolle in der Herstellung von Hochfrequenzbauelementen wie Integrierten Schaltkreisen ICs Leuchtdioden LEDs beziehungsweise Laserdioden LDs
+Es gab Anfang <num> weltweit nur drei Hersteller von hochreinem Arsen zwei in Deutschland und einen in Japan
+Arsen wird in Form seiner Verbindungen in einigen Ländern als Schädlingsbekämpfungsmittel im Weinbau als Fungizid Antipilzmittel in der Holzwirtschaft als Holzschutzmittel als Rattengift und als Entfärbungsmittel in der Glasherstellung verwendet
+Der Einsatz ist umstritten da die eingesetzten Arsenverbindungen hauptsächlich ArsenIII-oxid giftig sind
+Arsen in Arzneimitteln
+Die Verwendung arsenhaltiger Mineralien als Heilmittel ist bereits in der Antike durch Hippokrates und Plinius bezeugt
+Sie wurden als Fiebermittel als Stärkungsmittel und zur Therapie von Migräne Rheumatismus Malaria Tuberkulose und Diabetes eingesetzt
+Im <num> Jahrhundert wurde eine Mischung aus Kaliumarsenit und Lavendelwasser als Fowlersche Lösung bekannt die lange als medizinisches Wundermittel galt und als Fiebersenker Heilwasser und sogar als Aphrodisiakum Anwendung fand
+Kaliumarsenit war als Bestandteil der Fowlerschen Lösung bis in die <num>er Jahre in Deutschland als Mittel zur Behandlung der Psoriasis im Einsatz
+Constantinus Africanus <num>-<num> empfahl eine Arsenapplikation zur Bekämpfung von Zahnschmerzen
+Bereits um <num> vor Christus soll die Anwendung von Arsen zur Behandlung eines schmerzenden Zahnes in der chinesischen Heilkunst beschrieben worden sein
+In dem Mitte des <num> Jahrhunderts erschienenen Werk Liber Regius empfahl der arabische Arzt Haly Abbas ʿAli ibn al-ʿAbbās
+<num> ebenfalls den Einsatz von Arsenik zur Devitalisation der Pulpa ArsenIII-oxid wurde bis in die Neuzeit zur Devitalisation der Zahnpulpa verwendet und verschwand in den <num>er Jahren wegen der krebserregenden Wirkung Entzündungen des Zahnhalteapparates des Verlustes eines oder mehrerer Zähne einschließlich Nekrosen des umliegenden Alveolarknochens Allergien und Vergiftungserscheinungen aus dem Therapiespektrum
+Einen Aufschwung erlebten arsenhaltige bzw Arsenverbindungen enthaltende Arzneimittel zu Beginn des <num> Jahrhunderts
+Harold Wolferstan Thomas und Anton Breinl konnten <num> beobachten dass das arsenhaltige Präparat Atoxyl Trypanosomen zu denen die Erreger der Schlafkrankheit gehören abtötet
+<num> wurde eine Weiterentwicklung das Tryparsamid in der Zeit von <num> bis <num> im tropischen Afrika zur Therapie der Schlafkrankheit eingesetzt
+Es war bedeutsam für die Eingrenzung dieser Epidemie in der ersten Hälfte des vorigen Jahrhunderts konnte jedoch zur Erblindung führen
+Das in den <num>er Jahren entwickelte Melarsoprol war über mehrere Jahrzehnte das Mittel der Wahl zur Behandlung der Schlafkrankheit und wird heute noch eingesetzt da keine effektiven Nachfolgepräparate zur Verfügung stehen
+Ebenfalls angeregt durch die Trypanosomen-toxische Wirkung von Atoxyl entwickelte Paul Ehrlich das arsenhaltige Arsphenamin Salvarsan Das <num> in die Therapie der Syphilis eingeführte Mittel stellte das erste auf theoretischen Vorüberlegungen beruhende systematisch entwickelte spezifisch wirkende Chemotherapeutikum dar und war Vorbild für die Entwicklung der bis heute verwendeten Sulfonamide
+Es wurde lange Zeit auch bei der Behandlung von Dysenterie eingesetzt
+Im Jahr <num> wurde ein arsenikhaltiges Präparat unter dem Namen Trisenox in den USA zur Behandlung der akuten Promyelozytenleukämie APL zugelassen
+Seit <num> besteht für Trisenox in Europa eine Zulassung zur Behandlung der APL Vertrieb in EU und USA Cephalon
+Seine Wirksamkeit bei der Krebstherapie wird auch auf die antiangioneogenetische Wirkung zurückgeführt
+Die verschiedenen Arsensulfide sind Bestandteil von Arzneimitteln der Chinesischen Medizin
+Arsenik als Insektizid bei der Taxidermie
+Aufgrund der toxischen Eigenschaften von Arsenverbindungen wurde früher überwiegend Arsenik
+zur Haltbarmachung von Wirbeltieren Taxidermie als Insektizid verwendet Viele andere Stoffe wie auch Lindan wurden zum selben Zweck verwendet wie es die Fachliteratur der Präparatoren aus der Zeit von <num> bis <num> beschreibt
+Solche Stoffe sind jedoch auch für Menschen giftig und stellen heute an Präparatoren besondere Anforderungen da diese auch in Kontakt mit derart kontaminierten Präparaten kommen
+Biologische Bedeutung
+Die biologische Bedeutung des Arsens für den Menschen ist nicht vollständig geklärt
+Es gilt als Spurenelement im Menschen Mangelerscheinungen wurden bisher aber nur an Tieren nachgewiesen
+Der notwendige Bedarf liegt falls er bestehen sollte zwischen <num> und <num> µg pro Tag Eine tägliche Arsenaufnahme von - je nach Wahl der Nahrungsmittel - bis zu einem Milligramm gilt als harmlos
+In einer neuen Studie konnte eine erhöhte Arsenbelastung durch hohe Arsengehalte im Grundwasser von Reisanbaugebieten mit der Entstehung von Krebserkrankungen in Verbindung gebracht werden
+Die Förderung der Krebsentwicklung ist jedoch dosisabhängig und nur bei Verzehr von belastetem Reis als täglichem Grundnahrungsmittel gegeben Es gibt bei regelmäßigem Verzehr von Arsenverbindungen speziell Arsentrioxid eine Gewöhnung die beim Absetzen der Dosis sogar von Entzugserscheinungen begleitet werden
+Menschen die eine solche Gewöhnung erworben haben werden Arsenikesser genannt
+Meerestiere wie Muscheln oder Garnelen enthalten besonders viel Arsen letztere bis zu <num> ppm
+Vermutlich agiert es durch die Bindung an freie Thiolgruppen in Enzymen als Inhibitor verhindert also deren Wirkung
+Für viele Tiere ist Arsen ein essentielles Spurenelement
+So zeigen Hühner oder Ratten bei arsenfreier Ernährung deutliche Wachstumsstörungen dies hängt wahrscheinlich mit dem Einfluss des Elements auf die Verstoffwechslung der Aminosäure Arginin zusammen
+Zahlreiche Algen und Krebstiere enthalten organische Arsen-Verbindungen wie das schon erwähnte Arsenobetain
+Arsen führt zur verstärkten Bildung der sauerstofftransportierenden roten Blutkörperchen
+Aus diesem Grund wurde es früher dem Futter von Geflügel und Schweinen zugesetzt um eine schnellere Mästung zu ermöglichen
+Trainer von Rennpferden benutzten es zum illegalen Doping ihrer Tiere - heute kann der Zusatz von Arsen zur Nahrung allerdings leicht im Urin nachgewiesen werden
+Lösliche Arsenverbindungen werden leicht über den Magen-Darm-Trakt aufgenommen und rasch innerhalb von <num> Stunden im Körper verteilt
+Man findet den größten Teil des aufgenommenen Arsens in den Muskeln Knochen Nieren und Lungen
+Im Menschen wurde es zusammen mit Thallium in fast jedem Organ nachgewiesen
+Blut enthält bis zu <num> ppb Arsen in den anderen Organen des Körpers wie etwa den Knochen hat es einen Anteil von zwischen <num> und <num> ppm in Haaren liegt der Anteil bei etwa <num> ppm
+Der Gesamtgehalt von Arsen im Körper eines Erwachsenen liegt im Durchschnitt bei etwa <num> Milligramm
+Organische Arsenverbindungen wie die aus Fischen und Meeresfrüchten stammende Dimethylarsinsäure Trimethylarsenoxid Trimethylarsin sowie Arsenobetain verlassen den menschlichen Körper fast unverändert innerhalb von zwei bis drei Tagen über die Nieren
+Anorganische Arsenverbindungen werden in der Leber zu Monomethylarsonsäure MMAA und Dimethylarsinsäure DMAA umgewandelt und anschließend ebenso über die Nieren ausgeschieden
+Bei Pflanzen erhöht das Element den Kohlenhydrat-Umsatz
+Der Gebänderte Saumfarn Pteris vittata nimmt das Halbmetall bevorzugt aus dem Boden auf und kann bis zu fünf Prozent seines Trockengewichts an Arsen aufnehmen
+Aus diesem Grund wird die schnellwachsende Pflanze zur biologischen Säuberung arsenkontaminierter Böden eingesetzt
+Die stimulierende Wirkung des Arsens ist vermutlich auch Ursache des früher in einigen Alpengegenden verbreiteten Arsenikessens
+Im <num> Jahrhundert verzehrten manche der dortigen Bewohner lebenslang zweimal wöchentlich bis zu <num> Milligramm Arsen - bei Männern weil es bei der Arbeit in den Höhenlagen half bei Frauen da es angeblich zu einer kräftigen Gesichtsfarbe beitrug
+In der Wissenschaft lange als Märchen abgetan nahm ein Bauer aus den Steirischen Alpen <num> vor der in Graz versammelten deutschen Fachwelt eine Dosis von <num> Milligramm Arsentrioxid zu sich die sich später auch in seinem Urin nachweisen ließ
+Die Dosis lag weit über dem Doppelten der für normale Menschen tödlichen Arsenmenge zeigte aber keinerlei negative Auswirkungen auf den Bauern
+Ähnliches wird von Bewohnern einer Siedlung in der hochgelegenen chilenischen Atacamawüste berichtet deren Trinkwasser hochgradig mit Arsen belastet ist die jedoch keinerlei Vergiftungssymptome zeigen
+Heute geht man davon aus dass eine langsame Gewöhnung an das Gift mit sukzessive steigenden Dosen physiologisch möglich ist
+Über den Bakterienstamm GFAJ-<num> wurde <num> berichtet dass er unter bestimmten Bedingungen in arsenathaltigen Nährmedien in der Lage sei Arsenat anstatt Phosphat in Biomoleküle wie die DNA einzubauen ohne dabei abzusterben was bisher eher als unmöglich galt Der Befund scheint jedoch auf unsauberen Arbeitsmethoden zu basieren
+die Befunde konnten nicht repliziert werden
+Sicherheitshinweise
+Arsen-Stäube sind leicht entzündlich
+Toxizität
+Dreiwertige lösliche Verbindungen des Arsens sind hoch toxisch weil sie biochemische Prozesse wie die DNA-Reparatur den zellulären Energiestoffwechsel rezeptorvermittelte Transportvorgänge und die Signaltransduktion stören
+Dabei kommt es mutmaßlich nicht zu einer direkten Einwirkung auf die DNA sondern zu einer Verdrängung des Zink-Ions aus seiner Bindung zu Metallothioneinen und damit zur Inaktivierung von Tumor-Repressor-Proteinen siehe auch Zinkfingerprotein
+ArsenIII- und ZinkII-Ionen haben vergleichbare Ionenradien und damit ähnliche Affinität zu diesen Zink-Finger-Proteinen allerdings führt Arsen dann nicht zur Aktivierung der Tumor-Repressor-Proteine
+Eine akute Arsenvergiftung führt zu Krämpfen Übelkeit Erbrechen inneren Blutungen Durchfall und Koliken bis hin zu Nieren- und Kreislaufversagen
+Bei schweren Vergiftungen fühlt sich die Haut feucht und kalt an und der Betroffene kann in ein Koma fallen
+Die Einnahme von <num> bis <num> Milligramm Arsenik gilt für Menschen als tödliche Dosis LD<sub><num><sub>
+<num> mgkg Körpergewicht meist tritt der Tod innerhalb von mehreren Stunden bis wenigen Tagen durch Nieren- und Herz-Kreislauf-Versagen ein
+Eine chronische Arsenbelastung kann Krankheiten der Haut und Schäden an den Blutgefäßen hervorrufen was zum Absterben der betroffenen Regionen Black Foot Disease sowie zu bösartigen Tumoren der Haut Lunge Leber und Harnblase führt
+Diese Symptome wurden auch als Reichensteiner Krankheit bezeichnet nach einem Ort in Schlesien dessen Trinkwasser durch den Arsenik-Abbau bis zu <num> mg Arsen pro Liter enthielt
+Die chronische Arsen-Vergiftung führt über die Bindung an Sulfhydryl-Gruppen von Enzymen der Blutbildung zum Beispiel Delta-Amino-Laevulin-Säure-Synthetase zu einem initialen Abfall des Hämoglobins im Blut was zu einer reaktiven Polyglobulie führt
+Des Weiteren kommt es bei chronischer Einnahme von Arsen zur Substitution der Phosphor-Atome im Adenosin-Triphosphat ATP und damit zu einer Entkopplung der Atmungskette was zu einer weiteren reaktiven Polyglobulie führt
+Klinisch finden sich hier nach Jahren der As-Exposition Trommelschlägelfinger Uhrglasnägel Mees-Nagelbänder und Akrozyanose Raynaud-Syndrom mit Folge der Black Foot Disease
+Metallisches Arsen dagegen zeigt wegen seiner Unlöslichkeit nur eine geringe Giftigkeit da es vom Körper kaum aufgenommen wird LD<num>
+<num> mgkg Ratte oral Es sollte aber da es sich an der Luft leicht mit seinen sehr giftigen Oxiden wie dem Arsenik überzieht stets mit größter Vorsicht behandelt werden
+Anders verhält es sich mit Arsenik das in früheren Zeiten als Stimulans von Arsenikessern benutzt wurde um einer Arsenvergiftung vorzubeugen
+Der Mechanismus dieser Immunisierung gegen Arsen ist nicht bekannt
+Grenzwerte
+Anionisches Arsen tritt als Arsenit AsO<num><num>- und Arsenat AsO<num><num>- in vielen Ländern im Grundwasser in hohen Konzentrationen auf
+Durch Auswaschungen aus arsenhaltigen Erzen in Form von drei- und fünfwertigen Ionen trinken weltweit über <num> Millionen Menschen belastetes Wasser
+Besonders in Indien Bangladesh und Thailand wo im <num> Jahrhundert mit internationaler Unterstützung zahlreiche Brunnen gegraben wurden um von mit Krankheitserregern kontaminiertem Oberflächenwasser auf Grundwasser ausweichen zu können führte diese unerkannte Belastung des Trinkwassers zu chronischer Arsenvergiftung bei weiten Teilen der betroffenen Bevölkerung
+Das Problem kann wo es bekannt wird chemisch durch Oxidation der Arsenverbindungen und nachfolgende Ausfällung mit Eisenionen behoben werden
+Von der Rice University wurde eine kostengünstige Filtermöglichkeit mit Nano-Magnetit entwickelt DateiWeltkarte arsenrisikogebietegif Die Weltgesundheitsorganisation WHO empfiehlt seit <num> einen Grenzwert für Arsen im Trinkwasser von <num> Mikrogramm pro Liter
+Der Wert wird in vielen Staaten Europas und in den USA immer noch überschritten
+In Deutschland wird er dagegen seit <num> eingehalten
+Eine Richtlinie der Europäischen Union EU von <num> schreibt einen Höchstwert von <num> Mikrogramm pro Liter Trinkwasser EU-weit vor Die USA verpflichteten sich im Jahre <num> diesen Grenzwert ab <num> einzuhalten
+Das im Grundwasser vorkommende Arsen reichert sich in Reis zehnmal so stark an wie in anderen Getreidearten
+Auf dem Weltmarkt angebotene Sorten enthalten zwischen <num> und <num> Mikrogramm Arsen pro Kilogramm
+Im Jahr <num> senkte die chinesische Regierung den zulässigen Gehalt anorganischer Arsenverbindungen von <num> auf <num> Mikrogramm pro Kilogramm Lebensmittel im Juli <num> beschloss die Codex Alimentarius-Kommission erstmals einen Höchstwert von <num> Mikrogramm für polierten Reis
+Die für Lebensmittelsicherheit zuständige EU-Kommission diskutiert für Erzeugnisse aus Puffreis einen um <num> Prozent höheren Grenzwert und für spezielle Produkte für Kleinkinder einen nur halb so hohen d h
+<num> Mikrogramm pro kg
+Für andere belastete Lebensmittel wie Bier
+oder Fruchtsäfte gibt es noch keine Grenzwerte obwohl sie mehr Arsen enthalten können als für Trinkwasser zulässig ist
+Verbraucherorganisationen fordern für Apfelsaft einen Grenzwert von <num> höchstens aber <num> ppb entspricht Mikrogramm pro kg
+Fische und Meeresfrüchte weisen zwar hohe Gehalte an Arsen auf jedoch nahezu ausschließlich in der als unbedenklich geltenden organisch gebundenen Form Grenzwerte wie für Quecksilber oder Cadmium gibt es nicht
+Das neue Chemikaliengesetz der EU umgesetzt in der Gefahrstoffverordnung Deutschlands von <num> verbietet im Anhang <num> die gewerbliche nicht private Verarbeitung von arsenhaltigen Mitteln und Zubereitungen die mehr als <num> Gewichtsprozent an Arsen aufweisen
+Derartige Grenzwertregelungen sind gegeben da Arsen in den Verzinkereien der Galvanikindustrie weltweit der Zinkschmelze zugesetzt wird um die Haftungseigenschaften des Zinks an der Eisenoberfläche des zu verzinkenden Metallstückes zu verbessern
+Auf Grund der Temperatur im Zink-Schmelzbad von <num> C bis <num> C kommt es zum Verdampfen von Arsen Cadmium und anderen leicht flüchtigen Metallen und deren Anreicherung in der Luft des Arbeitsplatzes
+So können zulässige Grenzwerte kurzfristig um das Tausendfache überschritten werden mit der Folge der aerogen-alveolaren Aufnahme in den Körper Messungen ergaben dass Arsen und Cadmium im hochreinen Zink <num> Reinheitsgrad DIN-<num>-Reinheitsgrad mit weniger als <num> Gewichts- ausgewiesen waren und nach Zugabe von <num> Gramm dieses hochreinen Zinks in die Zinkschmelze zu einem Anstieg der Cd-As-Konzentration von <num> bis <num> µgm<num> Luft auf über <num> µgm<num> Luft führten
+Für Arsen wurde diese Tatsache überraschend in einer Verzinkerei durch Messung der Arsen-Konzentration in Zinkschmelze Blut und Urin festgestellt unveröffentlicht
+Bei Galvanik-Arbeitern wird die Urin-Arsen-Konzentration mit <num> bis <num> µgl Urin gemessen im Vergleich zu unbelasteter Bevölkerung mit <num> µg Arsenl Urin
+Abreicherung
+Für die Entfernung von ionischem Arsen aus dem Trinkwasser gibt es Verfahren die auf Adsorption an Aktivkohle aktiviertem Aluminiumoxid oder Eisenhydroxid-Granulat beruhen
+Daneben werden Ionenaustauscher verwendet
+Es ist möglich Arsen mittels gentechnisch veränderten Pflanzen aus dem Boden zu entfernen die es in Blättern speichern
+Zur Phytosanierung von Trinkwasser bietet sich die Dickstielige Wasserhyazinthe an die Arsen insbesondere in ihr Wurzelgewebe einlagert und so eine Abreicherung des kontaminierten Wassers bewirkt
+Organische Arsenverbindungen in belasteten Böden können enzymatisch mit Hilfe von Pilzen abgebaut werden
+In Bangladesh wird nach einem Verfahren der schweizerischen Forschungseinrichtung EAWAG versucht Arsen mit Hilfe von transparenten PET-Flaschen und Zitronensaft abzureichern
+Bei dieser SORAS Solar Oxidation and Removal of Arsenic genannten Methode oxidiert Sonnenlicht das Arsen die Inhaltsstoffe des Zitronensafts helfen bei der Ausfällung
+Mit dieser kostengünstigen Methode lässt sich der Arsengehalt um <num> bis <num> Prozent senken
+In Gewässern des Yellowstone-Nationalparks die sich aus Geysiren und anderen Thermalquellen vulkanischen Ursprungs speisen wurden eukaryontische Algen der Gattung Cyanidioschyzon gefunden die die hohen Arsenkonzentrationen der Gewässer tolerieren und sie zu biologisch weniger verfügbaren organischen Verbindungen oxidieren können
+An einer Nutzung zur Abreicherung in Trinkwasser wird gearbeitet
+Antidote
+Als Antidote bei akuten Arsenvergiftungen stehen die schwefelhaltigen Komplexbildner Dimercaptopropansulfonsäure DMPS Dimercaptobernsteinsäure und das ältere schlechter verträgliche Dimercaprol zur Verfügung
+Sie sind noch bei starken Arsendosen effektiv wenn die Vergiftung rechtzeitig diagnostiziert wird
+Ihr Stellenwert bei der Behandlung chronischer Arsenvergiftungen ist hingegen umstritten
+Aktivkohle ein bis mehrere Stunden nach der Einnahme kann das Metall ebenfalls binden und zur Ausscheidung bringen
+Prophylaxe
+Indische Forscher haben im Tierversuch herausgefunden dass die Einnahme von Knoblauch zur Senkung der Arsengehalte im Blut und der Erhöhung der Arsengehalte im Urin führen kann
+Erklärt wird dies über eine Ausfällung des Arsen bei Reaktion mit schwefelhaltigen Substanzen wie etwa Allicin das Bestandteil des Knoblauchs ist
+Zur Prophylaxe werden zwei bis drei Knoblauchzehen täglich empfohlen
+Nachweis
+Anorganische Nachweisreaktionen
+Arsenverbindungen zeigen beim Verbrennen eine wenig charakteristische fahlblaue Flammenfärbung
+Bei der Glühröhrchenprobe erhitzt man Arsenverbindungen welche teilweise sublimieren und sich an kalten Oberflächen in Form von schwarzem Arsen weißem ArsenIII-oxid oder gelbem Arsentrisulfid wieder niederschlagen
+Die so genannte Marshsche Probe ist die klassische Nachweisreaktion in der Chemie und Gerichtsmedizin für Arsen As<num>O<num>
+<num>Zn
+<num>H<num>O -> <num>AsH<num>
+<num>Zn<num>
+<num>H<num>O
+Bei der Bettendorfschen Probe oxidiert Arsen in konzentrierter Salzsäure unabhängig von der Oxidationsstufe zweiwertige Zinn-Ionen
+Dabei fällt elementares Arsen aus <num>As<num>
+<num>Sn<num> -> <num>Sn<num>
+<num>As
+Gibt man zu einer ammoniakalischen ammoniumchloridhaltigen Lösung von Arsenat Magnesium-Ionen so erhält man einen kristallinen Niederschlag von Magnesiumammoniumarsenat-Hexahydrat AsO<num><num>-
+Mg<num>
+NH<num>
+<num>H<num>O -> MgNH<num>AsO<num>H<num>O Arsenat reagiert mit Magnesiumionen Ammoniumionen und Wasser zu Magnesiumammoniumarsenat-Hexahydrat
+Eine weitere Nachweisreaktion von Arsenat in wässriger Lösung ist die Fällung mit Ammoniumheptamolybdat
+Der gelbe Niederschlag ist schwerlöslich in Säuren aber gut löslich in Basen H<num>AsO<num>-
+<num>H<num>O
+<num>NH<num>
+<num>MoO<num><num>- -> NH<num><num>AsMo<num>O<num><num>aq
+<num>H<num>O Dihydrogenarsenat reagiert mit Wasserstoffionen Ammoniumionen und Molybdationen zu Ammoniumarsenomolybdat und Wasser
+Instrumentelle Bestimmungsverfahren für Arsen
+Atomabsorptionsspektrometrie AAS
+Bei der Flammen-AAS werden die Arsenverbindungen in einer reduzierenden Luft-Acetylen-Flamme ionisiert
+Anschließend wird eine Atomabsorptionsmessung bei <num> nm beziehungsweise <num> nm durchgeführt
+Nachweisgrenzen bis zu <num> µgml wurden beschrieben
+Häufig wird das Arsen auch mit Hilfe von NaBH<num> in das gasförmige Arsin AsH<num> überführt Hydridtechnik
+In der Quarzrohrtechnik wird AsH<num> zuerst bei rund <num> C in einem elektrisch beheizten Quarzröhrchen thermisch in seine atomaren Bestandteile zersetzt um anschließend die Absorption bei o g
+Wellenlängen zu bestimmen
+Die Nachweisgrenze bei dieser Technik liegt bei <num> µgl Eine weitere Methode ist die sog Graphitrohrtechnik bei der das Arsen einer festen Probe bei <num> C und höher verflüchtigt und anschließend die Extinktion bei <num> nm gemessen wird
+Atomemissionsspektrometrie
+Die Kopplung von Hydridtechnik mit dem induktiv gekoppelten Plasma laserinduzierter Fluoreszenzmessung ist eine sehr nachweisstarke Methode zur Bestimmung von Arsen
+Mittels Hydriderzeugung freigesetztes AsH<num> wird dabei im Plasma atomisiert und mit einem Laser zur Emission angeregt
+Mit dieser Methode wurden Nachweisgrenzen von <num> ngmL erreicht
+Massenspektrometrie MS
+Bei der Massenspektrometrie wird die Arsenspezies zunächst durch ein induktiv gekoppeltes Argonplasma ICP-MS thermisch ionisiert
+Anschließend wird das Plasma in das Massenspektrometer geleitet
+Eine Nachweisgrenze von <num> µgl wurde für Arsenit beschrieben
+Photometrie
+Weitverbreitet ist die photometrische Erfassung von As als Arsenomolybdänblau
+AsV reagiert zunächst mit NH<num><num>MoO<num>
+Danach folgt eine Reduktion mit SnCl<num> oder Hydrazin zu einem blauen Komplex
+Die Photometrie erfolgt bei <num> nm und ist somit nahezu störungsfrei
+Die Nachweisgrenzen können durch Verwendung von basischen Farbstoffen als Komplexbildner verbessert werden
+Neutronenaktivierungsanalyse
+Eine sehr empfindliche Arsenbestimmung im ppt-Bereich ist mittels Neutronenaktivierungsanalyse möglich Sie kommt insbesondere dann zur Anwendung wenn die Probe eine komplexe Zusammensetzung aufweist oder schwierig aufzuschließen ist
+Allerdings gibt diese Methode keinen Hinweis auf die chemische Verbindung in der das Arsen vorliegt
+Bei der Wechselwirkung von Neutronen mit der Probe die das natürliche Isotop Arsen-<num> enthält wird das schwerere Isotop Arsen-<num> gebildet das jedoch instabil ist und sich unter einem β-Zerfall in Selen-<num> umwandelt
+Gemessen werden dabei die β-Strahlen über die ein Rückschluss auf die Menge des Arsens möglich ist
+<num>_<num>As
+<num>_<num>n -> <num>_<num>As -> <num>_<num>Se
+e-
+Biosensoren
+Bei Biosensoren wird die Biolumineszenz bei Kontakt von in Wasser gelöstem Arsen mit genetisch modifizierten Bakterien z B
+Escherichia coli
+K<num> und eines Lichtmessgeräts Luminometer detektiert
+Die vorhandene Arsenkonzentration korreliert dabei direkt mit der emittierten Lichtmenge
+Verbindungen
+Arsenwasserstoffe
+Chemische Verbindungen von Arsen und Wasserstoff
+Arsane sind im Vergleich zu den entsprechenden Verbindungen der Hauptgruppennachbarn Stickstoff und Phosphor nicht sehr zahlreich und sehr instabil
+Es sind zurzeit drei Arsane bekannt
+Arsenwasserstoff auch Monoarsan oder Arsin genannt mit der Summenformel AsH<num> ist eine wichtige Ausgangssubstanz zur Herstellung von Galliumarsenid in der Halbleiterindustrie
+Diarsan As<num>H<num>
+Triarsan As<num>H<num>
+Halogenverbindungen
+Arsen bildet mit Halogenen binäre Verbindungen vom Typ AsX<num> AsX<num> und As<num>X<num> X bezeichnet das entsprechende Halogen
+ArsenIII-fluorid AsF<num>
+ArsenV-fluorid AsF<num>
+ArsenIII-chlorid AsCl<num>
+Arsenpentachlorid AsCl<num>
+Arsentribromid AsBr<num>
+Arsentriiodid AsI<num>
+Diarsentetraiodid As<num>I<num>
+Sauerstoffverbindungen
+Wichtige Sauerstoffsäuren sind
+Arsensäure <num> H<num>AsO<num>
+H<num>O deren Salze als Arsenate oder ArsenateV bezeichnet werden und den Phosphaten ähneln
+Beispiele sind Calciumarsenat Ca<num>AsO<num><num><num>H<num>O und Bleihydrogenarsenat PbHAsO<num> die als Pflanzenschutzmittel verwendet wurden
+Arsenige Säure H<num>AsO<num> deren Salze als Arsenite oder ArsenateIII bezeichnet werden
+Das wichtigste Arsenoxid ist ArsenIII-oxid Arsentrioxid auch Arsenik oder Weißarsenik As<num>O<num> das Anhydrid der Arsenigen Säure das in der Gasphase in Form von Doppelmolekülen mit der Formel As<num>O<num> vorliegt
+Es ist amphoter und weist damit auf den Halbmetallcharakter des Arsens hin
+Neben As<num>O<num> kennt man As<num>O<num> Arsenpentaoxid das Anhydrid der Arsensäure und das gemischte Anhydrid der Arsenigen Säure und Arsensäure As<num>O<num> Arsentetraoxid
+Ein historisch wichtiges Färbe- und Pflanzenschutzmittel ist ein Kupfer-Arsen-Oxid mit dem Trivialnamen Schweinfurter Grün CuAsO<num><num>CuCH<num>COO<num>
+Schwefelverbindungen
+Es bestehen zwei wichtige Arsensulfide die beide als Minerale in der Natur vorkommen
+Arsenmonosulfid Realgar As<num>S<num>
+ArsenIII-sulfid Auripigment As<num>S<num>
+Arsen-Metall-Verbindungen
+Wichtige Verbindungen von Arsen mit Metallen sind
+Galliumarsenid GaAs ein wichtiger Halbleiter
+Indiumarsenid InAs ein wichtiger Halbleiter
+Nickelarsenid NiAs
+Aluminiumgalliumarsenid AlGaAs
+Organische Verbindungen
+In Analogie zu den Aminen und Phosphinen findet man entsprechende Verbindungen mit Arsen anstelle von Stickstoff oder Phosphor
+Sie werden als Arsine bezeichnet
+Dimethylarsin AsHCH<num><num>
+Trimethylarsin AsCH<num><num> eine übelriechende Flüssigkeit die zur Behandlung bakterieller Infektionen und als Pilzschutzmittel Anwendung fand
+Zu den Arsoranen Verbindungen vom Typ R<num>As wobei R<num> für fünf - möglicherweise unterschiedliche - organische Gruppen steht zählt man etwa Pentaphenylarsen oder Pentamethylarsen
+Fehlt eine der fünf Gruppen bleibt ein einfach positiv geladenes Ion zurück R steht wiederum für - möglicherweise verschiedene - organische Gruppen das man als Arsoniumion AsR<num> bezeichnet
+DateiPolyzyklisches Arsenpng
+Analog zu den Carbonsäuren lassen sich zwei Klassen arseno-organischer Säuren bilden
+Arsinsäuren RRAsOOH
+Arsonsäuren RAsOOH<num>
+Zudem sind Heteroaromaten mit Arsen als Heteroatom bekannt wie Arsabenzol das aus einem Benzolring besteht in dem ein Kohlenstoffatom durch Arsen ersetzt ist und das somit analog zu Pyridin aufgebaut ist
+DateiPolyarsinpng
+Auch homocyclische Arsenverbindungen existieren
+Beispiele sind
+Pentamethylcyclopentaarsen AsCH<num><num>
+Hexamethylcyclohexaarsen AsCH<num><num>
+deren Moleküle einen Fünf- beziehungsweise Sechsring aus Arsenatomen als Rückgrat aufweisen an den nach außen hin je eine Methylgruppe pro Arsenatom gebunden ist
+Eine polycyclische Variante bildet das nebenstehende Molekül dessen Rückgrat sich aus einem Sechs- und zwei angehefteten Fünfringen zusammensetzt R steht für jeweils eine tert-Butylgruppe
+Schließlich lassen sich Arsenpolymere darstellen lange Kettenmoleküle die als Polyarsine bezeichnet werden
+Sie bestehen aus einer zentralen Strickleiter der Arsenatome an die außen auf jeder Seite je Sprosse eine Methylgruppe angeheftet ist so dass sich die chemische Formel AsCH<num><num>n ergibt wobei die natürliche Zahl n weit über <num> liegen kann
+Polyarsine zeigen deutliche Halbleitereigenschaften
+Bioorganische Verbindungen
+In der Bioorganik spielen Arsenolipide Arsenosaccharide und arsenhaltige Glycolipide eine bedeutende Rolle
+Wichtige Vertreter dieser Stoffklassen sind zum Beispiel Arsenobetain Arsenocholin und unterschiedlich substituierte Arsenoribosen
+Sie treten vor allem kumuliert in maritimen Lebewesen auf und können auf diesem Weg in die menschliche Nahrungskette gelangen
+Arsenhaltige Biomoleküle konnten in Algen Meeresschwämmen und in Fischgewebe nach erfolgter Extraktion mittels HPLC-ICP-MS nachgewiesen werden
+Die Analytik von Organo-Arsenverbindungen einschließlich ihrer Speziation ist sehr aufwändig
+Arsen in Kriminalgeschichte Literatur und Film
+Das Element Arsen erreichte zweifelhafte Berühmtheit als Mordgift belegt durch geschichtliche Aufzeichnungen sowie die Instrumentalisierung in Literatur und Film
+Es handelte sich bei dem Mordgift allerdings nie um elementares Arsen sondern um dessen Verbindungen
+In Italien und Frankreich starben Herzöge Könige und Päpste an vorsätzlich herbeigeführten Arsenvergiftungen
+Im Frankreich des <num> Jahrhunderts steht die Marquise de Brinvilliers die ihren Vater und zwei Brüder mit einer Arsenikmischung vergiftete im Mittelpunkt eines Giftskandals
+In Deutschland brachte die Serienmörderin Gesche Gottfried aus Bremen <num> Menschen zu Tode
+Aufsehen erregte auch der Fall der Serienmörderin Anna Margaretha Zwanziger zu Beginn des <num> Jahrhunderts
+Die Urheber der Morde blieben jedoch meist unerkannt da Arsen bis <num> in kleinen Mengen nicht nachgewiesen werden konnte
+Erst die durch James Marsh entwickelte und nach ihm benannte Marshsche Probe machte es möglich Spuren des Elementes zu identifizieren und somit eine unnatürliche Todesursache nachzuweisen
+Im <num> und <num> Jahrhundert fanden weiter vorsätzliche Vergiftungen mit arsenhaltigen Mitteln statt - zum einen weil sie leicht als Herbizide verfügbar waren zum anderen ließ sich bei chronischer Gabe kleiner Dosen ein krankheitsbedingter Tod vortäuschen
+Im September <num> fiel im Prozess gegen Marie Lafarge das erste Urteil das alleine auf den Ergebnissen der Marshschen Probe beruhte
+Im Fall der Marie Besnard die angeblich zwischen <num> und <num> für mehrere Todesfälle in ihrem Umfeld in Loudun verantwortlich sein sollte konnte ein eindeutiger Beweis nicht erbracht werden weil Untersuchungsergebnisse widersprüchlich waren und sie musste <num> letztendlich freigesprochen werden
+DateiThe Imperial Portrait of Emperor Guangxu<num>jpg DateiNapoleon - <num>jpg Jahrelang glaubte die Fachwelt dass der Tod des ehemaligen französischen Kaisers Napoleon Bonaparte mit <num> Jahren auf der Insel St
+Helena
+einem Giftanschlag mit Arsen zugeschrieben werden muss
+Zumindest hatte man in seinen Haaren hochkonzentrierte Spuren des Giftes entdeckt
+Heute existieren verschiedene andere Thesen zur Erklärung des Faktenbefunds
+Eine Möglichkeit besteht darin dass das Arsen nach seinem Tod den Haaren beigegeben wurde um diese zu konservieren eine damals durchaus übliche Methode
+Möglich ist ein Übermaß der Benutzung der arsenhaltigen Fowlersche Lösung die zu seiner Zeit bei vielen seiner Zeitgenossen als medizinisches Wundermittel galt
+Die dritte und heute als wahrscheinlichste angesehene Möglichkeit ist dass sich Napoleon durch organische Arsenverbindungen vergiftete die Schimmelpilze beständig aus seinen mit grünen Arsenpigmenten gefertigten Tapeten freisetzten
+Deren hoher Arsengehalt ist durch eine <num> in einem Notizbuch aufgefundene Materialprobe schlüssig belegt
+Der berühmte Philosoph René Descartes starb <num> wenige Monate nach seiner Ankunft am Hofe der schwedischen Königin Christine
+Der Verdacht er sei von einem der Jesuiten die sich am Hofe der protestantischen Königin aufhielten aus religionspolitischen Gründen mit Arsen vergiftet worden verstärkte sich als Christine später tatsächlich zum Katholizismus konvertierte konnte aber nicht erhärtet werden so dass die offizielle Todesursache Lungenentzündung sich in den Biographien etablierte
+Erst kürzlich wurde anhand von neu aufgefundenen und neu interpretierten Dokumenten der alte Verdacht erhärtet und behauptet dass der Giftmord an Descartes in sehr hohem Maße wahrscheinlich um nicht zu sagen fast sicher erscheint
+Im Jahre <num> kam es im britischen Manchester zu einer Massenvergiftung von der mehrere Tausend Menschen betroffen waren
+Wie sich herausstellte hatten alle Bier derselben Brauerei getrunken
+In Vorstufen der Bierproduktion wurde anscheinend Schwefelsäure eingesetzt die ihrerseits aus Schwefel hergestellt wurde der aus mit Arsenopyrit kontaminierten Sulfidmineralen stammte
+Etwa <num> Menschen erlagen ihren Vergiftungen
+In den Jahren <num> und <num> starben in Österreich zwei Männer an einer Arsenvergiftung
+Am <num> April <num> wurde am Landesgericht Krems eine <num>-jährige Polin des Mordes an den beiden für schuldig befunden und von dem Geschworenengericht nicht rechtskräftig zu lebenslanger Haft verurteilt Noch in den <num>er Jahren auf dem Höhepunkt des Kalten Krieges erkrankte die US-amerikanische Botschafterin Clare Booth Luce in Rom durch eine Vergiftung mit dem aus Tapeten freigesetzten Arsen
+Die Tatsache dass die Krankheit auf die schimmelpilzbefallenen Tapeten und nicht auf gegnerische Geheimagenten zurückgeführt werden konnte trug in diesem Fall nicht nur zur Genesung der Botschafterin sondern auch zum Erhalt des Friedens bei
+In Friedrich Schillers bürgerlichem Trauerspiel Kabale und Liebe vergiftet der junge Major Ferdinand von Walter erst seine Geliebte Luise Millerin und dann sich selbst
+Allerdings tritt in Kabale und Liebe der Tod unrealistischerweise binnen Minuten ein
+Die Protagonistin des berühmten Romans
+Madame Bovary
+von Gustave Flaubert die unglücklich verheiratete Landarztgattin Emma Bovary stirbt am Ende des Romans durch Suizid mit Arsen in Form eines weißen Pulvers
+Der Spross einer Arztfamilie Flaubert beschreibt die Vergiftungssymptome und den äußerst qualvollen Tod der Bovary sehr detailliert
+Im Roman Starkes Gift Strong Poison von Dorothy L Sayers ist das Opfer mit Arsen vergiftet worden
+Die Verdächtige Krimi-Schriftstellerin Harriet Vane hat sich zur fraglichen Zeit intensiv mit Arsenmorden beschäftigt und sich dazu sogar vom Apotheker beraten lassen
+Der berühmte Detektiv Kalle Blomquist aus dem gleichnamigen Kinderbuch von Astrid Lindgren wendete die Marshsche Probe an um ein mit Arsen vergiftetes Stück Schokolade zu überprüfen
+In dem Theaterstück von Joseph Kesselring
+Arsen und Spitzenhäubchen
+englisch Arsenic and Old Lace vergiften zwei alte Damen in gutmeinender Absicht ältere einsame Herren mit einer Arsen- Strychnin- und Zyankali-Mischung
+Bekannt wurde das Stück durch die gleichnamige Verfilmung von Frank Capra mit Cary Grant Peter Lorre und Priscilla Lane in den Hauptrollen
+Literatur
+Erwin Riedel Anorganische Chemie
+de Gruyter Berlin <num> ISBN <num>-<num>-<num>-<num>
+Dietmar Ritter Charakterisierung und Einsatz alternativer Arsen- und Phosphor-Quellen für die Metallorganische Molekularstrahlepitaxie von InP und GaInAs Shaker Aachen <num> ISBN <num>-<num>-<num>-<num>
+Giulio Morteani Lorenz Eichinger Arsen im Trinkwasser und Dearsenierung
+Gesetzliche Vorschriften Toxikologie Hydrochemie
+In Wasser Luft Boden Vereinigte Fachverlag Mainz <num> <num> <num> S <num>-<num>
+Nicholas C Norman Chemistry of Arsenic Antimony and Bismuth Blackie London <num> ISBN <num>-<num>-<num>-X
+Andrew A Meharg Venomous Earth How arsenic caused the worlds worst mass poisoning Macmillan Science
+Die bremische Gesina In Hans Heinrich Frau-Geschichten WM-Literatur-Verlag Weilheim <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Weblinks
+MineralienatlasArsen Enzymatischer Abbau von Arsenkampfstoffen wissenschaftde - Arsen im Trinkwasser begünstigt Arteriosklerose Arsenic and Human Health Environmental Health
+Toxicology Specialized Information Services National Library of Medicine englisch
+PDF <num> KiB
+Einzelnachweise
+Jorma Maeki-Paakkanen Päivi Kurttio Anna Paldy Juha Pekkanen
+PDF In Environmental and Molecular Mutagenesis <num> Nr <num> <num> S <num>-<num> Oyeronke A Odunola Aliyu Muhammad Ahsana D Farooq Kourosh Dalvandi Huma Rasheed Muhammad I Choudhary Ochuko L Erukainure Comparative assessment of redox-sensitive biomarkers due to acacia honey and sodium arsenite administration in vivo In Mediterranean Journal of Nutrition and Metabolism <num> Nr <num> <num> S <num>-<num> doi<num>s<num>-<num>-<num>-<num> Bernhard Fischer Ueber Todesfälle nach Salvarsan In
+Deutsche Medizinische Wochenschrift Band <num> <num> S <num> f <num>-<num> <num>-<num> und <num>-<num> J Elfenbein Der erste Krimi der Weltgeschichte Teil <num> Die Machtergreifung des König Darius In Borsuye Zeitschrift für Medizin u Kultur <num> <num> <num> S <num> f Doris Schwarzmann-Schafhauser Arsen In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num> S <num> K H Wedepohl The composition of the continental crust In
+Geochimica et Cosmochimica Acta <num><num> <num> S <num>-<num> IMACNMNC List of Mineral Names - Gold PDF <num> MB S <num> englisch Localities for Arsenic Mindat Mineral Species sorted by the element As Arsenic Webmineral G Brauer Hrsg Handbook of Preparative Inorganic Chemistry <num> Auflage vol <num> Academic Press <num> S <num>-<num> NA J M Hyson A history of arsenic in dentistry In Journal of the California Dental Association Band <num> Nummer <num> Februar <num> S <num>-<num> PMID <num> M Hülsmann Risiken und Nebenwirkungen bei der Devitalisierung permanenter Zähne In Zahnärztl Mitt <num> <num> S <num>-<num> Ernst Sieburg Zur Biologie aromatischer Arsenverbindungen In
+Hoppe-Seylers Zeitschrift für physiologische Chemie Band <num> <num> S <num>-<num> Vgl auch Florian G Mildenberger Kein Heil durch Arsen Die Salvarsandebatte und ihre Konsequenzen In Fachprosaforschung - Grenzüberschreitungen Band <num><num> <num><num> <num> S <num>-<num>Fernando Marte Amandine Pequinot David W Von Endt
+PDF <num> kB Gerhard Schröder Das Sammeln Konservieren von Wirbeltieren <num> Rudolf Piechocki Joachim Händel Mikroskopische Präparationstechnik Teil II <num> Auflage <num>Felix Divo
+Jugend-forscht-Arbeit von <num> John Emsley Parfum Portwein PVC
+Wiley Verlag Weinheim <num> S <num>-<num> M Banerjee N Banerjee P Bhattacharjee D Mondal P R Lythgoe M Martínez J Pan D A Polya A K Giri High arsenic in rice is associated with elevated genotoxic effects in humans In Scientific reports Band <num> Juli <num> S <num> doi<num>srep<num> PMID <num> Felisa Wolfe-Simon Jodi Switzer Blum Thomas R Kulp Gwyneth W Gordon Shelley E Hoeft Jennifer Pett-Ridge John F Stolz Samuel M Webb Peter K Weber Paul C W Davies Ariel D Anbar Ronald S Oremland A Bacterium That Can Grow by Using Arsenic Instead of Phosphorus In
+Science
+<num> doi<num>science<num> Erika Check Study challenges existence of arsenic-based life Study challenges existence of arsenic-based life In nature news <num> Januar <num> doi<num>nature<num> M L Reaves S Sinha J D Rabinowitz L Kruglyak R J Redfield Absence of arsenate in DNA from arsenate-grown GFAJ-<num> cells <num> April <num>
+Johann Mutschmann Fritz Stimmelmayr Taschenbuch der Wasserversorgung ViewegTeubner <num> ISBN <num>-<num>-<num>-<num>-<num> Arsenic Removal Using Nanoscale Magnetite Richtlinie <num><num>EG des Rates vom <num> November <num> über die Qualität von Wasser für den menschlichen Gebrauch
+eur-lexeuropaeu DPA-Meldung auf merkur-onlinede vom <num> Juli <num> abgerufen am <num> November <num>
+auf der Webseite der FAO abgerufen am <num> November <num> englisch
+PDF eceuropaeu abgerufen am <num> November <num> englisch Keiligh Baker
+In
+Daily Mail <num> November <num> abgerufen am <num> November <num> englisch Nadja Podbregar
+In
+wissenschaftde <num> April <num> abgerufen am <num> November <num>
+In
+Washington Post <num> Mai <num> abgerufen am <num> November <num> englisch
+auf der Webseite des LGL Bayern aktualisiert am <num> Mai <num> abgerufen am <num> November <num> T K Morris Cadmium exposures at three nonferrous foundries an unexpected trace source In J Occup Environ Hyg <num><num> Jan <num> S <num>-<num> Ohio Bureau of Workers Compensation Division of Safety and Hygiene Cincinnati OH Jie Qin u a Biotransformation of arsenic by a Yellowstone thermoacidophilic eukaryotic alga In
+Proceedings of the National Academy of Sciences Abstract R Lobinski Z Marcenko Spectrochemical Trace Analysis for Metals and Metalloids Elsevier <num> P Liang L Peng P Yan Speciation of AsIII and AsV in water samples by liquid-liquid microextraction separation and determination by graphite furnace atomic absorption spectrometry In
+Microchimica Acta <num> <num> S <num>-<num> and darin genannte Zitationen Y Jiang J Liu X Xia D Wang Ammonium pyrrolidinedithiocarbamate-modified activated carbon micro-column extraction for the determination of AsIII in water by graphite furnace atomic absorption spectrometry In Microchimica Acta <num> <num> S <num>-<num> D Hung O Nekrassova R Compton Analytical Methods for Inorganic Arsenic in Water A Review In
+Talanta <num> <num> S <num>-<num> J Mattusch R Wennrich Novel Analytical Methodologies for the Determination of Arsenic and other Metalloid Species in Solids Liquids and Gases In Microchimica Acta <num> <num> S <num>-<num> S Londesborough J Mattusch R Wennrich Separation of organic and inorganic arsenic species by HPLC-ICP-MS In Fresenius Journal of Analytical Chemistry <num> <num> S <num>-<num> G Schwedt Analytische Chemie <num> Auflage Wiley-VCH <num> S <num>
+PDF Helmholtz-Zentrum für Umweltforschung Escherichia coli Bakterien in Arsen Detektoren <num> März <num> K O Amayo A Raab E M Krupp T Marschall M Horsfall Jr J Feldmann Arsenolipids show different profiles in muscle tissues of four commercial fish species J Trace Elem Med Biol <num> Nov <num> pii S<num>-<num>X<num><num>-<num> PMID <num> V Dembitsky D Levitsky Arsenolipides In Progress in Lipid Research <num> <num> S <num>-<num> Theodor Ebert Philosoph Interview zu seinem Buch Der rätselhafte Tod des René Descartes Alibri Aschaffenburg <num> orfat Lebenslange Haft im Arsen-Prozess abgerufen am <num> April <num>
+Astat
+von
+unbeständig unstet ist ein radioaktives chemisches Element mit dem Elementsymbol At und der Ordnungszahl <num> Im Periodensystem steht es in der <num> Hauptgruppe bzw der <num> IUPAC-Gruppe und zählt damit zu den Halogenen
+Astat entsteht beim natürlichen Zerfall von Uran
+Astat ist eines der seltensten natürlich vorkommenden Elemente der Erde das bei Bedarf künstlich erzeugt werden muss
+Geschichte
+ateiSegrejpgEmilio Gino Segrè Entdecker des Astats
+Dmitri Mendelejew
+Iod
+Im Jahre <num> behauptete Fred Allison er und seine Mitarbeiter am Alabama Polytechnic Institute heute Auburn University hätten das fehlende Element entdeckt und gaben ihm die Bezeichnung Alabamine Ab
+Ihre Entdeckung konnte jedoch nicht bestätigt werden und wurde später als falsch erkannt
+Ebenfalls auf der Suche nach einem Mitglied der Familie des radioaktiven Thoriums fand der Chemiker De Rajendralal Mitra im Jahre <num> in Dhaka Bangladesch damals Britisch-Indien zwei neue Elemente
+Das erste nannte er Dakin Eka-Iod wohl nach der englischen Bezeichnung für Dhaka Dacca das andere Gourium Beide Entdeckungen konnten jedoch nicht bestätigt werden
+Der Name Helvetium wurde wiederum von dem Schweizer Chemiker Walter Minder vorgeschlagen als er die Entdeckung des Elements <num> im Jahr <num> ankündigte
+Er änderte im Jahr <num> jedoch seinen Vorschlag in Anglohelvetium
+Bestätigt werden konnte die Entdeckung des Astat altgriechisch ἀστατέω
+unbeständig sein aufgrund des radioaktiven Zerfalls erstmals im Jahre <num> durch die Wissenschaftler Dale Corson Kenneth MacKenzie und Emilio Gino Segrè die es in der University of California künstlich durch Beschuss von Bismut mit Alphateilchen herstellten
+Drei Jahre später konnte das kurzlebige Element von Berta Karlik und Traude Bernert auch als Produkt des natürlichen Zerfallsprozesses von Uran gefunden werden
+Gewinnung und Darstellung
+Astat wird durch Beschuss von Bismut mit Alphateilchen im Energiebereich von <num> bis <num> MeV hergestellt
+Man erhält dabei die relativ langlebigen Isotope <num>At bis <num>At die dann im Stickstoff strom bei <num> bis <num> C sublimiert und an einer gekühlten Platinscheibe abgetrennt werden
+Eigenschaften
+Bei diesem radioaktiven Element wurde mit Hilfe von Massenspektrometrie nachgewiesen dass es sich chemisch wie die anderen Halogene besonders wie Iod verhält es sammelt sich wie dieses in der Schilddrüse an
+Astat ist stärker metallisch als Iod
+Forscher am Brookhaven National Laboratory haben Experimente zur Identifikation und Messung von elementaren chemischen Reaktionen durchgeführt die Astat beinhalten
+Mit dem On-line-Isotopen-Massenseparator ISOLDE am CERN wurde <num> das Ionisationspotenzial von Astat mit <num><num> Elektronenvolt bestimmt
+Isotope
+Astat hat etwa <num> bekannte Isotope die alle radioaktiv sind das langlebigste ist <num>At mit einer Halbwertszeit von <num> Stunden
+Verwendung
+Organische Astatverbindungen dienen in der Nuklearmedizin zur Bestrahlung bösartiger Tumore
+Astat-Isotope eignen sich aufgrund der kurzen Halbwertszeiten innerlich eingenommen als radioaktive Präparate zum Markieren der Schilddrüse
+Das Element wird in der Schilddrüse angereichert und in der Leber gespeichert
+Verbindungen
+Die chemischen Eigenschaften von Astat konnten aufgrund der geringen Mengen bisher nur mit Tracerexperimenten festgestellt werden
+Sie ähneln stark denjenigen des Iods wobei es aber ein schwächeres Oxidationsmittel ist
+Bisher konnten diverse Astatide Interhalogenverbindungen und organische Verbindungen nachgewiesen werden
+Auch die Anionen der entsprechenden Sauerstoffsäuren sind bekannt
+Wegen des im Vergleich zu anderen Halogenen elektropositiveren Charakters wird es von Silber nur unvollständig ausgefällt
+Dafür existiert das komplexstabilisierte Kation AtPy<num> PyPyridin wodurch Astat auch kathodisch abgeschieden werden kann
+Nachgewiesen wurde auch das Hydrid Astatwasserstoff HAt
+Sicherheitshinweise
+Einstufungen nach der CLP-Verordnung liegen nicht vor weil diese nur die chemische Gefährlichkeit umfassen und eine völlig untergeordnete Rolle gegenüber den auf der Radioaktivität beruhenden Gefahren spielen
+Auch Letzteres gilt nur wenn es sich um eine dafür relevante Stoffmenge handelt
+Literatur
+Eric Scerri A tale of seven elements Oxford University Press Oxford <num>
+Einzelnachweise
+Weblinks
+Wolfgang W Merkel
+in Weltde Datum <num> September <num> abgerufen am <num> September <num> Fred Allison Edgar J Murphy Edna R Bishop Anna L Sommer Evidence of the Detection of Element <num> in Certain Substances In Phys Rev <num> <num> S <num>-<num>
+R F Trimble What happened to alabamine virginium and illinium In J Chem Educ <num> <num> S <num> <num> Astatine Alice Leigh-Smith Walter Minder Experimental Evidence of the Existence of Element <num> in the Thorium Family In Nature <num> <num> S <num>-<num>
+D R Corson K R MacKenzie E Segrè Artificially Radioactive Element <num> In Phys Rev <num> <num> S <num>-<num>
+Berta Karlik Traude Bernert Eine neue natürliche α-Strahlung In Naturwissenschaften <num> <num> <num>-<num> S <num>-<num>
+Berta Karlik Traude Bernert Das Element <num> in den natürlichen Zerfallsreihen In Zeitschrift für Physik <num> <num> <num>-<num> S <num>-<num>
+Welt der Physik
+Deutsche Physikalische Gesellschaft eV über das Ionisationspotential von Astat <num>
+Als Alkalimetalle werden die chemischen Elemente Lithium Natrium Kalium Rubidium Caesium und Francium aus der <num> Hauptgruppe des Periodensystems bezeichnet
+Sie sind silbrig glänzende reaktive Metalle die in ihrer Valenzschale ein einzelnes Elektron besitzen
+Obwohl Wasserstoff in den meisten Darstellungen des Periodensystems in der ersten Hauptgruppe steht und zum Teil ähnliche chemische Eigenschaften wie die Alkalimetalle aufweist kann er nicht zu diesen gezählt werden da er unter Standardbedingungen weder fest ist noch metallische Eigenschaften aufweist
+Erklärung des Namens
+Der Name der Alkalimetalle leitet sich von dem arabischen Wort
+für Pottasche ab die alte Bezeichnung für aus Pflanzenaschen gewonnenes Kaliumcarbonat
+Humphry Davy stellte im Jahre <num> erstmals das Element Kalium durch eine Schmelzflusselektrolyse aus Kaliumhydroxid dar
+Letzteres gewann er aus Kaliumcarbonat
+In einigen Sprachen spiegelt sich dies im Namen wider
+So heißt Kalium beispielsweise im Englischen und Französischen potassium und im Italienischen potassio
+Eigenschaften
+DateiAlkalimetallejpg
+Alkalimetalle sind metallisch glänzende silbrig-weiße Ausnahme Caesium hat bei geringster Verunreinigung einen Goldton weiche Leichtmetalle
+Sie sind mit dem Messer schneidbar
+Alkalimetalle haben eine geringe Dichte
+Sie reagieren mit vielen Stoffen so beispielsweise mit Wasser Luft oder Halogenen teilweise äußerst heftig unter starker Wärmeentwicklung
+Insbesondere die schwereren Alkalimetalle können sich an der Luft selbst entzünden
+Daher werden sie unter Schutzflüssigkeiten wie Paraffin oder Petroleum Lithium Natrium und Kalium bzw unter Luftabschluss in Ampullen Rubidium und Caesium aufbewahrt
+Als Elemente der ersten Gruppe des Periodensystems besitzen sie nur ein schwach gebundenes s-Elektron das sie leicht abgeben
+Ihre ersten Ionisierungsenergien und ihre Elektronegativitäten sind entsprechend klein
+In Verbindungen kommen sie alle fast ausschließlich als einwertige Kationen vor wenngleich sogar Verbindungen bekannt sind in denen diese Metalle anionisch vorliegen z B
+Natride komplexiert mit sogenannten Kryptanden
+Alkalimetalle und ihre Salze besitzen eine spezifische Flammenfärbung
+Lithium und seine Salze färben die Flamme rot <num> nm
+Natrium und seine Salze färben die Flamme gelb <num> nm
+Kalium und seine Salze färben die Flamme violett <num> und <num> nm
+Rubidium und seine Salze färben die Flamme rot <num> und <num> nm
+Caesium und seine Salze färben die Flamme blauviolett <num> nm
+Aufgrund dieser Flammenfärbung werden Alkalimetallverbindungen für Feuerwerke benutzt
+In der Atomphysik werden Alkalimetalle eingesetzt da sie sich aufgrund ihrer besonders einfachen elektronischen Struktur besonders leicht mit Lasern kühlen lassen
+Alle Alkalimetalle kristallisieren in der kubisch-raumzentrierten Struktur
+Lediglich Lithium und Natrium kristallisieren in der hexagonal-dichtesten Packung wenn tiefe Temperaturen vorherrschen
+Trends
+Der Radius der Elementatome sowie der Kationen nimmt mit steigender Massenzahl zu
+Viele andere Eigenschaften der Alkalimetalle zeigen einen Trend innerhalb der Gruppe von oben nach unten
+Abnahme der Härte Ionisierungsenergie Elektronegativität Schmelz- und Siedepunkte
+Zunahme der Reaktivität Basizität und Dichte
+Reaktionsverhalten und Verbindungen
+Die Alkalimetalle reagieren mit Wasserstoff unter Bildung salzartiger Alkalimetallhydride
+<num> Me
+H_<num> -> <num> MeH
+Die thermische Beständigkeit der Hydride nimmt vom Lithiumhydrid LiH zum Caesiumhydrid CsH ab
+Alkalihydride werden u a als Reduktions- oder Trockenmittel eingesetzt
+Mit Sauerstoff reagieren die Metalle unter Bildung fester weißer Alkalimetalloxide Lithiumoxid Alkalimetallperoxide Natriumperoxid und Alkalimetallhyperoxide Kaliumhyperoxid Rubidiumhyperoxid Caesiumhyperoxid
+<num> Li
+O_<num> -> <num> Li_<num>O
+<num> Na
+O_<num> -> Na_<num>O_<num>
+<num> Na
+O_<num> -> Na_<num>O
+M
+O_<num> -> MO_<num> M
+K Rb Cs
+DateiPotassium water <num>theoraogv Die Reaktion mit Wasser zu Alkalimetallhydroxiden erfolgt unter Freisetzung von Wasserstoff
+<num> M
+<num> H_<num>O -> <num> MOH
+H_<num>
+Vom Lithium zum Caesium steigt die Reaktivität stark an
+Während eine annähernd kubische Probe von Lithium relativ träge reagiert entzündet sich schon bei Natrium aufgrund der Hitzeentwicklung der entstehende Wasserstoff unter Anwesenheit von Luftsauerstoff
+Ab dem Kalium erfolgt bei fortschreitender Reaktion auch Verdampfung und Entflammung des Metalls nicht zuletzt auch wegen des mit der Ordnungszahl abnehmenden Siedepunkts siehe oben
+Aber auch unter Luftabschluss können schon weniger als <num> g Natrium explosiv mit Wasser reagieren was eigentlich durch die an der Kontaktfläche der Edukte entstehenden Reaktionsprodukte Wasserstoff und Alkalimetalhydroxid gehemmt werden sollte
+Hochgeschwindigkeitsaufnahmen eines Experiments bei dem Tropfen einer unter Standardbedingungen flüssigen Legierung aus Kalium und Natrium unter einer Inertgas-Atmosphäre mit Wasser in Kontakt gebracht wurden legen eine initial erfolgende Coulomb-Explosion negative Oberflächenspannung bzw die damit einhergehende starke Oberflächenvergrößerung der mit Ausnahme von Lithium nach kurzer Zeit schmelzflüssigen unlegierten Alkalimetallproben als Ursache für den ungehemmten Ablauf die hohe Geschwindigkeit und damit die Heftigkeit dieser Reaktionen nahe Die Alkalimetallhydroxide sind farblose Feststoffe die sich in Wasser unter starker Erwärmung leicht lösen und dabei stark basisch reagieren
+Die Hydroxide und ihre Lösungen wirken stark ätzend
+Mit Halogenen reagieren die Alkalimetalle zu den salzartigen
+Alkalimetallhalogeniden
+<num> Me
+X_<num> -> <num> MeX
+Die Reaktivität steigt vom Lithium zum Caesium und sinkt vom Fluor zum Iod
+So reagiert Natrium mit Iod kaum und mit Brom sehr langsam während die Reaktion von Kalium mit Brom und Iod explosionsartig erfolgt
+Alkalimetalle können Halogenkohlenwasserstoffen unter Explosionserscheinungen das Halogen unter Bildung von Kohlenstoff und dem entsprechenden Alkalimetallhalogenid entziehen
+CCl_<num>
+<num> Na -> <num> NaCl
+C
+Alkalimetalle ergeben mit flüssigem Ammoniak intensiv blau gefärbte Lösungen
+Diese Lösungen die aus positiven Alkalimetall-Ionen und solvatisierten Elektronen besteht sind ein sehr starkes Reduktionsmittel und werden beispielsweise für die Birch-Reduktion eingesetzt
+Wird diesen Lösungen ein geeigneter Komplexbildner zugesetzt können sich entsprechende Salze mit Alkalimetall-Anionen die sogenannten Alkalide bilden
+Wasserstoff
+Wasserstoff das erste Element der <num> Hauptgruppe ist unter Normalbedingungen ein Nichtmetall
+Er wird deshalb nicht zu den Alkalimetallen gezählt teilt jedoch mit ihnen einige Eigenschaften
+Wasserstoff tritt wie die Alkalimetalle stets einwertig auf und wandelt sich unter extrem hohem Druck in eine metallische Hochdruckmodifikation um den metallischen Wasserstoff
+Umgekehrt haben auch einige Alkalimetalle unter bestimmten Bedingungen Eigenschaften wie Wasserstoff z B
+besteht Lithium als Gas zu <num>
+aus zweiatomigen Molekülen
+Literatur
+A G Sharpe et al Inorganic Chemistry second edition - ISBN <num>-<num>-<num>-<num> - Kapitel <num> Group <num> the alkali metals
+Handbuch der experimentellen Chemie Sekundarbereich II Band <num> Alkali- und Erdalkalimetalle Halogene Aulis Verlag Deubner
+Co KG Köln
+Weblinks
+Pink-Panther-Reaktion Reaktion von Natrium mit Wasser auf Video
+Die Alkalimetalle Beschreibung der Alkalimetalle mit vielen Abbildungen
+High speed camera reveals why sodium explodes Video zur Ursache der heftigen Reaktion von Alkalimetallen mit Wasser unter Luftabschluss auf dem YouTube-Kanal Thunderf<num>t des Hauptautors des Nature-chemistry-Artikels englisch
+Einzelnachweise
+P E Mason F Uhlig V Vaněk T Buttersack S Bauerecker P Jungwirth Coulomb explosion during the early stages of the reaction of alkali metals with water In Nature chemistry Band <num> Nummer <num> März <num> S <num>-<num>
+PMID <num>
+Actinoide
+Actiniumähnliche griech Endung -οειδής -oeides ähnlich ist eine Gruppenbezeichnung bestimmter ähnlicher Elemente
+Zugerechnet werden ihr das Actinium und die <num> im Periodensystem folgenden Elemente Thorium Protactinium Uran und die Transurane Neptunium Plutonium Americium Curium Berkelium Californium Einsteinium Fermium Mendelevium Nobelium und Lawrencium
+Im Sinne des Begriffs gehört Actinium nicht zu den Actiniumähnlichen jedoch folgt die Nomenklatur der IUPAC hier dem praktischen Gebrauch
+Die frühere Bezeichnung Actinide entspricht nicht dem Vorschlag der Nomenklaturkommission da nach diesem die Endung -id für binäre Verbindungen wie z B
+Chloride reserviert ist die Bezeichnung ist aber weiterhin erlaubt
+Alle Actinoide sind Metalle und werden auch als Elemente der Actiniumreihe bezeichnet
+Begriffliche Abgrenzung
+Die Transurane sind die Elemente mit einer höheren Ordnungszahl als Uran d h
+die Actinoide beginnend mit Neptunium <num> sind auch Transurane
+Als Transactinoide bezeichnet man die Elemente mit Ordnungszahlen ab <num> Rutherfordium
+Sie folgen im Periodensystem auf die Actinoide
+Alle Transactinoide sind auch gleichzeitig Transurane da sie Ordnungszahlen größer als die des Urans haben
+Im Zusammenhang mit Kernbrennstoffen und radioaktivem Abfall werden Neptunium Americium Curium Berkelium und Californium auch als minore Actinoide bezeichnet
+Die Actinoid-Nuklide sind Schwermetalle
+In der Reaktorphysik wird bei Abbrandberechnungen der Schwermetall-Begriff etwas eingeschränkt
+Als Schwermetalle bezeichnet man in diesem Zusammenhang nur die durch Neutronen spaltbaren Schwermetall-Nuklide
+Spaltbar sind alle Schwermetall-Nuklide ab Actinium <num> also auch alle Nuklide der Actinoiden
+Massen von Spaltprodukten und Massen der überwiegend durch Neutroneneinfang in einem Kernreaktor entstandenen schweren Nuklide werden meist relativ zur Masse der anfangs eingesetzten so definierten Schwermetalle angegeben
+Entdeckung und Gewinnung
+Im Jahr <num> publizierte die deutsche Chemikerin Ida Noddack eine Arbeit über drei Lücken im Periodischen System der Elemente die später mit den Elementen Francium Astat und Promethium gefüllt wurden
+Gleichsam nebenbei merkte sie an dass es denkbar sei dass bei der Beschießung schwerer Kerne mit Neutronen diese Kerne in mehrere größere Bruchstücke zerfallen
+Aber nicht nur das
+Denkbar sei auch dass Elemente mit Ordnungszahlen Z > <num> also Transurane gebildet werden könnten
+Tatsächlich synthetisierten Edwin M McMillan und Philip H Abelson erstmals im Jahr <num> die ersten nicht in der Natur vorkommenden Actinoid-Nuklide <num>U <num>Np und <num>Pu durch Beschuss von Uran mit Neutronen
+Da im Jahr <num> noch kein Kernreaktor in Betrieb war konnten die Neutronen nur aus einer Neutronenquelle stammen
+Obwohl bei dieser Kernreaktion letztlich auch ein Plutonium-Isotop entsteht konnte Plutonium wahrscheinlich wegen der geringen Ausbeute noch nicht nachgewiesen werden
+Als Entdeckungsjahr von Plutonium gilt das Jahr <num> wie die Tabelle Entdeckung der Transurane zeigt
+Plutonium wurde von den US-Amerikanern Glenn T Seaborg J W Kennedy E M McMillan Michael Cefola und Arthur Wahl entdeckt
+Ende <num> stellten sie das Plutonium-Isotop <num>Pu durch Beschuss des Uran-Isotops <num>U mit Deuteronen her die in einem Zyklotron beschleunigt worden waren
+Nachdem der eindeutige Nachweis für das Element <num> erbracht worden war erhielt es <num> den Namen Plutonium
+Der Name lag nahe da die beiden Vorgängerelemente nach den Planeten Uranus und Neptun benannt worden waren
+Details über die Kernreaktionen sind im Artikel
+Plutonium
+nachzulesen
+Damit eine Transmutation mit elektrisch geladenen Teilchen wie Deuteronen stattfinden kann müssen diese Teilchen auf eine Energie beschleunigt werden die ausreicht um die Coulombbarriere von Urankernen zu überwinden oder diese zumindest zu durchtunneln
+Das war erstmals mit einem Zyklotron möglich
+Die erste wägbare Menge Plutonium von etwa <num> µg wurde <num> isoliert
+DateiStagg Field reactorjpg Ende <num> wurde der erste Kernreaktor Chicago Pile in Betrieb genommen
+Mit Kernreaktoren konnten vergleichsweise größere Mengen der Elemente Plutonium und Americium gewonnen werden die als Targetmaterial dienten
+In Verbindung mit geladenen Teilchen mit beschleunigten α-Teilchen wurden dann die Nuklide der Elemente Curium Berkelium und Californium entdeckt
+Der Vorteil des Verfahrens der Beschuss beschleunigter geladener Teilchen auf leichtere Actinoide ist dass auch massereiche neutronenarme Nuklide erhalten werden können die durch eine Neutronenbestrahlung nicht gebildet werden
+Das effektivste Verfahren um synthetische Actinoide zu erzeugen ist die Transmutation von Uran- oder Thorium-Nukliden im Kernbrennstoff eines Kernreaktors durch Neutroneneinfang oder n<num>n-Reaktionen
+Dieses Verfahren ist auf nicht allzu massereiche Actinoid-Nuklide beschränkt etwa bis zu Massenzahlen von A
+<num>
+Rechnerisch s u werden meist nur Nuklide bis A <
+<num> einbezogen
+Americium zum Beispiel wurde in einem Zweistufenprozess entdeckt
+In der ersten Stufe werden synthetische Actinoide in einem Kernreaktor gebildet zum Beispiel <num>Pu
+Plutonium wird nach Entnahme des Kernbrennstoffs durch Wiederaufarbeitung chemisch extrahiert
+Dann wird das Plutonium erneut im Reaktor oder mittels einer Quelle mit Neutronen bestrahlt
+Der gegenwärtig betriebene <num> MW High-Flux-Isotope Reactor am Oak Ridge National Laboratory in Tennessee USA ist auf die Herstellung von Transcuriumelementen Z > <num> speziell ausgelegt
+Die massereichen Elemente Einsteinium und Fermium wurden durch den Test der ersten amerikanischen Wasserstoffbombe Ivy Mike am <num> November <num> auf dem Eniwetok-Atoll auf unsere Erde gebracht
+Nur wenige Wochen später wurden sie im Lawrence Berkeley National Laboratory das an der geheimen Waffentwicklung nicht beteiligt war auf Filterpapieren und in Ablagerungen an Korallen völlig unerwartet entdeckt Bei der Wasserstoffbombenexplosion waren bis zu <num> Neutronen von einem Kern von <num>U eingefangen worden
+Dieser Zwischenkern zerfiel sehr schnell über eine Kette von Betazerfällen in Nuklide der bis dahin unbekannten Elemente
+Das Uran stammte aus der Ummantelung der Wasserstoffbombe die aus fünf Tonnen Natururan bestand
+Aus Gründen der militärischen Geheimhaltung durften die Ergebnisse zunächst nicht publiziert werden
+Um sich dennoch die Priorität der Entdeckungen der beiden neuen Elemente zu sichern wurden parallel erfolgreich Schwerionenreaktionen durchgeführt
+<num>U wurde mit <num>N-Ionen die an einem Zyklotron erzeugt wurden bombardiert
+Auf diesem Wege wurde zunächst Einsteinium synthetisiert und in der Publikation auf die Entdeckung von <num> verwiesen
+Ähnlich verfuhr man mit Fermium das durch Beschuss mit <num>Pu mit <num>N-Ionen erzeugt wurde
+Wie die Tabelle zeigt führten Schwerionenreaktionen auch zu den Elementen Mendelevium Nobelium und Lawrencium mit den Ordnungszahlen <num> bis <num>
+Mit Schwerionenreaktionen wurden auch die Elemente mit höheren Ordnungszahlen synthetisiert
+Bildung und Gewinnung im Kernreaktor
+Der Kernreaktor nimmt was die Actinoide betrifft nicht nur deshalb eine herausragende Stellung ein weil er ohne Actinoide nicht betrieben werden könnte sondern weil es nur innerhalb eines Kernreaktors möglich ist größere wägbare Mengen von höheren Actinoid-Nukliden zu bilden
+Dieser Abschnitt beschreibt welche Actinoid-Nuklide das sind und in welchem Massenanteil relativ zur ursprünglichen Schwermetallmasse sie gebildet werden
+In einem Kernreaktor werden zu Beginn des Betriebs große Mengen von Actinoiden in Form von Kernbrennstoff eingebracht zum Beispiel mit <num>U angereichertes Uran
+In einem Leistungsreaktor sind Aktinoidmassen in der Größenordnung von <num> t erthalten Aus diesem Kernbrennstoff werden neben der gewünschten Energiefreisetzung durch Kernspaltung synthetische höhere Actinoide durch Transmutation erzeugt
+Actinoid-Nuklide in einem Kernreaktor
+DateiActinide Buildup Chart <num>apng
+Die Abbildung Nuklidkarte Bildung und Zerfall von Actinoiden in einem Kernreaktor ist eine Nuklidkarte in der Anordnung nach Segrè
+Das heißt die Anzahl der Neutronen wird nach rechts zunehmend die Anzahl der Protonen nach oben zunehmend aufgetragen
+Um die Zeichnungsfläche sinnvoll zu nutzen ist der Nuklidpfad am roten Punkt unterteilt
+Jedes Quadrat der Abbildung stellt ein Actinoid-Nuklid dar das in einem Kernreaktor auftreten kann
+Die Abbildung zeigt auch das Netzwerk von Bildung und Zerfall von Actinoid-Nukliden ausgelöst durch den Neutroneneinfang freier Neutronen und durch andere Kernreaktionen
+Ein ähnliches Schema findet man in einer Arbeit aus dem Jahr <num>
+Dort sind die Isotope von Thorium und Protactinium die zum Beispiel in Salzschmelzenreaktoren eine große Rolle spielen und die Isotope der Elemente Berkelium und Californium nicht enthalten
+Die Bildung von Actinoid-Nukliden wird in erster Linie geprägt durch
+Neutroneneinfang-Reaktionen nγ die in der Abbildung durch einen kurzen Rechtspfeil dargestellt sind
+Berücksichtigt werden aber auch die n<num>n-Reaktionen und die seltener auftretenden gγ-Reaktionen die beide durch einen kurzen Linkspfeil markiert sind
+Noch seltener und nur ausgelöst von schnellen Neutronen tritt die n<num>n-Reaktion auf die in der Abbildung mit einem Beispiel vertreten ist markiert durch einen langen Linkspfeil
+Außer diesen neutronen- oder gammainduzierten Kernreaktionen wirkt sich auch die radioaktive Umwandlung der Actinoid-Nuklide auf den Nuklid-Bestand in einem Reaktor zu einem gegebenen Zeitpunkt Abbrandzustand aus
+Diese Zerfallsarten sind in der Abbildung durch Diagonalpfeile markiert
+Eine große Rolle für die Bilanz der Teilchendichten der Nuklide spielt der Beta-Minus-Zerfall markiert mit aufwärts zeigenden Diagonalpfeilen
+Die Quadrate der Nuklide dieses Zerfallstyps haben in der Nuklidkarte eine hellblaue Füllfarbe
+Zwei Nuklide sind nur zum Teil betaaktiv
+Das rosafarben hinterlegte Nuklid <num>Np wandelt sich zu <num>
+durch Elektroneneinfang und zu <num>
+durch Beta-Minus-Zerfall hellblaue Ecke um
+Ebenfalls zwei Zerfallsarten aber in nahezu umgekehrtem Verhältnis <num>
+Beta-Minus-Zerfall <num>
+Elektroneneinfang zeigt auch der Grundzustand von <num>Am rosa Ecke
+Dieses Nuklid besitzt außerdem einen langlebigen metastabilen Zustand weiß hinterlegt der in der Regel durch <num>m<num>Am symbolisiert wird
+Nuklide mit Positronen-Emissionen Beta-Plus-Zerfälle kommen in einem Kernreaktor nicht vor
+Die Actinoid-Nuklide die sich unter Aussendung von α-Teilchen spontan umwandeln sind in der Nuklidkarte der Abbildung mit einer gelben Füllfarbe versehen worden
+Der α-Zerfall spielt wegen der langen Halbwertszeiten T<num><num> bei Bildung und Zerfall der Actinoide während der Aufenthaltsdauer des Brennstoffs in einem Leistungsreaktor max ca <num> Jahre so gut wie keine Rolle
+Ausnahmen sind die beiden relativ kurzlebigen Nuklide <num>Cm T<num><num>
+<num> d und <num>Pu T<num><num>
+<num> a
+Nur für diese beiden Fälle ist der α-Zerfall durch lange abwärts zeigende Pfeile auf der Nuklidkarte markiert
+Alle in der Abbildung angegebenen Halbwertszeiten sind die aktuellen evaluierten Nukleardaten NUBASE<num> abgerufen über den Nukleardaten-Viewer JANIS <num> Manche Halbwertszeiten sind gerundet
+Zur Bedeutung von Abbrandprogrammen
+Nur bei der ersten Inbetriebnahme des Reaktors kennt man die Zusammensetzung an Nukliden des Kernbrennstoffs genau
+Es ist aber für jeden Zeitpunkt Abbrandzustand erforderlich grundlegende physikalische Größen wie den Neutronenfluss zu kennen
+Zu den grundlegenden physikalischen Größen gehören auch die Teilchendichten und
+Massendichten
+aller im Reaktor gebildeten Actinoid-Nuklide
+Das betrifft sowohl die der anfangs eingebrachten oder was davon noch vorhanden ist als auch die der im Reaktorbetrieb gebildeten Nuklide
+Die tatsächlichen Teilchendichten und Massendichten der Actinoid-Nuklide in Abhängigkeit vom Abbrand im laufenden Betrieb zu messen ist nicht möglich
+Erst nach der Entladung von Kernbrennstoff können diese Größen im Prinzip chemisch oder massenspektrometrisch untersucht werden
+Das ist sehr aufwendig
+Deshalb kommt einer Berechnung die den Betriebsablauf eines Kernreaktors begleitet ein hoher Stellenwert zu
+Die Entwicklung der Teilchendichten und Massendichten von Nukliden in einem Kernreaktor wird in Abhängigkeit vom mittleren Abbrand engl Burnup Depletion vereinfacht in sog Abbrandprogrammen berechnet zum Beispiel
+ORIGEN das erste weltweit verbreitete Programm zur Berechnung der Nuklidbildungen in Abhängigkeit vom Abbrand aus dem Jahr <num>
+OrigenArp ein Programm zur Berechnung der Teilchendichten von Nukliden in Abhängigkeit vom Abbrand aus dem Jahr <num> das auch in das Programmsystem SCALE s u integriert ist
+Für eine detaillierte Analyse werden hochkomplexe Reaktorprogrammsysteme Neutronen-Transportprogramme eingesetzt deren Leistungsumfang weit über den der zuvor genannten Programme hinausgeht und deren Anwendung eine lange Einarbeitungszeit erfordert zum Beispiel
+SCALE ein großes Programmsystem für unterschiedliche neutronenphysikalische Berechnungen so u a auch für Abbrand- und Abschirmrechnungen
+HELIOS ein Zell- und Abbrandprogrammsystem für Berechnungen in Neutronen-Transportnäherung
+In letzteren Programmsystemen sind neben der anfänglichen Materialzusammensetzung auch geometrische Details von Reaktorbauteilen Zellen vorzugeben
+Von Zeit zu Zeit werden solche Rechnungen mit den Ergebnissen von chemischer und massenspektrometrischer Analyse von entladenem Kernbrennstoff verglichen und gegebenenfalls genauere Messungen noch unsicherer Nukleardaten oder genauere Berechnungsmethoden angestoßen
+Entwicklung der Massen der Actinoide im Kernreaktor
+DateiActinide Masses <num>apng
+Die Abbildung Entwicklung der Massen der Actinoiden
+zeigt die Zu- oder Abnahme der Massen der <num> häufigsten Actinoid-Nuklide in einem Druckwasserreaktor der mit angereichertem Uran betrieben wird
+Die Zahlenwerte wurden für eine größere Brennstoff-Zelle in Abhängigkeit vom Abbrand der spezifischen Energiefreisetzung berechnet
+Die Berechnungen wurden im Jahr <num> mit dem Programmsystem HELIOS <num> ausgeführt Als Anfangsanreicherung des Nuklids <num>U wurde für dieses Beispiel <num>
+gewählt
+Die Punkte auf den Kurven der Abbildung markieren die Schrittweiten in der Abbrandrechnung
+Die Schrittweite ist anfangs kleiner um auch diejenigen Spaltprodukte genauer zu erfassen die ihre Sättigung sehr schnell erreichen
+Das trifft vor allem auf die starken Neutronenabsorber <num>Xe und <num>Sm zu
+Eine ähnliche Abbildung eingeschränkt auf Uran- und Plutonium-Isotope findet man im Lehrbuch Neutron Physics von Paul Reuss
+Die Masse jedes Nuklids wird durch die anfangs eingesetzte Masse an Schwermetall der Masse des Urans geteilt
+Dargestellt sind die Massenanteile aller Nuklide die anfangs vorhanden waren drei Uran-Nuklide oder die mit einer Masse von mindestens <num> g pro eingesetzter Tonne Schwermetall nach einem Abbrand von maximal <num> MWdkg gebildet werden
+Wie die Abbildung zeigt nehmen die Massen der drei anfangs vorhandenen Uranisotope <num>U <num>U und <num>U mit steigendem Abbrand monoton ab
+Gleichzeitig nehmen die Massen der höheren Actinoide fast linear zu man beachte die logarithmische Skalierung der Ordinate
+Von allen synthetischen Actinoiden nimmt die Masse des Nuklids <num>Pu am stärksten zu
+Damit wächst auch die Anzahl der Spaltungen der Kerne des Nuklids <num>Pu
+Ab einem Abbrand von ca <num> MWdkg nimmt dessen Masse wieder geringfügig ab
+Würde man die Ordinate nach unten auf einen Massenanteil von mindestens <num> g pro eingesetzter Tonne Schwermetall herabsetzen kämen auf der Abbildung ab einem Abrand von ca <num> MWdkg das Nuklid <num>m<num>Am und ab einem Abrand von ca <num> MWdkg das Nuklid <num>Cm hinzu
+Zusammengefasst In einem Druckwasserreaktor mit Uran-Brennelementen ohne MOX-Brennelemente werden aus den ursprünglich vorhandenen Actinoid-Nukliden <num>U und <num>U und einem geringen Anteil <num>U maximal <num> synthetische Actinoid-Nuklide innerhalb der üblichen Betriebszeiten gebildet deren Anteil größer als <num> g je Tonne Startmasse Schwermetall SM ist also <num> ppm Das sind die Nuklide <num>U <num>Np <num>Pu <num>Pu <num>Pu <num>Pu <num>Pu <num>Am <num>m<num>Am <num>Am <num>Cm <num>Cm und <num>Cm
+Nuklide der Elemente Berkelium und Californium werden in einem Kernreaktor ebenfalls aber nur in sehr geringen Mengen gebildet
+Die Actinoide können wie erwähnt durch chemische Aufarbeitung von entladenem Brennstoff extrahiert werden
+Der Massenanteil von Curium zum Beispiel beträgt ca <num> bei einem gegenwärtig üblichen Abbrand von <num> MWdkg
+wobei
+die Masse des Curiums und
+die Startmasse des Schwermetalls bedeuten
+In einem Leistungsreaktor beträgt die anfängliche Schwermetallmasse ca
+verteilt auf <num> Brennelemente
+Angenommen alle Brennelemente seien entladen worden die diesen Abbrandzustand erreicht haben
+Folglich ist die Masse des Curiums
+Im gesamten Reaktor sind bei diesem mittleren Abbrand im Brennstoff ca <num> kg Curium entstanden
+Anzumerken ist dass Leistungsreaktoren nicht betrieben werden um Actinoide zu gewinnen sondern um möglichst viele Actinoide zu spalten und Energie freizusetzen
+Die Gesamtmasse aller Actinoide verringert sich durch Kernspaltung und zwar bei einem mittleren Abbrand von <num> MWdkg um insgesamt nur ca <num>
+Diese findet sich in der Masse der Spaltprodukte wieder
+Eigenschaften
+Nukleare Eigenschaften
+Die hervorgehobene Stellung der Actinoide man denke an ihre Bedeutung zur nuklearen Energiefreisetzung und an Kernwaffen werden durch die Eigenschaften ihrer Atomkerne determiniert
+Alle Actinoid-Nuklide sind radioaktiv
+Alle Actinoid-Nuklide sind neutroneninduziert spaltbar wenn auch mit sehr unterschiedlichen Wirkungsquerschnitten die außerdem sehr stark von der kinetischen Energie der Neutronen abhängen
+Die vier Actinoid-Nuklide <num>Th <num>U <num>U und <num>U kommen natürlich vor
+Ihre Quadrate sind in der obigen Nuklidkarte durch eine dickere Umrandung hervorgehoben
+Mit Ausnahme von <num>U sind es primordiale Nuklide also Nuklide die schon bei der Entstehung der Erde vorhanden waren und noch nicht vollständig zerfallen sind
+Das natürlich vorkommende extrem seltene primodiale Plutonium-Nuklid <num>Pu spielt im Kernreaktor keine Rolle
+Sein Massenanteil in einigen Erzen liegt bei <num>-<num>
+Im Jahr <num> waren mehr als <num> synthetisch erzeugte Actinoid-Nuklide bekannt Die meisten besitzen kurze Halbwertszeiten
+Nur <num> haben Halbwertszeiten T<num><num> > <num> d
+Von <num> Actinoid-Nukliden wird angenommen dass sie zu einer sich selbsterhaltenden Kettenreaktion fähig sind Andere Quellen gehen von weniger Actinoid-Nukliden aus für die es eine kritische Masse gibt
+Für die sechs Actinoid-Nuklide <num>U <num>U <num>U <num>Pu <num>Pu und <num>Pu sind die Wirkungsquerschnitte relativ genau bekannt für alle anderen sind die Nukleardaten weniger genau Auf Kritikalitätsberechnungen wirken sich diese Ungenauigkeiten aber kaum aus
+Je weniger Masse eines Nuklids sich im Kernreaktor befindet desto geringer ist die Auswirkung fehlerhafter Wirkungsquerschnitte auf solche Berechnungen
+Klassische physikalische Eigenschaften
+Einige physikalische Eigenschaften der Actinoid-Elemente findet man unter dem Stichwort der Namen der Elemente
+Die Voraussetzung dafür dass klassische physikalische Eigenschaften zum Beispiel Kristallstruktur Massendichte Schmelzpunkt Siedepunkt oder elektrische Leitfähigkeit gemessen werden können ist es dass das Element in wägbaren Mengen gewonnen werden kann
+Die Anzahl der tatsächlich gemessenen physikalischen Eigenschaften nimmt mit wachsender Ordnungszahl des Elements schnell ab
+Zum Beispiel ist Californium das letzte Actinoid-Element von dem die Massendichte gemessen werden konnte
+Zur Atomphysik der Actinoide ist anzumerken
+Alle Actinoide sind wie oben erwähnt Schwermetalle
+Einige Actinoide sind in feinverteiltem Zustand pyrophor
+Actinoide gehören wie die Lanthanoide zu den inneren Übergangselementen oder
+f-Block-Elementen da in diesen Reihen die f-Unterschalen mit Elektronen aufgefüllt werden
+Chemische Eigenschaften
+Alle Actinoide bilden dreifach geladene Ionen sie werden wie das Actinium als Untergruppe der <num> Nebengruppe aufgefasst
+Die leichteren Actinoide Thorium bis Americium kommen in einer größeren Anzahl von Oxidationszahlen vor als die entsprechenden Lanthanoide
+Farben der Actinoid-Ionen in wässriger Lösung
+Verbindungen
+Die Eigenschaften beziehen sich auf das häufigste bzw stabilste Isotop
+Oxide
+Die vierwertigen Oxide der Actinoide kristallisieren im kubischen Kristallsystem der Strukturtyp ist der CaF<sub><num><sub>-Typ Fluorit mit der
+und den Koordinationszahlen An<num> O<num>
+Halogenide
+Die dreiwertigen Chloride der Actinoide kristallisieren im hexagonalen Kristallsystem
+Die Struktur des UranIII-chlorids ist die Leitstruktur für eine Reihe weiterer Verbindungen
+In dieser werden die Metallatome von je neun Chloratomen umgeben
+Als Koordinationspolyeder ergibt sich dabei ein dreifach überkapptes trigonales Prisma wie es auch bei den späteren Actinoiden und den Lanthanoiden häufig anzutreffen ist
+Es kristallisiert im hexagonalen Kristallsystem in der
+und zwei Formeleinheiten pro Elementarzelle
+Siehe auch
+Lanthanoide
+Einzelnachweise
+Literatur
+Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements
+Springer Dordrecht <num> ISBN <num>-<num>-<num>-<num>
+Harold W Kirby Lester R Morss Actinium S <num>-<num>
+Mathias S Wickleder Blandine Fourest Peter K Dorhout Thorium S <num>-<num>
+Boris F Myasoedov Harold W Kirby Ivan G Tananaev Protactinium S <num>-<num>
+Ingmar Grenthe Janusz Drożdżynński Takeo Fujino Edgar C Buck Thomas E Albrecht-Schmitt Stephen F Wolf Uranium S <num>-<num>
+Zenko Yoshida Stephen G Johnson Takaumi Kimura John R Krsul Neptunium S <num>-<num>
+David L Clark Siegfried S Hecker Gordon D Jarvinen Mary P Neu Plutonium S <num>-<num>
+Wolfgang H Runde Wallace W Schulz Americium S <num>-<num>
+Gregg J Lumetta Major C Thompson Robert A Penneman P Gary Eller Curium S <num>-<num>
+David E Hobart Joseph R Peterson Berkelium S <num>-<num>
+Richard G Haire Californium S <num>-<num>
+Richard G Haire Einsteinium S <num>-<num>
+Robert J Silva Fermium Mendelevium Nobelium and Lawrencium S <num>-<num>
+James E Huheey Anorganische Chemie
+de Gruyter Berlin <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Norman N Greenwood Alan Earnshaw Chemie der Elemente
+<num> Auflage
+VCH Weinheim <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+dtv-Atlas zur Chemie Teil <num> <num> S <num>-<num>
+Weblinks
+Ida Noddack Das Periodische System der Elemente und seine Lücken in
+Angewandte Chemie
+<num> <num> <num> S <num>-<num> doi<num>ange<num>
+E McMillan P H Abelson Radioactive Element <num> in
+Physical Review
+<num> <num> S <num>-<num> doi<num>PhysRev<num><num>
+B B Cunningham L B Werner The First Isolation Of Plutonium In
+Journal of the American Chemical Society <num> <num> <num> S <num>-<num> doi<num>ja<num>a<num>
+High Flux Isotope Reactor Oak Ridge National Laboratory abgerufen am <num> November <num>
+Albert Ghiorso
+Chemical
+Engineering News <num>
+Die Schwermetallmasse ist nicht für jeden Leistungsreaktor leicht zu finden Im Artikel
+wird die Schwermetallmasse mit <num> t angegeben verteilt auf <num> Brennelemente Das dürfte auch auf die anderen Leistungsreaktoren der Bauform
+näherungsweise zutreffen
+Janis <num> - Java-based Nuclear Data Information System
+RK PWR-Calculations with the Code-System HELIOS <num> Studsvik <num> International Users Group Meeting Charlotte NC USA June <num>-<num> <num>
+Die Zusammenfassung findet sich im INIS Repository httpsinisiaeaorgsearchsearchaspxorig_qRN<num> Wolfgang Liebscher Ekkehard Fluck Die systematische Nomenklatur der anorganischen Chemie Springer Berlin <num> ISBN <num>-<num>-<num>-X
+Neil G Connelly Red Nomenclature of inorganic chemistry - IUPAC recommendations <num> Royal Society of Chemistry Cambridge <num> ISBN <num>-<num>-<num>-<num>
+Guttmann Hengge Anorganische Chemie VCH Weinheim
+New York
+Basel
+Cambridge <num>
+dtv-Atlas zur Chemie <num> Teil <num> S <num>
+Die Werte der atomaren und physikalischen Eigenschaften sind wenn nicht anders angegeben aus wwwwebelementscom entnommen
+Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements Bd <num> <num> Springer ISBN <num>-<num>-<num>-<num>
+Americium ist ein chemisches Element mit dem Elementsymbol Am und der Ordnungszahl <num> Im Periodensystem steht es in der Gruppe der Actinoide <num> Periode f-Block und zählt auch zu den Transuranen
+Americium ist neben Europium das einzige nach einem Erdteil benannte Element
+Es ist ein leicht verformbares radioaktives Metall silbrig-weißen Aussehens
+Von Americium gibt es kein stabiles Isotop
+Auf der Erde kommt es ausschließlich in künstlich erzeugter Form vor
+Das Element wurde erstmals im Spätherbst <num> erzeugt die Entdeckung jedoch zunächst nicht veröffentlicht
+Kurioserweise wurde seine Existenz in einer amerikanischen Radiosendung für Kinder durch den Entdecker Glenn T Seaborg den Gast der Sendung der Öffentlichkeit preisgegeben
+Americium wird in Kernreaktoren gebildet eine Tonne abgebrannten Kernbrennstoffs enthält durchschnittlich etwa <num> g des Elements
+Es wird als Quelle ionisierender Strahlung eingesetzt z B
+in der Fluoreszenzspektroskopie und in Ionisationsrauchmeldern
+Das Americiumisotop <num>Am wurde wegen seiner gegenüber Plutonium <num>Pu wesentlich längeren Halbwertszeit von <num> Jahren zur Befüllung von Radionuklidbatterien RTG für Raumsonden vorgeschlagen welche dann hunderte Jahre lang elektrische Energie zum Betrieb bereitstellen würden
+Geschichte
+DateiGlenn Seaborg - <num>jpg DateiBerkeley <num>-inch cyclotrongif
+Americium wurde im Spätherbst <num> von Glenn T Seaborg Ralph A James Leon O Morgan und Albert Ghiorso im <num>-Zoll-Cyclotron an der Universität von Kalifornien in Berkeley sowie am metallurgischen Laboratorium der Universität von Chicago heute Argonne National Laboratory erzeugt
+Nach Neptunium und Plutonium war Americium das vierte Transuran das seit dem Jahr <num> entdeckt wurde das um eine Ordnungszahl höhere Curium wurde als drittes schon im Sommer <num> erzeugt
+Der Name für das Element wurde in Anlehnung zum Erdteil Amerika gewählt - in Analogie zu Europium dem Seltene-Erden-Metall das im Periodensystem genau über Americium steht The name americium after the Americas and the symbol Am are suggested for the element on the basis of its position as the sixth member of the actinide rare-earth series analogous to europium Eu of the lanthanide series
+Zur Erzeugung des neuen Elements wurden in der Regel die Oxide der Ausgangselemente verwendet
+Dazu wurde zunächst Plutoniumnitratlösung mit dem Isotop <num>Pu auf eine Platinfolie von etwa <num> cm<num> aufgetragen die Lösung danach eingedampft und der Rückstand dann zum Oxid PuO<num> geglüht
+Nach dem Beschuss im Cyclotron wurde die Beschichtung mittels Salpetersäure gelöst anschließend wieder mit einer konzentrierten wässrigen Ammoniaklösung als Hydroxid ausgefällt der Rückstand wurde in Perchlorsäure gelöst
+Die weitere Trennung erfolgte mit Ionenaustauschern
+In ihren Versuchsreihen wurden der Reihe nach vier verschiedene Isotope erzeugt <num>Am <num>Am <num>Am und <num>Am
+Als erstes Isotop isolierten sie <num>Am aus einer Plutonium-Probe die mit Neutronen bestrahlt wurde
+Es zerfällt durch Aussendung eines α-Teilchens in <num>Np
+Die Halbwertszeit dieses α-Zerfalls wurde zunächst auf <num>
+<num> Jahre bestimmt der heute allgemein akzeptierte Wert ist <num> a
+Die angegebenen Zeiten sind Halbwertszeiten
+Als zweites Isotop wurde <num>Am durch erneuten Neutronenbeschuss des zuvor erzeugten <num>Am gefunden
+Durch nachfolgenden raschen β-Zerfall entsteht dabei <num>Cm das zuvor schon entdeckte Curium
+Die Halbwertszeit dieses β-Zerfalls wurde zunächst auf <num> Stunden bestimmt der heute als gültig ermittelte Wert beträgt <num> h
+Erstmals öffentlich bekannt gemacht wurde die Entdeckung des Elements in der amerikanischen Radiosendung Quiz Kids am <num> November <num> durch Glenn T Seaborg noch vor der eigentlichen Bekanntmachung bei einem Symposium der American Chemical Society Einer der jungen Zuhörer fragte den Gast der Sendung Seaborg ob während des Zweiten Weltkrieges im Zuge der Erforschung von Nuklearwaffen neue Elemente entdeckt wurden
+Seaborg bejahte die Frage und enthüllte dabei auch gleichzeitig die Entdeckung des nächsthöheren Elements Curium
+Americium <num>Am und <num>Am und seine Produktion wurde später unter dem Namen Element <num> and method of producing said element patentiert wobei als Erfinder nur Glenn T Seaborg angegeben wurde
+In elementarer Form wurde es erstmals im Jahr <num> durch Reduktion von AmericiumIII-fluorid mit Barium dargestellt
+Vorkommen
+Americiumisotope entstehen im r-Prozess in Supernovae und kommen auf der Erde wegen ihrer im Vergleich zum Alter der Erde zu geringen Halbwertszeit nicht natürlich vor
+Heutzutage wird jedoch Americium als Nebenprodukt in Kernkraftwerken erbrütet das Americiumisotop <num>Am entsteht als Zerfallsprodukt u a
+in abgebrannten Brennstäben aus dem Plutoniumisotop <num>Pu
+Eine Tonne abgebrannten Kernbrennstoffs enthält durchschnittlich etwa <num> g verschiedener Americiumisotope Es handelt sich dabei hauptsächlich um die α-Strahler <num>Am und <num>Am die aufgrund ihrer relativ langen Halbwertszeiten in der Endlagerung unerwünscht sind und deshalb zum Transuranabfall zählen
+Eine Verminderung der Langzeitradiotoxizität in nuklearen Endlagern wäre durch Abtrennung langlebiger Isotope aus abgebrannten Kernbrennstoffen möglich
+Zur Beseitigung des Americiums wird derzeit die Partitioning
+Transmutation-Strategie untersucht
+Gewinnung und Darstellung
+Gewinnung von Americiumisotopen
+Americium fällt in geringen Mengen in Kernreaktoren an
+Es steht heute in Mengen von wenigen Kilogramm zur Verfügung
+Durch die aufwändige Gewinnung aus abgebrannten Brennstäben hat es einen sehr hohen Preis
+Seit der Markteinführung <num> soll der Preis für AmericiumIV-oxid mit dem Isotop <num>Am bei etwa <num> US-Dollar pro Gramm liegen Das Americiumisotop <num>Am entsteht in geringeren Mengen im Reaktor aus <num>Am und ist deshalb mit <num> US-Dollar pro Milligramm <num>Am noch wesentlich teurer
+Americium wird über das Plutoniumisotop <num>Pu in Kernreaktoren mit hohem <num>U-Anteil zwangsläufig erbrütet da es aus diesem durch Neutroneneinfang und zwei anschließende β-Zerfälle über <num>U und <num>Np entsteht
+Die angegebenen Zeiten sind Halbwertszeiten
+Danach wird wenn es nicht zur Kernspaltung kommt aus dem <num>Pu neben anderen Nukliden durch stufenweisen Neutroneneinfang nγ und anschließenden β-Zerfall <num>Am oder <num>Am erbrütet
+Das Plutonium welches aus abgebrannten Brennstäben von Leistungsreaktoren gewonnen werden kann besteht zu etwa <num>
+aus dem Isotop <num>Pu Deshalb erreichen erst <num> Jahre nachdem der Brutprozess beendet wurde die abgebrannten Brennstäbe ihren Maximalgehalt von <num>Am danach nimmt der Gehalt wieder langsamer als der Anstieg ab
+Aus dem so entstandenen <num>Am kann durch weiteren Neutroneneinfang im Reaktor <num>Am entstehen
+Bei Leichtwasserreaktoren soll aus dem <num>Am zu <num>
+<num>Am und zu <num>
+<num>m Am entstehen
+zu <num>
+zu <num>
+Für die Erbrütung von <num>Am ist ein vierfacher Neutroneneinfang des <num>Pu erforderlich
+Darstellung elementaren Americiums
+Metallisches Americium kann durch Reduktion aus seinen Verbindungen erhalten werden
+Zuerst wurde AmericiumIII-fluorid zur Reduktion verwendet
+Dieses wird hierzu in wasser- und sauerstofffreier Umgebung in Reaktionsapparaturen aus Tantal und Wolfram mit elementarem Barium zur Reaktion gebracht
+<num> AmF<num>
+<num> Ba -> <num> Am
+<num> BaF<num>
+Auch die Reduktion von AmericiumIV-oxid mittels Lanthan oder Thorium ergibt metallisches Americium
+<num> AmO<num>
+<num> La -> <num> Am
+<num> La<num>O<num>
+Eigenschaften
+DateiAmericium microscopejpg DateiClosest packing ABACpng Im Periodensystem steht das Americium mit der Ordnungszahl <num> in der Reihe der Actinoide sein Vorgänger ist das Plutonium das nachfolgende Element ist das Curium
+Sein Analogon in der Reihe der Lanthanoiden ist das Europium
+Physikalische Eigenschaften
+Americium ist ein radioaktives Metall
+Frisch hergestelltes Americium ist ein silberweißes Metall welches jedoch bei Raumtemperatur langsam matt wird
+Es ist leicht verformbar
+Sein Schmelzpunkt beträgt <num> C der Siedepunkt liegt bei <num> C
+Die Dichte beträgt <num> gcm-<num>
+Es tritt in zwei Modifikationen auf
+Die bei Standardbedingungen stabile Modifikation α-Am kristallisiert im hexagonalen Kristallsystem in der
+mit den Gitterparametern a
+<num> pm und c
+<num> pm sowie vier Formeleinheiten pro Elementarzelle
+Die Kristallstruktur besteht aus einer doppelt-hexagonal dichtesten Kugelpackung d hcp mit der Schichtfolge ABAC und ist damit isotyp zur Struktur von α-La
+Bei hohem Druck geht α-Am in β-Am über
+Die β-Modifikation kristallisiert im kubischen Kristallsystem in der Raumgruppe
+mit dem Gitterparameter a
+<num> pm
+was einem kubisch flächenzentrierten Gitter fcc beziehungsweise einer kubisch dichtesten Kugelpackung mit der Stapelfolge ABC entspricht
+Die Lösungsenthalpie von Americium-Metall in Salzsäure bei Standardbedingungen beträgt -<num>
+<num> kJmol-<num>
+Ausgehend von diesem Wert erfolgte die erstmalige Berechnung der Standardbildungsenthalpie Δf H <num> von Am<num> aq auf -<num>
+<num> kJmol-<num> und des Standardpotentials Am<num>
+Am<num> auf -<num>
+<num> V
+Chemische Eigenschaften
+Americium ist ein sehr reaktionsfähiges Element das schon mit Luftsauerstoff reagiert und sich gut in Säuren löst
+Gegenüber Alkalien ist es stabil
+Die stabilste Oxidationsstufe für Americium ist <num> die AmIII-Verbindungen sind gegen Oxidation und Reduktion sehr stabil
+Mit dem Americium liegt der erste Vertreter der Actinoiden vor der in seinem Verhalten eher den Lanthanoiden ähnelt als den d-Block-Elementen
+Es ist auch in den Oxidationsstufen <num> sowie <num> <num> <num> und <num> zu finden
+Je nach Oxidationszahl variiert die Farbe von Americium in wässriger Lösung ebenso wie in festen VerbindungenAm<num> gelbrosa Am<num> gelbrot AmVO<num>
+gelb AmVIO<num> <num> zitronengelb AmVIIO<num> <num>- dunkelgrün
+Im Gegensatz zum homologen Europium - Americium hat eine zu Europium analoge Elektronenkonfiguration - kann Am<num> in wässriger Lösung nicht zu Am<num> reduziert werden
+Verbindungen mit Americium ab Oxidationszahl <num> aufwärts sind starke Oxidationsmittel vergleichbar dem Permanganat-Ion MnO<num> - in saurer Lösung
+Die in wässriger Lösung nicht beständigen Am<num>-Ionen lassen sich nur noch mit starken Oxidationsmitteln aus AmIII darstellen
+In fester Form sind zwei Verbindungen des Americiums in der Oxidationsstufe <num> bekannt AmericiumIV-oxid AmO<num> und AmericiumIV-fluorid AmF<num>
+Der fünfwertige Oxidationszustand wurde beim Americium erstmals <num> beobachtet In wässriger Lösung liegen primär AmO<num> -Ionen sauer oder AmO<num> --Ionen alkalisch vor die jedoch instabil sind und einer raschen Disproportionierung unterliegen
+<num> AmO<num>
+<num> H -> <num> AmO<num><num>
+Am<num>
+<num> H<num>O
+Zunächst ist von einer Disproportionierung zur Oxidationsstufe <num> und <num> auszugehen
+<num> Am V -> Am VI
+Am IV
+Etwas beständiger als AmIV und AmV sind die AmericiumVI-Verbindungen
+Sie lassen sich aus AmIII durch Oxidation mit Ammoniumperoxodisulfat in verdünnter Salpetersäure herstellen
+Der typische rosafarbene Ton verschwindet in Richtung zu einer starken Gelbfärbung Zudem kann die Oxidation mit SilberI-oxid in Perchlorsäure quantitativ erreicht werden In Natriumcarbonat- oder Natriumhydrogencarbonat-Lösungen ist eine Oxidation mit Ozon oder Natriumperoxodisulfat gleichfalls möglich
+Americium III in <num>M Na<num>CO<num>jpgAmericiumIIIin <num> M Na<num>CO<num>-Lösung Americium IV in <num>M Na<num>CO<num>jpgAmericiumIVin <num> M Na<num>CO<num>-Lösung Americium IV VI in <num>M Na<num>CO<num>jpgAmericiumIV und VIin <num> M Na<num>CO<num>-Lösung
+Biologische Aspekte
+Eine biologische Funktion des Americiums ist nicht bekannt Vorgeschlagen wurde der Einsatz immobilisierter Bakterienzellen zur Entfernung von Americium und anderen Schwermetallen aus Fließgewässern
+So können Enterobakterien der Gattung
+Citrobacter
+durch die Phosphatase aktivität in ihrer Zellwand bestimmte Americiumnuklide aus wässriger Lösung ausfällen und als Metall-Phosphat-Komplex binden Ferner wurden die Faktoren untersucht die die Biosorption und Bioakkumulation des Americiums durch Bakterien
+und Pilze beeinflussen
+Spaltbarkeit
+Das Isotop <num>m<num>Am hat mit rund <num> barn den höchsten bisher <num><num> gemessenen thermischen Spaltquerschnitt Damit geht eine kleine kritische Masse einher weswegen <num>m<num>Am als Spaltmaterial vorgeschlagen wurde um beispielsweise Raumschiffe mit Kernenergieantrieb anzutreiben
+Dieses Isotop eignet sich prinzipiell auch zum Bau von Kernwaffen
+Die kritische Masse einer reinen <num>m<num>Am-Kugel beträgt etwa <num>-<num> kg
+Die Unsicherheiten der verfügbaren Wirkungsquerschnitte lassen derzeit keine genauere Aussage zu
+Mit Reflektor beträgt die kritische Masse noch etwa <num>-<num> kg In wässriger Lösung wird sie nochmals stark herabgesetzt
+Auf diese Weise ließen sich sehr kompakte Sprengköpfe bauen
+Nach öffentlichem Kenntnisstand wurden bisher keine Kernwaffen aus <num>m<num>Am gebaut was mit der geringen Verfügbarkeit und dem hohen Preis begründet werden kann
+Aus denselben Gründen wird <num>m<num>Am auch nicht als Kernbrennstoff in Kernreaktoren eingesetzt obwohl es dazu prinzipiell sowohl in thermischen als auch in schnellen Reaktoren geeignet wäre Auch die beiden anderen häufiger verfügbaren Isotope <num>Am und <num>Am können in einem schnellen Reaktor eine Kettenreaktion aufrechterhalten
+Die kritischen Massen sind hier jedoch sehr hoch
+Sie betragen unreflektiert <num>-<num> kg bei <num>Am und <num> kg bei <num>Am so dass sich durch die Verwendung keine Vorteile gegenüber herkömmlichen Spaltstoffen ergeben
+Entsprechend ist Americium rechtlich nach
+Abs <num> des Atomgesetzes nicht den Kernbrennstoffen zugeordnet
+Es existieren jedoch Vorschläge sehr kompakte Reaktoren mit einem Americium-Inventar von lediglich knapp <num> g zu konstruieren die in Krankenhäusern als Neutronenquelle für die Neutroneneinfangtherapie verwendet werden können
+Isotope
+Von Americium sind <num> Isotope und <num> Kernisomere mit Halbwertszeiten zwischen Bruchteilen von Mikrosekunden und <num> Jahren bekannt
+Es gibt zwei langlebige α-strahlende Isotope <num>Am mit <num> und <num>Am mit <num> Jahren Halbwertszeit
+Außerdem hat das Kernisomer <num>m<num>Am mit <num> Jahren eine lange Halbwertszeit
+Die restlichen Kernisomere und Isotope haben mit <num> µs bei <num>m<num>Am bis <num> Stunden bei <num>Am kurze Halbwertszeiten
+<num>Am ist das am häufigsten erbrütete Americiumisotop und liegt auf der Neptunium-Reihe
+Es zerfällt mit einer Halbwertszeit von <num> Jahren mit einem α-Zerfall zu <num>Np
+<num>Am gibt nur mit einer Wahrscheinlichkeit von <num>
+die gesamte Zerfallsenergie mit dem α-Teilchen ab sondern emittiert meistens noch ein oder mehrere Gammaquanten
+<num>Am ist kurzlebig und zerfällt mit einer Halbwertszeit von <num> h zu <num>
+durch β-Zerfall zu <num>Cm und zu <num>
+durch Elektroneneinfang zu <num>Pu
+Das <num>Cm zerfällt zu <num>Pu und dieses weiter zu <num>U das auf der Uran-Radium-Reihe liegt
+Das <num>Pu zerfällt über die gleiche Zerfallskette wie <num>Pu
+Während jedoch <num>Pu als Seitenarm beim <num>U auf die Zerfallskette kommt steht <num>Pu noch vor dem <num>U <num>Pu zerfällt durch α-Zerfall in <num>U den Beginn der natürlichen Uran-Radium-Reihe
+<num>m<num>Am zerfällt mit einer Halbwertszeit von <num> Jahren zu <num>
+durch Innere Konversion zu <num>Am und zu <num>
+durch α-Zerfall zu <num>Np
+Dieses zerfällt zu <num>Pu und dann weiter zu <num>U das auf der Uran-Radium-Reihe liegt
+<num>Am ist mit einer Halbwertszeit von <num> Jahren das langlebigste Americiumisotop
+Es geht zunächst durch α-Strahlung in <num>Np über das durch β-Zerfall weiter zu <num>Pu zerfällt
+Das <num>Pu zerfällt durch α-Strahlung zu Uran <num>U dem offiziellen Anfang der Uran-Actinium-Reihe
+Die Americiumisotope mit ungerader Neutronenzahl also gerader Massenzahl sind gut durch thermische Neutronen spaltbar
+Liste der Americiumisotope
+Verwendung
+Für die Verwendung von Americium sind vor allem die beiden langlebigsten Isotope <num>Am und <num>Am von Interesse
+In der Regel wird es in Form des Oxids AmO<num> verwendet
+DateiAmericio-alarmajpg
+Ionisationsrauchmelder
+Die α-Strahlung des <num>Am wird in Ionisationsrauchmeldern genutzt Es wird gegenüber <num> Ra bevorzugt da es vergleichsweise wenig γ-Strahlung emittiert
+Dafür muss aber die Aktivität gegenüber Radium ca das Fünffache betragen
+Die Zerfallsreihe von <num>Am endet für den Verwendungszeitraum quasi direkt nach dessen α-Zerfall bei <num> Np das eine Halbwertszeit von rund <num> Millionen Jahren besitzt
+Radionuklidbatterien
+<num>Am wurde wegen seiner gegenüber <num>Pu wesentlich längeren Halbwertszeit zur Befüllung von Radionuklidbatterien RTG von Raumsonden vorgeschlagen
+Dank seiner Halbwertszeit von <num> Jahren könnte ein RTG mit <num>Am-Füllung hunderte Jahre lang - anstatt nur einige Jahrzehnte wie mit einer <num>Pu-Füllung - elektrische Energie zum Betrieb einer Raumsonde bereitstellen Es soll voraussichtlich in den Radionuklidbatterien zum Einsatz kommen deren Entwicklung die ESA erwägt und deren Entwicklung in den <num>er-Jahren abgeschlossen werden könnte
+Neutronenquellen
+<num>Am als Oxid mit Beryllium verpresst stellt eine Neutronenquelle dar die beispielsweise für radiochemische Untersuchungen eingesetzt wird Hierzu wird der hohe Wirkungsquerschnitt des Berylliums für αn-Kernreaktionen ausgenutzt wobei das Americium als Produzent der α-Teilchen dient
+Die entsprechenden Reaktionsgleichungen lauten
+Derartige Neutronenquellen kommen beispielsweise in der Neutronenradiographie und -tomographie zum Einsatz
+Ionisator
+DateiAm-<num> Brushjpg Neben dem häufig verwendeten <num>Po als Ionisator zur Beseitigung von unerwünschter elektrostatischer Aufladung kam auch <num>Am zum Einsatz
+Dazu wurde z B
+die Quelle am Kopf einer Bürste montiert mit der man langsam über die zu behandelnden Oberflächen strich und dadurch eine Wiederverschmutzung durch elektrostatisch angezogene Staubpartikel vermeiden konnte
+Herstellung anderer Elemente
+Americium ist Ausgangsmaterial zur Erzeugung höherer Transurane und auch der Transactinoide
+Aus <num>Am entsteht zu <num>
+Curium <num>Cm und zu <num>
+Plutonium <num>Pu
+Im Kernreaktor wird zwangsläufig in geringen Mengen durch Neutroneneinfang aus <num>Am das <num>Am erbrütet das durch β-Zerfall zum Curiumisotop <num>Cm zerfällt
+In Teilchenbeschleunigern führt zum Beispiel der Beschuss von <num>Am mit Kohlenstoffkernen <num>C beziehungsweise Neonkernen <num>Ne zu den Elementen Einsteinium <num>Es beziehungsweise Dubnium <num>Db
+Spektrometer
+Mit seiner intensiven Gammastrahlungs-Spektrallinie bei <num> keV eignet sich <num>Am gut als Strahlenquelle für die Röntgen-Fluoreszenzspektroskopie
+Dies wird auch zur Kalibrierung von Gammaspektrometern im niederenergetischen Bereich verwendet da die benachbarten Linien vergleichsweise schwach sind und so ein einzeln stehender Peak entsteht
+Zudem wird der Peak nur vernachlässigbar durch das Compton-Kontinuum höherenergetischer Linien gestört da diese ebenfalls höchstens mit einer um mindestens drei Größenordnungen geringeren Intensität auftreten
+Sicherheitshinweise und Gefahren
+Einstufungen nach der CLP-Verordnung liegen nicht vor weil diese nur die chemische Gefährlichkeit umfassen welche eine völlig untergeordnete Rolle gegenüber den auf der Radioaktivität beruhenden Gefahren spielt
+Eine chemische Gefahr liegt überhaupt nur dann vor wenn es sich um eine dafür relevante Stoffmenge handelt
+Da von Americium nur radioaktive Isotope existieren darf es selbst sowie seine Verbindungen nur in geeigneten Laboratorien unter speziellen Vorkehrungen gehandhabt werden
+Die meisten gängigen Americiumisotope sind α-Strahler weshalb eine Inkorporation unbedingt vermieden werden muss
+Das breite Spektrum der hieraus resultierenden meist ebenfalls radioaktiven Tochternuklide stellt ein weiteres Risiko dar das bei der Wahl der Sicherheitsvorkehrungen berücksichtigt werden muss <num>Am gibt beim radioaktiven Zerfall große Mengen relativ weicher Gammastrahlung ab die sich gut abschirmen lässt
+Nach Untersuchungen des Forschers Arnulf Seidel vom Institut für Strahlenbiologie des Kernforschungszentrums Karlsruhe erzeugt Americium wie Plutonium bei Aufnahme in den Körper mehr Knochentumore als dieselbe Dosis Radium
+Die biologische Halbwertszeit von <num>Am beträgt in den Knochen <num> Jahre und in der Leber <num> Jahre
+In den Gonaden verbleibt es dagegen offensichtlich dauerhaft
+Verbindungen
+Kategorie
+Oxide
+Von Americium existieren Oxide der Oxidationsstufen <num> Am<num>O<num> und <num> AmO<num>
+AmericiumIII-oxid Am<num>O<num> ist ein rotbrauner Feststoff und hat einen Schmelzpunkt von <num> C
+AmericiumIV-oxid AmO<num> ist die wichtigste Verbindung dieses Elements
+Nahezu alle Anwendungen dieses Elements basieren auf dieser Verbindung
+Sie entsteht unter anderem implizit in Kernreaktoren beim Bestrahlen von Urandioxid UO<num> bzw Plutoniumdioxid PuO<num> mit Neutronen
+Es ist ein schwarzer Feststoff und kristallisiert - wie die anderen ActinoidenIV-oxide - im kubischen Kristallsystem in der Fluorit-Struktur
+Halogenide
+Halogenide sind für die Oxidationsstufen <num> <num> und <num> bekannt Die stabilste Stufe <num> ist für sämtliche Verbindungen von Fluor bis Iod bekannt und in wässriger Lösung stabil
+AmericiumIII-fluorid AmF<num> ist schwerlöslich und kann durch die Umsetzung einer wässrigen Americiumlösung mit Fluoridsalzen im schwach Sauren durch Fällung hergestellt werden
+Das tetravalente AmericiumIV-fluorid AmF<num> ist durch die Umsetzung von AmericiumIII-fluorid mit molekularem Fluor zugänglich
+In der wässrigen Phase wurde das vierwertige Americium auch beobachtet
+AmericiumIII-chlorid AmCl<num> bildet rosafarbene hexagonale Kristalle
+Seine Kristallstruktur ist isotyp mit UranIII-chlorid
+Der Schmelzpunkt der Verbindung liegt bei <num> C Das Hexahydrat AmCl<num><num> H<num>O weist eine monokline Kristallstruktur auf
+Durch Reduktion mit Na-Amalgam aus AmIII-Verbindungen sind AmII-Salze zugänglich die schwarzen Halogenide AmCl<num> AmBr<num> und AmI<num>
+Sie sind sehr sauerstoffempfindlich und oxidieren in Wasser unter Freisetzung von Wasserstoff zu AmIII-Verbindungen
+Chalkogenide und Pentelide
+Von den Chalkogeniden sind bekannt das Sulfid AmS<num> zwei Selenide AmSe<num> und Am<num>Se<num>
+und zwei Telluride Am<num>Te<num> und AmTe<num>
+Die Pentelide des Americiums <num>Am des Typs AmX sind für die Elemente Phosphor Arsen Antimon und Bismut dargestellt worden
+Sie kristallisieren im NaCl-Gitter
+Silicide und Boride
+Americiummonosilicid AmSi und Americiumdisilicid AmSix mit <num> < x < <num> wurden durch Reduktion von AmericiumIII-fluorid mit elementaren Silicium im Vakuum bei <num> C AmSi und <num>-<num> C AmSix dargestellt
+AmSi ist eine schwarze Masse isomorph mit LaSi
+AmSix ist eine hellsilbrige Verbindung mit einem tetragonalen Kristallgitter
+Boride der Zusammensetzungen AmB<num> und AmB<num> sind gleichfalls bekannt
+Metallorganische Verbindungen
+Analog zu Uranocen einer Organometallverbindung in der Uran von zwei Cyclooctatetraen-Liganden komplexiert ist wurden die entsprechenden Komplexe von Thorium Protactinium Neptunium Plutonium und auch des Americiums η<num>-C<num>H<num><num>Am dargestellt
+Einzelnachweise
+Literatur
+Wolfgang H Runde Wallace W Schulz
+in Lester R Morss Norman M Edelstein Jean Fuger Hrsg The Chemistry of the Actinide and Transactinide Elements Springer Dordrecht <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> doi<num><num>-<num>-<num>-<num>_<num>
+Gmelins Handbuch der anorganischen Chemie
+System Nr <num> Transurane Teil A <num> I S <num>-<num> Teil A <num> II S <num> <num>-<num> <num>-<num> Teil A <num> S <num>-<num> <num>-<num> <num>-<num> Teil B <num> S <num>-<num>
+Weblinks
+Rachel Sheremeta Pepling
+Chemical
+Engineering News <num>
+G T Seaborg R A James L O Morgan The New Element Americium Atomic Number <num> NNES PPR National Nuclear Energy Series Plutonium Project Record Vol <num> B The Transuranium Elements Research Papers Paper No <num> McGraw-Hill Book Co Inc New York <num> Abstract Maschinoskript Januar <num> K Street Jr A Ghiorso G T Seaborg The Isotopes of Americium in
+Physical Review
+<num> <num> <num> S <num>-<num> doi<num>PhysRev<num> Maschinoskript <num> April <num> Übersetzung Der Name Americium nach den beiden Amerikas und das Symbol Am werden für das Element vorgeschlagen - basierend auf seiner Position als sechstes Mitglied der Actinoid-Seltenerdmetalle-Serie in Analogie zum Europium Eu aus der Lanthanoiden-Serie G Audi O Bersillon J Blachot A H Wapstra The NUBASE evaluation of nuclear and decay properties in
+Nuclear Physics A
+<num> <num> S <num>-<num>
+<num> MB Rachel Sheremeta Pepling
+Chemical
+Engineering News <num> Edgar F Westrum Jr LeRoy Eyring The Preparation and Some Properties of Americium Metal in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> Klaus Hoffmann Kann man Gold machen Gauner Gaukler und Gelehrte Aus der Geschichte der chemischen Elemente Urania-Verlag Leipzig Jena Berlin <num>
+S <num> L H Baetsle
+PDF <num> MB September <num> Gabriele Fioni Michel Cribier Frédéric Marie textSmoke Detectors and Americium urlhttpwwwworld-nuclearorginfoinf<num>html wayback<num> archiv-bot<num>-<num>-<num> <num><num> InternetArchiveBot
+Informationen zum Element Americium bei wwwspeclabcom engl Zugriff <num> Oktober <num>
+Akihiro Sasahara Tetsuo Matsumura Giorgos Nicolaou Dimitri Papaioannou Neutron and Gamma Ray Source Evaluation of LWR High Burn-up UO<num> and MOX Spent Fuels in
+Journal of Nuclear Science and Technology
+<num> <num> <num> S <num>-<num> doi<num><num><num> Gmelins Handbuch der anorganischen Chemie
+System Nr <num> Transurane Teil B <num> S <num>-<num> W Z Wade T Wolf Preparation and Some Properties of Americium Metal in
+J Inorg Nucl Chem
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> D B McWhan B B Cunningham J C Wallmann Crystal Structure Thermal Expansion and Melting Point of Americium Metal in
+J Inorg Nucl Chem
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> J U Mondal D L Raschella R G Haire J R Peterson The Enthalpy of Solution of <num>Am Metal and the Standard Enthalpy of Formation of Am<num>aq in
+Thermochim Acta
+<num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> L B Werner I Perlman The Pentavalent State of Americium in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> G R Hall T L Markin The Self-reduction of AmericiumV and VI and the Disproportionation of AmericiumV in Aqueous Solution in
+J Inorg Nucl Chem
+<num> <num> <num>-<num> S <num>-<num> doi<num><num>-<num><num><num>-<num> James S Coleman The Kinetics of the Disproportionation of AmericiumV in
+Inorg Chem
+<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num> L B Asprey S E Stephanou R A Penneman A New Valence State of Americium AmVI in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> L B Asprey S E Stephanou R A Penneman Hexavalent Americium in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> J S Coleman T K Keenan L H Jones W T Carnall R A Penneman Preparation and Properties of AmericiumVI in Aqueous Carbonate Solutions in
+Inorg Chem
+<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num>
+L E Macaskie B C Jeong M R Tolley Enzymically Accelerated Biomineralization of Heavy Metals Application to the Removal of Americium and Plutonium from Aqueous Flows in
+FEMS Microbiol Rev
+<num> <num> <num> S <num>-<num> PMID <num> E A Wurtz T H Sibley W R Schell Interactions of Escherichia coli and Marine Bacteria with <num>Am in Laboratory Cultures in
+Health Phys
+<num> <num> <num> S <num>-<num> PMID <num> A J Francis J B Fillow C J Dodge M Dunn K Mantione B A Strietelmeier M E Pansoy-Hjelvik H W Papenguth Role of Bacteria as Biocolloids in the Transport of Actinides from a Deep Underground Radioactive Waste Repository in
+Radiochimica Acta
+<num> <num> S <num>-<num> Abstract und PDF-Download N Liu Y Yang S Luo T Zhang J Jin J Liao X Hua Biosorption of <num>Am by Rhizopus arrihizus Preliminary Investigation and Evaluation in
+Appl Radiat Isot
+<num> <num> <num> S <num>-<num> PMID <num> G Pfennig H Klewe-Nebenius W Seelmann-Eggebert Hrsg Karlsruher Nuklidkarte
+<num> Auflage <num> Science daily
+<num> Januar <num> H Dias N Tancock A Clayton Critical Mass Calculations for <num>Am <num>mAm and <num>Am in
+Nippon Genshiryoku Kenkyujo JAERI Conf
+<num> S <num>-<num> Abstract PDF Y Ronen M Aboudy D Regev A novel method for energy production using <num>mAm as a nuclear fuel in
+Nuclear technology
+<num> <num> <num> S <num>-<num> Abstract Institut de Radioprotection et de Sûreté Nucléaire Evaluation of nuclear criticality safety data and limits for actinides in transport S <num>
+Y Ronen M Aboudy D Regev Homogeneous <num>mAm-Fueled Reactor for Neutron Capture Therapy in
+Nuclear Science and Engineering
+<num> <num> <num> S <num>-<num> Abstract
+PDF <num> kB letzte Seite Stephen Clark
+in
+Spaceflight Now
+<num> Juli <num> NA Nuclear Data Viewer <num> NNDC abgefragt am <num> September <num> Sucheingabe Lenntech
+Abschnitt <num> Franz Frisch Klipp und klar <num> x Energie Bibliographisches Institut AG Mannheim <num> ISBN <num>-<num>-<num>-X S <num>
+L B Asprey T K Keenan F H Kruse Crystal Structures of the Trifluorides Trichlorides Tribromides and Triiodides of Americium and Curium in
+Inorg Chem
+<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num> L B Asprey New Compounds of Quadrivalent Americium AmF<num> KAmF<num>
+in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> L B Asprey R A Penneman First Observation of Aqueous Tetravalent Americium in
+J Am Chem Soc
+<num> <num> <num> S <num>-<num> doi<num>ja<num>a<num> John H Burns Joseph Richard Peterson The Crystal Structures of Americium Trichloride Hexahydrate and Berkelium Trichloride Hexahydrate in
+Inorg Chem
+<num> <num> <num> S <num>-<num> doi<num>ic<num>a<num> D Damien J Jove Americium Disulfide and Diselenide in
+Inorg Nucl Chem Lett
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> J W Roddy Americium Metallides AmAs AmSb AmBi Am<num>Se<num> and AmSe<num>
+in
+J Inorg Nucl Chem
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> D Damien Americium Tritelluride and Ditelluride in
+Inorg Nucl Chem Lett
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> J P Charvillat D Damien Americium Monoarsenide in
+Inorg Nucl Chem Lett
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> F Weigel F D Wittmann R Marquart Americium Monosilicide and Disilicide in
+Journal of the Less Common Metals
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-X Harry A Eick R N R Mulford Americium and Neptunium Borides in
+J Inorg Nucl Chem
+<num> <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-X Christoph Elschenbroich Organometallchemie <num> Auflage Wiesbaden <num> ISBN <num>-<num>-<num>-<num>-<num> S <num>
+DateiHelium atom QM DEsvg DateiKovalente Atomradien auf Basis der Cambridge Structural Databasesvg Atome von
+átomos unteilbar sind die Bausteine aus denen alle festen flüssigen oder gasförmigen Stoffe bestehen
+Alle Materialeigenschaften dieser Stoffe sowie ihr Verhalten in chemischen Reaktionen werden durch die Eigenschaften und die räumliche Anordnung der Atome aus denen sie aufgebaut sind festgelegt
+Jedes Atom gehört zu einem bestimmten chemischen Element und bildet dessen kleinste Einheit
+Zurzeit sind <num> Elemente bekannt von denen etwa <num> auf der Erde natürlich vorkommen
+Atome verschiedener Elemente unterscheiden sich in ihrer Größe und Masse und vor allem in ihrer Fähigkeit mit anderen Atomen chemisch zu reagieren und sich zu Molekülen oder festen Körpern zu verbinden
+Die Durchmesser von Atomen liegen im Bereich von <num>
+<num>-<num> m Helium bis <num>
+<num>-<num> m Cäsium ihre Massen in einem Bereich von <num>
+<num>-<num> kg Wasserstoff bis knapp <num> <num>-<num> kg die derzeit schwersten synthetisch hergestellten Kerne
+Atome sind nicht unteilbar wie zum Zeitpunkt der Namensgebung angenommen sondern zeigen einen wohlbestimmten Aufbau aus noch kleineren Teilchen
+Sie bestehen aus einem Atomkern und einer Atomhülle
+Der Atomkern hat einen Durchmesser von etwa einem Zehn- bis Hunderttausendstel des gesamten Atomdurchmessers enthält jedoch über <num> Prozent der Atommasse
+Er besteht aus positiv geladenen Protonen und einer Anzahl von etwa gleich schweren elektrisch neutralen Neutronen
+Diese Nukleonen sind durch die starke Wechselwirkung aneinander gebunden
+Die Hülle besteht aus negativ geladenen Elektronen
+Sie trägt mit weniger als <num> Prozent zur Masse bei bestimmt jedoch die Größe des Atoms
+Der positive Kern und die negative Hülle sind durch elektrostatische Anziehung aneinander gebunden
+In der elektrisch neutralen Grundform des Atoms ist die Anzahl der Elektronen in der Hülle gleich der Anzahl der Protonen im Kern
+Diese Zahl legt den genauen Aufbau der Hülle und damit auch das chemische Verhalten des Atoms fest und wird deshalb als chemische Ordnungszahl
+bezeichnet
+Alle Atome desselben Elements haben die gleiche chemische Ordnungszahl
+Sind zusätzliche Elektronen vorhanden oder fehlen welche ist das Atom negativ bzw positiv geladen und wird als Ion bezeichnet
+Die Vorstellung vom atomaren Aufbau der Materie existierte bereits in der Antike war jedoch bis in die Neuzeit umstritten
+Der endgültige Nachweis konnte erst Anfang des <num> Jahrhunderts erbracht werden und gilt als eine der bedeutendsten Entdeckungen in Physik und Chemie
+Einzelne Atome sind selbst mit den stärksten Lichtmikroskopen nicht zu erkennen
+Eine direkte Beobachtung einzelner Atome ist erst seit Mitte des <num> Jahrhunderts mit Feldionenmikroskopen möglich seit einigen Jahren auch mit Rastertunnelmikroskopen und hochauflösenden Elektronenmikroskopen
+Die Atomphysik die neben dem Aufbau der Atome auch die Vorgänge in ihrem Inneren und ihre Wechselwirkungen mit anderen Atomen erforscht hat entscheidend zur Entwicklung der modernen Physik und insbesondere der Quantenmechanik beigetragen
+Erforschungsgeschichte
+Die Vorstellung vom atomaren Aufbau der Materie existierte bereits in der Antike
+Aufgrund ihrer extrem geringen Größe sind einzelne Atome selbst mit den stärksten Lichtmikroskopen nicht zu erkennen noch Anfang des <num> Jahrhunderts war ihre Existenz umstritten
+Der endgültige Nachweis gilt als eine der bedeutendsten Entdeckungen in Physik und Chemie
+Einen entscheidenden Beitrag lieferte Albert Einstein <num> indem er die bereits seit langem bekannte im Mikroskop direkt sichtbare Brownsche Bewegung kleiner Körnchen durch zufällige Stöße von Atomen oder Molekülen in deren Umgebung erklärte
+Erst seit wenigen Jahrzehnten erlauben Feldionenmikroskope und Rastertunnelmikroskope seit einigen Jahren zudem auch Elektronenmikroskope einzelne Atome direkt zu beobachten
+Philosophische Überlegungen
+Das Konzept des Atomismus nämlich dass Materie aus Grundeinheiten aufgebaut ist - kleinsten Teilchen die nicht immer weiter in kleinere Stücke zerteilt werden können - existiert seit Jahrtausenden genauso wie das Gegenkonzept Materie sei ein beliebig teilbares Kontinuum
+Doch diese Ideen beruhten zunächst ausschließlich auf philosophischen Überlegungen und nicht auf empirischer experimenteller Untersuchung
+Dabei wurden den Atomen verschiedene Eigenschaften zugeschrieben und zwar je nach Zeitalter Kultur und philosophischer Schule sehr unterschiedliche
+Eine frühe Erwähnung des Atomkonzepts in der Philosophie ist aus Indien bekannt
+Die Nyaya- und Vaisheshika-Schulen entwickelten ausgearbeitete Theorien wie sich Atome zu komplexeren Gebilden zusammenschlössen erst in Paaren dann je drei Paare
+Experimentell arbeitende Naturwissenschaftler machten sich Ende des <num> Jahrhunderts die Hypothese vom Atom zu eigen weil diese Hypothese im Rahmen eines Teilchenmodells der Materie eine elegante Erklärung für neue Entdeckungen in der Chemie bot Doch wurde gleichzeitig die gegenteilige Vorstellung Materie sei ein Kontinuum von Philosophen und auch unter Naturwissenschaftlern noch bis ins <num> Jahrhundert hinein aufrechterhalten
+In der griechischen Philosophie ist die Atomvorstellung erstmals im <num> Jahrhundert v Chr
+bei Leukipp überliefert
+Sein Schüler Demokrit systematisierte sie und führte den Begriff átomos ein was etwa das Unzerschneidbare bedeutet also ein nicht weiter zerteilbares Objekt
+Diese Bezeichnung wurde Ende des <num> Jahrhunderts für die damals hypothetischen kleinsten Einheiten der chemischen Elemente der beginnenden modernen Chemie übernommen denn mit chemischen Methoden lassen sich Atome in der Tat nicht zerschneiden
+Naturwissenschaftliche Erforschung
+Im Rahmen der wissenschaftlichen Erforschung konnte die Existenz von Atomen bestätigt werden
+Es wurden viele verschiedene Atommodelle entwickelt um ihren Aufbau zu beschreiben
+Insbesondere das Wasserstoffatom als das einfachste aller Atome war dabei wichtig
+Einige der Modelle werden heute nicht mehr verwendet und sind nur von wissenschaftsgeschichtlichem Interesse
+Andere gelten je nach Anwendungsbereich als Näherung noch heute
+In der Regel wird das einfachste Modell genommen welches im gegebenen Zusammenhang noch ausreicht um die auftretenden Fragen zu klären
+Bestätigung der Atomhypothese
+DateiA New System of Chemical Philosophy fpjpg
+Robert Boyle vertrat <num> in seinem Werk
+The Sceptical Chymist
+die Meinung die Materie sei aus diversen Kombinationen verschiedener corpuscules aufgebaut und nicht aus den vier Elementen der Alchemie Wasser Erde Feuer Luft Damit bereitete er die Überwindung der Alchemie durch den Element- und Atombegriff der modernen Chemie vor
+Daniel Bernoulli zeigte <num> dass der gleichmäßige Druck von Gasen auf die Behälterwände und insbesondere das Gesetz von Boyle und Mariotte sich durch zahllose Stöße kleinster Teilchen erklären lässt
+Damit wurde seine Forschung zum Vorläufer der kinetischen Gastheorie und statistischen Mechanik
+Ab Ende des <num> Jahrhunderts wurde die Vorstellung von Atomen genutzt um die wohlbestimmten Winkel an den Kanten und Ecken der Edelsteine auf die verschiedenen möglichen Schichtungen von harten Kugeln zurückzuführen
+Nachdem Antoine Lavoisier <num> den heutigen Begriff des chemischen Elements geprägt und die ersten Elemente richtig identifiziert hatte benutzte <num> John Dalton das Atomkonzept um zu erklären wieso Elemente immer in Mengenverhältnissen kleiner ganzer Zahlen miteinander reagieren Gesetz der multiplen Proportionen
+Er nahm an dass jedes Element aus gleichartigen Atomen besteht die sich nach festen Regeln miteinander verbinden können und so Stoffe mit anderen Materialeigenschaften bilden
+Außerdem ging er davon aus dass alle Atome eines Elements die gleiche Masse hätten und begründete den Begriff Atomgewicht
+Die Beobachtungen zum chemischen und physikalischen Verhalten von Gasen konnte Amedeo Avogadro <num> dahingehend zusammenfassen dass zwei näherungsweise ideale Gase bei gleichen Werten von Volumen Druck und Temperatur des Gases immer aus gleich vielen identischen Teilchen Molekülen bestehen
+Die Moleküle bestehen bei elementaren Gasen wie Wasserstoff Sauerstoff oder Stickstoff immer aus zwei Atomen des Elements Avogadrosches Gesetz
+<num> konnte Johann Loschmidt die Größe der Luftmoleküle bestimmen indem er mit der von James C Maxwell aus der kinetischen Gastheorie gewonnenen Formel die von George Stokes gemessenen Werte für die innere Reibung in Luft auswertete Damit konnte er das Gewicht eines Luftmoleküls bestimmen
+Außerdem erhielt er die nach ihm benannte Loschmidtsche Zahl als Anzahl der Luftmoleküle pro Kubikzentimeter
+Infolge der Arbeiten von Avogadro und Stanislao Cannizzaro wurde angenommen dass Atome nicht als einzelne Teilchen auftreten sondern nur als Bestandteile von Molekülen aus mindestens zwei Atomen
+Doch <num> gelang August Kundt und Emil Warburg der erste Nachweis eines einatomigen Gases
+Sie bestimmten den Adiabatenexponenten von Quecksilber-Dampf bei hoher Temperatur und erhielten einen Wert wie er nach der kinetischen Gastheorie nur für Teilchen in Gestalt echter Massepunkte auftreten kann
+Ab <num> kamen entsprechende Beobachtungen an den neu entdeckten Edelgasen hinzu
+Nach Erscheinen seiner Dissertation über die Bestimmung von Moleküldimensionen schlug Albert Einstein im selben Jahr <num> ein Experiment vor um die Hypothese von der Existenz der Atome anhand der Zitterbewegung kleiner Partikel in Wasser quantitativ zu prüfen
+Nach seiner Theorie müssten die Partikel aufgrund der Unregelmäßigkeit der Stöße durch die Wassermoleküle kleine aber immerhin unter dem Mikroskop sichtbare Bewegungen ausführen
+Es war Einstein dabei zunächst nicht bekannt dass er damit die seit <num> bekannte Brownsche Bewegung von Pollen quantitativ erklärt hatte für deren Ursache schon <num> Christian Wiener erstmals Molekularstöße angenommen hatte Der französische Physiker Jean Perrin bestimmte auf der Grundlage von Einsteins Theorie die Masse und Größe von Molekülen experimentell und fand ähnliche Ergebnisse wie Loschmidt Diese Arbeiten trugen entscheidend zur allgemeinen Anerkennung der bis dahin so genannten Atomhypothese bei
+Teilbarkeit und Aufbau der Atome
+Joseph John Thomson entdeckte <num> dass die Kathodenstrahlen aus Teilchen bestimmter Ladung und Masse bestehen deren Masse kleiner als ein Tausendstel der Atommasse ist
+Diese Teilchen wurden als Elektronen bezeichnet und erwiesen sich als ein Bestandteil aller Materie was dem Konzept des Atoms als unzerteilbarer Einheit widersprach Thomson glaubte dass die Elektronen dem Atom seine Masse verliehen und dass sie im Atom in einem masselosen positiv geladenen Medium verteilt seien wie Rosinen in einem Kuchen Thomsonsches Atommodell
+Die kurz zuvor entdeckte Radioaktivität wurde <num> von Ernest Rutherford und Frederick Soddy mit Umwandlungen verschiedener Atomsorten ineinander in Verbindung gebracht
+Sie konnten <num> nachweisen dass α-Teilchen die bei Alphastrahlung ausgesandt werden Helium-Atome bilden
+Zusammen mit seiner Forschergruppe beschoss Ernest Rutherford <num> eine Goldfolie mit α-Teilchen
+Er stellte fest dass die meisten der Teilchen die Folie fast ungehindert durchdrangen einige wenige aber um sehr viel größere Winkel abgelenkt wurden als nach Thomsons Modell möglich
+Rutherford schloss daraus dass fast die ganze Masse des Atoms in einem sehr viel kleineren geladenen Atomkern in der Mitte des Atoms konzentriert sei Rutherfordsches Atommodell
+Die stark abgelenkten α-Teilchen waren diejenigen die einem Kern zufällig näher als etwa ein Hundertstel des Atomradius gekommen waren Die Ladungszahl des Atomkerns entpuppte sich als die chemische Ordnungszahl des betreffenden Elements und α-Teilchen erwiesen sich als die Atomkerne des Heliums
+DateiMass Spectrometer Schematic DEsvg
+Der Chemiker Frederick Soddy stellte <num> fest dass manche der natürlichen radioaktiven Elemente aus Atomen mit unterschiedlichen Massen und unterschiedlicher Radioaktivität bestehen mussten Der Begriff Isotop für physikalisch verschiedene Atome desselben chemischen Elements wurde <num> von Margaret Todd vorgeschlagen Da die Isotope desselben Elements an ihrem chemischen Verhalten nicht zu unterscheiden waren entwickelte der Physiker JJ Thomson ein erstes Massenspektrometer zu ihrer physikalischen Trennung
+Damit konnte er <num> am Beispiel von Neon nachweisen dass es auch stabile Elemente mit mehreren Isotopen gibt
+<num> fand Francis William Aston mit einem Massenspektrometer von erheblich größerer Genauigkeit heraus dass fast alle Elemente Gemische aus mehreren Isotopen sind wobei die Massen der einzelnen Isotope immer nahezu ganzzahlige Vielfache der Masse des Wasserstoffatoms sind Rutherford wies <num> in der ersten beobachteten Kernreaktion nach dass durch Beschuss mit α-Teilchen aus den Kernen von Stickstoffatomen die Kerne von Wasserstoffatomen herausgeschossen werden können
+Diesen gab er den Namen Proton und entwickelte ein Atommodell in dem die Atome nur aus Protonen und Elektronen bestehen wobei die Protonen und ein Teil der Elektronen den kleinen schweren Atomkern bilden die übrigen Elektronen die große leichte Atomhülle
+Die Vorstellung von Elektronen im Atomkern stellte sich jedoch als falsch heraus und wurde fallengelassen nachdem <num> von James Chadwick das Neutron als ein neutraler Kernbaustein mit etwa gleicher Masse wie das Proton nachgewiesen wurde Damit entstand das heutige Atommodell Der Atomkern ist zusammengesetzt aus so vielen Protonen wie die Ordnungszahl angibt und zusätzlich so vielen Neutronen dass die betreffende Isotopenmasse erreicht wird
+Quantenmechanische Atommodelle
+DateiBohr atom modelsvg
+<num> konnte Niels Bohr aufbauend auf Rutherfords Atommodell aus Kern und Hülle erstmals erklären wie es in den optischen Spektren reiner Elemente zu den Spektrallinien kommt die für das jeweilige Element absolut charakteristisch sind Spektralanalyse nach Robert Wilhelm Bunsen und Gustav Robert Kirchhoff <num>
+Bohr nahm an dass die Elektronen sich nur auf bestimmten quantisierten Umlaufbahnen Schalen aufhalten und von einer zur anderen springen sich jedoch nicht dazwischen aufhalten können Beim Quantensprung von einer äußeren zu einer weiter innen liegenden Bahn muss das Elektron eine bestimmte Menge an Energie abgeben die als Lichtquant bestimmter Wellenlänge erscheint
+Im Franck-Hertz-Versuch konnte die quantisierte Energieaufnahme und -abgabe an Quecksilberatomen experimentell bestätigt werden
+Das Bohrsche Atommodell ergab zwar nur für Systeme mit lediglich einem Elektron Wasserstoff und ionisiertes Helium quantitativ richtige Resultate
+Jedoch bildete es im Laufe des folgenden Jahrzehnts das Fundament für eine Reihe von Verfeinerungen die zu einem qualitativen Verständnis des Aufbaus der Elektronenhüllen aller Elemente führten
+Damit wurde das Bohrsche Atommodell zur Grundlage des populären Bildes vom Atom als einem kleinen Planetensystem
+<num> versuchte Gilbert Newton Lewis im Rahmen des Bohrschen Atommodells die chemische Bindung durch Wechselwirkung der Elektronen eines Atoms mit einem anderen Atom zu erklären Walther Kossel ging <num> erstmals von abgeschlossenen Elektronenschalen bei den Edelgasen aus um zu erklären dass die chemischen Eigenschaften der Elemente grob periodisch mit der Ordnungszahl variieren wobei sich benachbarte Elemente durch ein oder zwei zusätzliche oder fehlende Elektronen unterscheiden Dies wurde bis <num> von Niels Bohr zum Aufbauprinzip weiterentwickelt wonach mit zunehmender Kernladungszahl jedes weitere Elektron in die jeweils energetisch niedrigste Elektronenschale der Atomhülle die noch Plätze frei hat aufgenommen wird ohne dass die schon vorhandenen Elektronen sich wesentlich umordnen
+DateiAOs-<num>D-dotspng Aufbauend auf dem von Louis de Broglie <num> postulierten Welle-Teilchen-Dualismus entwickelte Erwin Schrödinger <num> die Wellenmechanik
+Sie beschreibt die Elektronen nicht als Massenpunkte auf bestimmten Bahnen sondern als dreidimensionale
+Materiewellen
+Als Folge dieser Beschreibung ist es unter anderem unzulässig einem Elektron gleichzeitig genaue Werte für Ort und Impuls zuzuschreiben
+Dieser Sachverhalt wurde <num> von Werner Heisenberg in der Unschärferelation formuliert
+Demnach können statt der Bewegung auf bestimmten Bahnen nur Wahrscheinlichkeitsverteilungen für Wertebereiche von Ort und Impuls angegeben werden eine Vorstellung die nur schwer zu veranschaulichen ist
+Den quantisierten Umlaufbahnen des Bohrschen Modells entsprechen hier stehende Materiewellen oder Atomorbitale Sie geben unter anderem an wie sich in der Nähe des Atomkerns die Aufenthaltswahrscheinlichkeit der Elektronen konzentriert und bestimmen damit die wirkliche Größe des Atoms
+Die Beschreibung der Eigenschaften der Atome gelang mit diesem ersten vollständig quantenmechanischen Atommodell sehr viel besser als mit den Vorläufermodellen
+Insbesondere ließen sich auch bei Atomen mit mehreren Elektronen die Spektrallinien und die Struktur der Atomhülle in räumlicher und energetischer Hinsicht darstellen einschließlich der genauen Möglichkeiten mit den Atomhüllen anderer Atome gebundene Zustände zu bilden also stabile Moleküle
+Daher wurde das Bohrsche Atommodell zugunsten des quantenmechanischen Orbitalmodells des Atoms verworfen
+Das Orbitalmodell ist bis heute Grundlage und Ausgangspunkt genauer quantenmechanischer Berechnungen fast aller Eigenschaften der Atome
+Das gilt insbesondere für ihre Fähigkeit sich mit anderen Atomen zu einzelnen Molekülen oder zu ausgedehnten Festkörpern zu verbinden
+Bei Atomen mit mehreren Elektronen muss dafür außer dem Pauli-Prinzip auch die elektrostatische Wechselwirkung jedes Elektrons mit allen anderen berücksichtigt werden
+Diese hängt u a von der Form der besetzten Orbitale ab
+Andererseits wirkt sich umgekehrt die Wechselwirkung auf die Form und Energie der Orbitale aus
+Es ergibt sich das Problem die Orbitale in selbstkonsistenter Weise so zu bestimmen dass sich ein stabiles System ergibt
+Die Hartree-Fock-Methode geht von Orbitalen einer bestimmten Form aus und variiert diese systematisch bis die Rechnung eine minimale Gesamtenergie ergibt
+Wenn man die Orbitale nach der Dichtefunktionaltheorie bestimmen will geht man von einer ortsabhängigen Gesamtdichte der Elektronen aus und bildet daraus eine Schrödingergleichung zur Bestimmung der Orbitale der einzelnen Elektronen
+Hier wird die anfänglich angenommene Gesamtdichte variiert bis sie mit der Gesamtdichte die aus den besetzten Orbitalen zu berechnen ist gut übereinstimmt
+Das Orbitalmodell bei einem Atom mit mehr als einem Elektron ist physikalisch als eine Näherung zu bezeichnen nämlich als eine Ein-Teilchen-Näherung
+Sie besteht darin dass jedem einzelnen Elektron ein bestimmtes Orbital zugeschrieben wird
+Ein so gebildeter Zustand gehört zu der einfachsten Art von Mehrteilchenzuständen und wird hier als Konfiguration des Atoms bezeichnet
+Genauere Modelle berücksichtigen dass nach den Regeln der Quantenmechanik die Hülle auch in einem Zustand sein kann der durch Superposition verschiedener Konfigurationen entsteht wo also mit verschiedenen Wahrscheinlichkeitsamplituden gleichzeitig verschiedene Elektronenkonfigurationen vorliegen eine sogenannte Konfigurationsmischung
+Hiermit werden die genauesten Berechnungen von Energieniveaus und Wechselwirkungen der Atome möglich
+Wegen des dazu nötigen mathematischen Aufwands werden jedoch wo es möglich ist auch weiterhin einfachere Atommodelle genutzt
+Zu nennen ist hier das Thomas-Fermi-Modell in dem die Elektronenhülle pauschal wie ein im Potentialtopf gebundenes ideales Elektronengas das Fermigas behandelt wird dessen Dichte wiederum die Form des Potentialtopfs bestimmt
+Erklärung grundlegender Atomeigenschaften
+Die Elektronen der Atomhülle sind aufgrund ihrer negativen Ladung durch elektrostatische Anziehung an den positiven Atomkern gebunden
+Anschaulich bilden sie eine Elektronenwolke ohne scharfen Rand
+Ein neutrales Atom enthält genauso viele Elektronen in der Hülle wie Protonen im Kern
+Die Hülle hat einen etwa zehn- bis hunderttausend Mal größeren Durchmesser als der Kern trägt jedoch weniger als <num> Prozent zur Atommasse bei
+Sie ist für energiereiche freie Teilchen z B
+Photonen der Röntgenstrahlung oder Elektronen und Alphateilchen der radioaktiven Strahlung mit Energien ab einigen hundert Elektronenvolt eV sehr durchlässig
+Daher wird das Atom zuweilen als weitgehend leer beschrieben
+Für geladene Teilchen geringer Energie im Bereich bis zu einigen zehn eV ist die Hülle aber praktisch undurchdringlich
+In diesem Bereich liegen auch die kinetische Energie und die Bindungsenergie der Elektronen im äußeren Teil der Hülle
+Daher erfahren zwei Atome immer eine starke Abstoßungskraft wenn sie sich so weit annähern dass sich ihre Hüllen merklich überschneiden würden
+Der Bereich der kinetischen Energien ganzer Atome und Moleküle wie sie unter normalen Bedingungen auf der Erde vorkommen liegt noch deutlich darunter
+Z B
+beträgt die thermische Energie
+Boltzmannkonstante
+absolute Temperatur die für die Größenordnung dieses Energiebereichs typisch ist bei Raumtemperatur nur ungefähr <num> eV
+Unter diesen Bedingungen ist die Atomhülle daher erstens stabil weil ihr keine Elektronen entrissen werden und zweitens undurchdringlich weil sie sich nicht merklich mit den Hüllen anderer Atome überschneidet
+Damit wird das Atom zum universellen Baustein der alltäglichen makroskopischen Materie
+Seine wenn auch nicht ganz scharf definierte Größe verdankt es der gegenseitigen Undurchdringlichkeit der Hüllen
+Wenn sich die Hüllen zweier Atome aber nur geringfügig mit ihren äußeren Randbereichen überschneiden kann zwischen ihnen eine anziehende Kraft entstehen
+Sie ist die Ursache für die Entstehung von stabilen Molekülen also den kleinsten Teilchen einer chemischen Verbindung
+Bedingung ist dass insgesamt ein Gewinn an Bindungsenergie damit einhergeht dass ein oder zwei Elektronen von einer Hülle ganz oder mit gewisser Wahrscheinlichkeit zu der anderen Hülle überwechseln oder an beiden Hüllen beteiligt sind
+Das ist nur bei genau passendem Aufbau beider Hüllen gegeben
+Daher treten chemische Bindungen nur bei entsprechend geeigneten Kombinationen von Atomen auf
+Bei größeren Abständen etwa bei einigen Atomdurchmessern ziehen sich hingegen Atome aller Arten gegenseitig schwach an unabhängig von der Möglichkeit eine chemische Bindung einzugehen
+Diese Van-der-Waals-Kräfte bewirken dass jedes Gas bei genügend niedriger Temperatur zu einer Flüssigkeit oder einem Feststoff kondensiert
+Sie sind also für den Wechsel der Aggregatzustände verantwortlich und wirken zwischen den neutralen Atomen bzw Molekülen sind aber auch elektrischen Ursprungs
+Sie werden dadurch erklärt dass sich zwei Atome durch leichte räumliche Verschiebung ihrer Elektronenwolken gegenseitig elektrische Dipolmomente induzieren die einander elektrostatisch anziehen
+Weitere Entdeckungen
+Der Chemiker Otto Hahn ein Schüler Rutherfords versuchte im Jahr <num> durch Einfang von Neutronen an Urankernen Atome mit größerer Masse Transurane herzustellen wie das bei leichteren Elementen seit Jahren gelungen war
+Fritz Straßmann wies jedoch überraschenderweise nach dass dabei das viel leichtere Barium entstanden war
+Die Physiker Lise Meitner und Otto Frisch konnten den Vorgang als Kernspaltung identifizieren indem sie mittels einer Ionisationskammer mehrere radioaktive Spaltprodukte nachwiesen
+Ab den <num>er Jahren konnten Atome durch die Entwicklung verbesserter Teilchenbeschleuniger und Teilchendetektoren beim Beschuss mit Teilchen sehr hoher Energie untersucht werden Ende der <num>er Jahre zeigte sich in der tiefinelastischen Streuung von Elektronen an Atomkernen dass auch Neutronen und Protonen keine unteilbaren Einheiten sind sondern aus Quarks zusammengesetzt sind
+<num> entwickelte Erwin Müller das Feldionenmikroskop und konnte damit von einer Nadelspitze erstmals ein Abbild erzeugen das auf direkte Weise so stark vergrößert war dass einzelne Atome darin sichtbar wurden wenn auch nur als verschwommene Flecken
+<num> entwickelte Wolfgang Paul die magnetische Ionenfalle Paulfalle in der einzelne Ionen gespeichert und mit immer höherer Genauigkeit untersucht werden konnten
+<num> entwickelte eine Arbeitsgruppe um Steven Chu die Laserkühlung ein Verfahren die Temperatur einer Ansammlung von Atomen mittels Laserstrahlung stark zu verringern
+Im selben Jahr gelang es einer Gruppe um William D Phillips neutrale Natriumatome in einer magneto-optischen Falle einzuschließen
+Durch Kombination dieser Verfahren mit einer Methode die den Dopplereffekt nutzt gelang es einer Arbeitsgruppe um Claude Cohen-Tannoudji geringe Mengen von Atomen auf Temperaturen von einigen Mikrokelvin zu kühlen
+Mit diesem Verfahren können Atome mit höchster Genauigkeit untersucht werden außerdem ermöglichte es auch die experimentelle Realisierung der Bose-Einstein-Kondensation
+Anfang der <num>er Jahre wurde von Gerd Binnig und Heinrich Rohrer das Rastertunnelmikroskop entwickelt in dem eine Nadelspitze eine Oberfläche mittels des Tunneleffekts so fein abtastet dass einzelne Atome sichtbar werden
+Damit wurde es auch möglich Atome einzeln an bestimmte Plätze zu setzen
+In den <num>er Jahren konnten Serge Haroche und David Wineland in Experimenten die Wechselwirkung eines einzelnen Atoms mit einem einzelnen Photon erfolgreich untersuchen
+In den <num>er Jahren wurde die Handhabbarkeit einzelner Atome unter anderem genutzt um einen Transistor aus nur einem Metallatom mit organischen Liganden herzustellen
+Viele dieser Entdeckungen wurden mit dem Nobelpreis Physik oder Chemie ausgezeichnet
+Klassifizierung
+DateiPeriodensystem Z A Name Deutschsvg DateiIsotopentabelle Segresvg
+Elemente Isotope Nuklide
+Die Unterscheidung und Bezeichnung verschiedener Atomsorten geht zunächst vom Aufbau des Atomkerns aus während der Zustand der Hülle gegebenenfalls durch zusätzliche Symbole angegeben wird
+Kennzahlen sind die Protonenzahl Ordnungszahl Kernladungszahl Z die Neutronenzahl N des Kerns und die daraus gebildete Massenzahl AZN
+Je nach ihrer Protonenzahl gehören die Atome zu einem der <num> bekannten chemischen Elemente von Wasserstoff mit Z<num> bis Oganesson mit Z<num>
+Davon sind <num> in natürlichen Vorkommen entdeckt worden <num> nur nach künstlicher Herstellung durch Kernreaktionen
+Die Ordnung der Elemente wird im Periodensystem - wichtig für die Chemie - graphisch veranschaulicht
+Darin werden die Elemente mit aufsteigender Ordnungszahl in Form einer Tabelle angeordnet
+Jede Zeile wird als Periode des Periodensystems bezeichnet und endet wenn das jeweilige Orbital mit Elektronen voll besetzt ist Edelgas
+In den nächsten Zeilen wiederholt sich aufgrund der schrittweisen Elektronenbesetzung der nächsten Orbitale der chemische Charakter der Elemente
+So stehen Elemente mit ähnlichen chemischen Eigenschaften in einer Spalte untereinander sie bilden eine Gruppe des Periodensystems
+Atome eines Elements die sich in der Neutronenzahl unterscheiden gehören zu verschiedenen Isotopen des Elements
+Insgesamt bestehen die <num> Elemente aus etwa <num> Isotopen wovon <num> künstlich erzeugt wurden
+Isotope werden - bis auf die Ausnahmen der Wasserstoffisotope Deuterium und Tritium - nach dem chemischen Element und der Massenzahl bezeichnet
+Das Symbol für ein bestimmtes Isotop des Elements X hat die Form
+oder X-A Beispiele
+Pb-<num>
+Die Angabe der Protonenzahl Z ist redundant da sich Z schon aus der Ordnungszahl des Elements ergibt
+Nuklid ist die ganz allgemeine Bezeichnung für Atomarten unabhängig davon ob sie zum gleichen Element gehören oder nicht
+Die Nuklidkarte oder Isotopenkarte - wichtig für die Kernphysik und ihre Anwendungen - ist eine Tabelle in der jede Atomart einen eigenen Platz erhält
+Dazu wird auf einer Achse die Anzahl der Protonen auf der anderen die der Neutronen aufgetragen
+Häufig wird die Stabilität und bei instabilen Nukliden auch die Art der Umwandlung oder die Größenordnung der Halbwertszeit durch bestimmte Farben dargestellt
+Stabile und instabile radioaktive Atome
+Der Atomkern eines Nuklids
+kann im energetischen Grundzustand und in verschiedenen Anregungszuständen vorliegen
+Wenn darunter relativ langlebige sogenannte metastabile Zustände sind werden diese als Isomere bezeichnet und als eigene Nuklide gezählt Symbol
+o ä Nach dieser Definition sind mit dem Stand von <num> insgesamt etwa <num> Nuklide bekannt
+In der Kernphysik werden Nuklide mit unterschiedlichen Protonenzahlen aber gleicher Massenzahl
+als Isobare bezeichnet
+Seltener werden unter dem Namen Isotone Nuklide mit verschiedenen Protonenzahlen aber gleicher Neutronenzahl zusammengefasst
+Nur etwa <num> Isotope von <num> Elementen haben einen stabilen Kern
+Alle anderen Atome sind instabil und wandeln sich über kurz oder lang in Atome eines stabilen Isotops um
+Da sie dabei im Allgemeinen ionisierende Strahlung aussenden heißen sie auch Radioisotope oder Radionuklide
+Auf der Erde wurden in den natürlichen Vorkommen neben allen <num> stabilen Isotopen <num> Radioisotope gefunden die sich auf <num> radioaktive Elemente verteilen und die natürliche Radioaktivität verursachen Viele weitere kurzlebige Isotope existieren im Inneren von Sternen insbesondere während der Supernova-Phase
+Seltene und theoretische Formen
+Als Rydberg-Atom wird ein Atom bezeichnet in dem ein Elektron in einem so hohen Energiezustand angeregt ist dass es den Atomkern teilweise auch den gesamten Atomrumpf bestehend aus dem Atomkern und den restlichen Elektronen in weitem Abstand umkreist und sein Verhalten damit dem eines klassischen Teilchens ähnelt
+Rydberg-Atome können über <num>-mal größer sein als nicht angeregte Atome
+Da sie extrem empfindlich auf äußere Felder reagieren kann man mit ihnen z B
+die Wechselwirkung mit einem einzelnen Photon im Detail untersuchen
+Sind zwei oder mehr Elektronen in solchen Zuständen angeregt spricht man von planetarischen Atomen
+Im teils übertragenen Sinn werden als exotische Atome auch solche Systeme bezeichnet die in physikalischer Hinsicht gewisse Ähnlichkeiten zu den gewöhnlichen Atomen aufweisen
+In ihnen kann z B
+eines der Protonen Neutronen oder Elektronen durch ein anderes Teilchen derselben Ladung ersetzt worden sein
+Wird etwa ein Elektron durch ein schwereres Myon ersetzt bildet sich ein myonisches Atom
+Als Positronium wird ein exotisches Atom bezeichnet in dem ein Elektron statt an ein Proton an ein Positron das ist das positiv geladene Antiteilchen des Elektrons gebunden ist
+Auch Atome die gänzlich aus Antiteilchen zur normalen Materie aufgebaut sind sind möglich
+So wurden erstmals <num> am Genfer CERN Antiwasserstoffatome künstlich hergestellt und nachgewiesen An solchen exotischen Atomen lassen sich unter anderem fundamentale physikalische Theorien überprüfen
+Des Weiteren wird der Name Atom manchmal auch für Zwei-Teilchen-Systeme verwendet die nicht durch elektromagnetische Wechselwirkung zusammengehalten werden sondern durch die starke Wechselwirkung
+Bei einem solchen Quarkonium handelt es sich um ein kurzlebiges Elementarteilchen vom Typ Meson das aus einem Quark und seinem Antiteilchen aufgebaut ist
+Ein Quarkonium-Atom lässt sich in seinen verschiedenen metastabilen Zuständen so durch Quantenzahlen klassifizieren wie das Wasserstoffatom
+Entstehung
+Etwa eine Sekunde nach dem Urknall kamen die ständigen Umwandlungen zwischen den Elementarteilchen zur Ruhe übrig blieben Elektronen Protonen und Neutronen
+In den darauf folgenden drei Minuten verbanden sich in der primordialen Nukleosynthese die vorhandenen Neutronen mit Protonen zu den einfachsten Kernen Deuterium Helium in geringerem Umfang auch Lithium und möglicherweise in noch kleineren Mengen Beryllium und Bor
+Die übrigen Protonen <num> Prozent blieben erhalten Die ersten neutralen Atome mit dauerhaft gebundenen Elektronen wurden erst <num> Jahre nach dem Urknall in der Rekombinationsphase gebildet als das Universum durch Expansion so weit abgekühlt war dass die Atome nicht sogleich wieder ionisiert wurden
+Die Kerne aller schwereren Atome wurden und werden durch verschiedene Prozesse der Kernfusion erzeugt
+Am wichtigsten ist die stellare Nukleosynthese durch die in Sternen zunächst Helium anschließend auch die schwereren Elemente bis zum Eisen gebildet werden
+Elemente mit höheren Kernladungszahlen als Eisen entstehen in explosionsartigen Vorgängen wie im r-Prozess in Supernovae und im s-Prozess in AGB-Sternen die kurz vor dem Ende ihrer Lebensdauer sind
+Kleine Mengen verschiedener Elemente und Isotope werden auch dadurch gebildet dass schwere Kerne wieder geteilt werden
+Das geschieht durch radioaktive Zerfälle siehe Zerfallsreihe die u a für einen Teil des Vorkommens von Helium und Blei verantwortlich sind und Spallationen die für die Entstehung von Lithium Beryllium und Bor wichtig sind
+Vorkommen und Verteilung
+DateiElement-haeufigkeitsvg
+Im beobachtbaren Universum liegen die Atome mit einer mittleren Dichte von <num> Atomem vor
+Nach dem Urknallmodell Lambda-CDM-Modell bilden sie etwa <num> Prozent der gesamten Energiedichte
+Der Rest dessen Natur noch weitgehend unklar ist setzt sich aus etwa <num> Prozent dunkler Materie und <num> Prozent dunkler Energie zusammen sowie kleinen Beiträgen von Neutrinos und elektromagnetischer Strahlung Im Inneren einer Galaxie wie etwa der Milchstraße ist im interstellaren Medium ISM die Dichte der Atome wesentlich höher und liegt zwischen <num> und <num> Atomem<num> Die Sonne befindet sich in der weitgehend staubfreien lokalen Blase daher ist die Dichte in der Umgebung des Sonnensystems nur etwa <num> Atomem<num> In festen Himmelskörpern wie der Erde beträgt die Atomdichte etwa <num> Atomem<num>
+In der Verteilung der Elemente dominiert im Universum Wasserstoff mit rund drei Viertel der Masse danach folgt Helium mit etwa einem Viertel
+Alle schwereren Elemente sind viel seltener und machen nur einen kleinen Teil der im Universum vorhandenen Atome aus
+Ihre Häufigkeiten werden von den verschiedenen Mechanismen der Nukleosynthese bestimmt
+Im Sonnensystem sind Wasserstoff und Helium vorwiegend in der Sonne und den Gasplaneten enthalten
+Dagegen überwiegen auf der Erde die schweren Elemente
+Die häufigsten Elemente sind hier Sauerstoff Eisen Silicium und Magnesium
+Der Erdkern besteht vorwiegend aus Eisen während in der Erdkruste Sauerstoff und Silicium vorherrschen
+Bestandteile des Atoms
+Die beiden Hauptbestandteile eines Atoms sind der Atomkern und die Atomhülle
+Die Hülle besteht aus Elektronen
+Sie trägt mit weniger als <num> Prozent zur Masse des Atoms bei bestimmt aber dessen Größe und dessen Verhalten gegenüber anderen Atomen wenn sie einander nahe kommen
+Der Kern besteht aus Protonen und Neutronen ist im Durchmesser zehn- bis hunderttausendmal kleiner als die Hülle enthält aber mehr als <num> Prozent der Masse des Atoms
+Atomkern
+Aufbau
+DateiBinding energy curve - common isotopes DEsvg
+Die in einem Atom vorhandenen Protonen und Neutronen zusammen auch als Nukleonen bezeichnet sind aneinander gebundenen und bilden den Atomkern
+Die Nukleonen zählen zu den Hadronen
+Das Proton ist positiv geladen das Neutron ist elektrisch neutral
+Proton und Neutron haben einen Durchmesser von etwa <num> fm Femtometer und sind selber keine Elementarteilchen sondern nach dem Standardmodell der Elementarteilchenphysik aus den punktförmigen Quarks aufgebaut
+Jeweils drei Quarks binden sich durch die starke Wechselwirkung die durch Gluonen vermittelt wird zu einem Nukleon
+Die starke Wechselwirkung ist darüber hinaus für den Zusammenhalt der Nukleonen im Atomkern verantwortlich insbesondere ist die Anziehung bis zu etwa <num> fm Abstand deutlich stärker als die gegenseitige elektrische Abstoßung der Protonen Unterhalb von etwa <num> fm wird die starke Wechselwirkung der Hadronen jedoch stark abstoßend
+Anschaulich gesprochen verhalten sich die Nukleonen im Kern also etwa wie harte Kugeln die aneinander haften
+Daher steigt das Volumen des Kerns proportional zur Nukleonenzahl Massenzahl
+Sein Radius beträgt etwa
+fm
+Der leichteste Atomkern besteht aus nur einem Proton
+Mehrere Protonen stoßen sich zwar gemäß der Elektrostatik ab können zusammen mit einer geeigneten Anzahl von Neutronen aber ein stabiles System bilden
+Doch schon bei kleinen Abweichungen von dem energetisch günstigsten Zahlenverhältnis ist der Kern instabil und wandelt sich spontan um indem aus einem Neutron ein Proton wird oder umgekehrt und die frei werdende Energie und Ladung als Betastrahlung abgegeben wird
+Kerne mit bis zu etwa <num> Protonen sind nur bei annähernd gleich großer Neutronenzahl stabil
+Darüber steigt in den stabilen Atomkernen das Verhältnis von Neutronen zu Protonen von <num> bis auf etwa <num><num> weil bei größeren Protonenzahlen wegen ihrer elektrostatischen Abstoßung die Anzahl der Neutronen schneller anwachsen muss als die der Protonen Details siehe Tröpfchenmodell
+Die Bindungsenergie liegt in stabilen Kernen abgesehen von den leichtesten oberhalb von <num> MeV pro Nukleon siehe Abbildung und übertrifft damit die Bindungsenergie der äußeren Elektronen der Atomhülle oder die chemische Bindungsenergie in stabilen Molekülen um das ca <num>-fache
+Kerne mit bestimmten Nukleonenzahlen die als Magische Zahl bezeichnet werden beispielsweise Helium-<num> Sauerstoff-<num> oder Blei-<num> sind besonders stabil was mit dem Schalenmodell des Atomkerns erklärt werden kann
+Oberhalb einer Zahl von <num> Protonen also jenseits von Blei sind alle Kerne instabil
+Sie wandeln sich durch Ausstoßen eines Kerns He-<num> in leichtere Kerne um Alphastrahlung
+Dies wiederholt sich zusammen mit Betastrahlung so lange bis ein stabiler Kern erreicht ist mehrere Zerfallsstufen bilden eine Zerfallsreihe
+Auch zu den Protonenzahlen <num> Technetium und <num> Promethium existiert kein stabiler Kern
+Daher kann es insgesamt nur <num> verschiedene stabile chemische Elemente geben alle weiteren sind radioaktiv
+Sie kommen auf der Erde nur dann natürlich vor wenn sie selber oder eine ihrer Muttersubstanzen eine genügend lange Halbwertzeit haben
+Masse
+Da der Großteil der Atommasse von den Neutronen und Protonen stammt und diese etwa gleich schwer sind wird die Gesamtzahl dieser Teilchen in einem Atom als Massenzahl bezeichnet
+Die genaue Masse eines Atoms wird oft in der atomaren Masseneinheit u angegeben ihr Zahlenwert ist dann etwa gleich der Massenzahl
+Kleinere Abweichungen entstehen durch den Massendefekt der Atomkerne
+Die atomare Masseneinheit ergibt sich aus der Definition der SI-Einheit des Mols in der Art und Weise dass ein Atom des Kohlenstoffisotops <num>C im Grundzustand inklusive seiner Hüllenelektronen eine Masse von exakt <num> u besitzt
+Damit beträgt <num> u gleich <num>
+<num>-<num> kg Ein Atom des leichtesten Wasserstoffisotops hat eine Masse von <num> u
+Das schwerste stabile Nuklid ist das Bleiisotop <num>Pb mit einer Masse von <num> u
+Da makroskopische Stoffmengen so viele Atome enthalten dass die Angabe ihrer Anzahl als natürliche Zahl unhandlich wäre erhielt die Stoffmenge eine eigene Einheit das Mol
+Ein Mol sind etwa <num>nbspnbsp<num><sup><num><sup> Atome oder auch Moleküle oder andere Teilchen die betrachtete Teilchenart muss immer mitgenannt werden
+Die Masse von <num> Mol Atomen der Atommasse X u ist daher exakt X g Daher ist es in der Chemie üblich Atommassen statt in u auch indirekt in gmol anzugeben
+Bildung und Zerfall
+In welcher Art ein instabiler Atomkern zerfällt ist für das jeweilige Radionuklid typisch
+Bei manchen Nukliden können die untereinander völlig gleichen Kerne auch auf verschiedene Arten zerfallen so dass mehrere Zerfallskanäle mit bestimmten Anteilen beteiligt sind
+Die wichtigsten radioaktiven Zerfälle sind
+Alpha-Zerfall bei dem sich aus zwei Protonen und zwei Neutronen des Kerns durch die starke Wechselwirkung ein Helium-Atomkern bildet der ausgestoßen wird
+Beta-Zerfall bei dem mittels der schwachen Wechselwirkung ein Neutron des Kerns in ein Proton oder umgekehrt umgewandelt wird und ein Elektron und ein Antineutrino beziehungsweise ein Positron und ein Neutrino ausgesendet werden
+Gamma-Zerfall bei dem ein angeregter Kern durch elektromagnetische Wechselwirkung Gammastrahlung erzeugt und in ein niedrigeres Energieniveau gelangt bei gleichbleibender Protonen- und Neutronenzahl
+DateiNuclear fusionsvg Die Energien der Strahlungen sind für das jeweilige Nuklid charakteristisch ebenso wie die Halbwertszeit die angibt wie lange es dauert bis die Hälfte einer Probe des Nuklids zerfallen ist
+Durch Anlagerung eines Neutrons kann sich ein Kern in das nächstschwerere Isotop desselben Elements verwandeln
+Durch den Beschuss mit Neutronen oder anderen Atomkernen kann ein großer Atomkern in mehrere kleinere Kerne gespalten werden
+Einige schwere Nuklide können sich auch ohne äußere Einwirkung spontan spalten
+Größere Atomkerne können aus kleineren Kernen gebildet werden
+Dieser Vorgang wird Kernfusion genannt
+Für eine Fusion müssen sich Atomkerne sehr nahe kommen
+Diesem Annähern steht die elektrostatische Abstoßung beider Kerne der sogenannte Coulombwall entgegen
+Aus diesem Grund ist eine Kernfusion außer in bestimmten Experimenten nur unter sehr hohen Temperaturen von mehreren Millionen Grad und hohen Drücken wie sie im Inneren von Sternen herrschen möglich
+Die Kernfusion ist bei Nukliden bis zum Nickel-<num> eine exotherme Reaktion so dass sie im Großen selbsterhaltend ablaufen kann
+Sie ist die Energiequelle der Sterne
+Bei Atomkernen jenseits des Nickels nimmt die Bindungsenergie pro Nukleon ab die Fusion schwererer Atomkerne ist daher endotherm und damit kein selbsterhaltender Prozess
+Die Kernfusion in Sternen kommt daher zum Erliegen wenn die leichten Atomkerne aufgebraucht sind
+Atomhülle
+Aufbau und Bindungsenergie
+Die Atomhülle besteht aus Elektronen die aufgrund ihrer negativen Ladung an den positiven Atomkern gebunden sind
+Sie wird oft auch als Elektronenhülle bezeichnet
+Bei einem neutralen Atom beträgt die durchschnittliche Bindungsenergie der
+Elektronen der Hülle etwa
+Sie nimmt daher mit steigender Teilchenzahl erheblich zu im Gegensatz zur durchschnittlichen Bindungsenergie pro Nukleon im Kern
+Zur Erklärung wird angeführt dass zwischen Nukleonen nur Bindungskräfte kurzer Reichweite wirken die kaum über die benachbarten Teilchen hinausreichen während die Hülle durch die elektrostatische Anziehungskraft gebunden ist die als langreichweitige Wechselwirkung mit größerem Abstand vom Kern vergleichsweise schwach abnimmt
+Abgesehen von der Masse die zu über <num> Prozent im Atomkern konzentriert ist ist die Atomhülle für praktisch alle äußeren Eigenschaften des Atoms verantwortlich
+Der Begriff Atommodell bezieht sich daher im engeren Sinn meist nur auf die Hülle siehe Liste der Atommodelle
+Ein einfaches Atommodell ist das Schalenmodell nach dem die Elektronen sich in bestimmten Schalen um den Kern anordnen in denen jeweils für eine bestimmte Anzahl Elektronen Platz ist
+Allerdings haben diese Schalen weder einen bestimmten Radius noch eine bestimmte Dicke sondern überlappen und durchdringen einander teilweise
+Wesentliche Eigenschaften der Hülle sind oben unter Quantenmechanische Atommodelle und Erklärung grundlegender Atomeigenschaften dargestellt
+In den nachfolgenden Abschnitten folgen weitere Details
+Interpretation grundlegender Atomeigenschaften im Rahmen des Schalenmodells
+Die Atomhülle bestimmt die Stärke und Abstandsabhängigkeit der Kräfte zwischen zwei Atomen
+Im Abstandsbereich mehrerer Atomdurchmesser polarisieren sich die gesamten Atomhüllen wechselseitig sodass durch elektrostatische Anziehung anziehende Kräfte die Van-der-Waals-Kräfte entstehen
+Sie bewirken vor allem die Kondensation der Gase zu Flüssigkeiten also einen Wechsel der Aggregatzustände
+Die näherungsweise Inkompressibilität der Flüssigkeiten und Festkörper hingegen beruht darauf dass alle Atome bei starker Annäherung einander stark abstoßen sobald sich ihre Hüllen im Raum merklich überschneiden und daher verformen müssen
+Außer im Fall zweier Wasserstoffatome die jeweils nur ein Elektron in der Hülle haben spielt die elektrostatische Abstoßung der beiden Atomkerne dabei nur eine geringe Rolle
+In einem mittleren Abstandsbereich zwischen dem Vorherrschen der schwach anziehenden Van-der-Waals-Kräfte und der starken Abstoßung kommt es zwischen zwei oder mehr zueinander passenden Atomhüllen zu einer besonders starken Anziehung der chemischen Bindung
+Bei Atomen bestimmter Elemente kann diese Anziehung zu einem stabilen Molekül führen das aus Atomen in zahlenmäßig genau festgelegter Beteiligung und räumlicher Anordnung aufgebaut ist
+Die Moleküle sind die kleinsten Stoffeinheiten der chemischen Verbindungen also der homogenen Materialien in all ihrer Vielfalt
+Vermittelt über die Hüllen ihrer Atome ziehen auch Moleküle einander an
+Ein fester Körper entsteht wenn viele Moleküle sich aneinander binden und dabei weil es energetisch günstig ist eine feste Anordnung einhalten
+Ist diese Anordnung regelmäßig bildet sich ein Kristallgitter
+Infolge dieser Bindung ist der feste Körper nicht nur weitgehend inkompressibel wie eine Flüssigkeit sondern im Unterschied zu dieser auch auf Zug belastbar und deutlich weniger leicht verformbar
+Verbinden sich Atome metallischer Elemente miteinander ist ihre Anzahl nicht festgelegt und es können sich nach Größe und Gestalt beliebige Körper bilden
+Vor allem chemisch reine Metalle zeigen dann meist auch eine große Verformbarkeit
+Verbindungen verschiedener Metalle werden Legierung genannt
+Die Art der Bindung von Metallatomen erklärt warum Elektronen sich fast frei durch das Kristallgitter bewegen können was die große elektrische Leitfähigkeit und Wärmeleitfähigkeit der Metalle verursacht
+Zusammengefasst ergeben sich aus der Wechselwirkung der Atomhüllen miteinander die mechanische Stabilität und viele weitere Eigenschaften der makroskopischen Materialien
+Aufgrund des unscharfen Randes der Atomhülle liegt die Größe der Atome nicht eindeutig fest
+Die als Atomradien tabellierten Werte sind aus der Bindungslänge gewonnen das ist der energetisch günstigste Abstand zwischen den Atomkernen in einer chemischen Bindung
+Insgesamt zeigt sich mit steigender Ordnungszahl eine in etwa periodische Variation der Atomgröße die mit der periodischen Variation des chemischen Verhaltens gut übereinstimmt
+Im Periodensystem der Elemente gilt allgemein dass innerhalb einer Periode also einer Zeile des Systems eine bestimmte Schale aufgefüllt wird
+Von links nach rechts nimmt die Größe der Atome dabei ab weil die Kernladung anwächst und daher alle Schalen stärker angezogen werden
+Wenn eine bestimmte Schale mit den stark gebundenen Elektronen gefüllt ist gehört das Atom zu den Edelgasen
+Mit dem nächsten Elektron beginnt die Besetzung der Schale mit nächstgrößerer Energie was mit einem größeren Radius verbunden ist
+Innerhalb einer Gruppe also einer Spalte des Periodensystems nimmt die Größe daher von oben nach unten zu
+Dementsprechend ist das kleinste Atom das Heliumatom am Ende der ersten Periode mit einem Radius von <num> pm während eines der größten Atome das Caesiumatom ist das erste Atom der <num> Periode
+Es hat einen Radius von <num> pm
+Erklärung der Atomeigenschaften im Rahmen des Orbitalmodells
+Die dem Schalenmodell zugrundeliegenden Elektronenschalen ergeben sich durch die Quantisierung der Elektronenenergien im Kraftfeld des Atomkerns nach den Regeln der Quantenmechanik
+Um den Kern herum bilden sich verschiedene Atomorbitale das sind unscharf begrenzte Wahrscheinlichkeitsverteilungen für mögliche räumliche Zustände der Elektronen
+Jedes Orbital kann aufgrund des Pauli-Prinzips mit maximal zwei Elektronen besetzt werden dem Elektronenpaar
+Die Orbitale die unter Vernachlässigung der gegenseitigen Abstoßung der Elektronen und der Feinstruktur theoretisch die gleiche Energie hätten bilden eine Schale
+Die Schalen werden mit der Hauptquantenzahl durchnummeriert oder fortlaufend mit den Buchstaben K L M bezeichnet
+Genauere Messungen zeigen dass ab der zweiten Schale nicht alle Elektronen einer Schale die gleiche Energie besitzen
+Falls erforderlich wird durch die Nebenquantenzahl oder Drehimpulsquantenzahl eine bestimmte Unterschale identifiziert
+Sind die Orbitale angefangen vom energetisch niedrigsten so weit mit Elektronen besetzt dass die gesamte Elektronenzahl gleich der Protonenzahl des Kerns ist ist das Atom neutral und befindet sich im Grundzustand
+Werden in einem Atom ein oder mehrere Elektronen in energetisch höherliegende Orbitale versetzt ist das Atom in einem angeregten Zustand
+Die Energien der angeregten Zustände haben für jedes Atom wohlbestimmte Werte die sein Termschema bilden
+Ein angeregtes Atom kann seine Überschussenergie abgeben durch Stöße mit anderen Atomen durch Emission eines der Elektronen Auger-Effekt oder durch Emission eines Photons also durch Erzeugung von Licht oder Röntgenstrahlung
+Bei sehr hoher Temperatur oder in Gasentladungen können die Atome durch Stöße Elektronen verlieren siehe Ionisationsenergie es entsteht ein Plasma so z B
+in einer heißen Flamme oder in einem Stern
+DateiFraunhofer lines DEsvg Da die Energien der Quanten der emittierten Strahlung je nach Atom bzw Molekül und den beteiligten Zuständen verschieden sind lässt sich durch Spektroskopie dieser Strahlung die Quelle im Allgemeinen eindeutig identifizieren
+Beispielsweise zeigen die einzelnen Atome ihr elementspezifisches optisches Linienspektrum
+Bekannt ist etwa die Natrium-D-Linie eine Doppellinie im gelben Spektralbereich bei <num> nm und <num> nm die auch in nebenstehender Abbildung mit D-<num> bezeichnet wird
+Ihr Aufleuchten zeigt die Anwesenheit von angeregten Natrium-Atomen an sei es auf der Sonne oder über der Herdflamme bei Anwesenheit von Natrium oder seinen Salzen
+Da diese Strahlung einem Atom auch durch Absorption dieselbe Energie zuführen kann lassen sich die Spektrallinien der Elemente sowohl in Absorptions- als auch in Emissionsspektren beobachten
+Diese Spektrallinien lassen sich auch verwenden um Frequenzen sehr präzise zu vermessen beispielsweise für Atomuhren
+Obwohl Elektronen sich untereinander elektrostatisch abstoßen können zusätzlich bis zu zwei weitere Elektronen gebunden werden wenn es bei der höchsten vorkommenden Elektronenenergie noch Orbitale mit weiteren freien Plätzen gibt siehe Elektronenaffinität
+Chemische Reaktionen d h
+die Verbindung mehrerer Atome zu einem Molekül oder sehr vieler Atome zu einem Festkörper werden dadurch erklärt dass ein oder zwei Elektronen aus einem der äußeren Orbitale eines Atoms Valenzelektronen unter Energiegewinn auf einen freien Platz in einem Orbital eines benachbarten Atoms ganz hinüberwechseln Ionenbindung oder sich mit einer gewissen Wahrscheinlichkeit dort aufhalten kovalente Bindung durch ein bindendes Elektronenpaar
+Dabei bestimmt die Elektronegativität der Elemente bei welchem Atom sich die Elektronen wahrscheinlicher aufhalten
+In der Regel werden chemische Bindungen so gebildet dass die Atome die Elektronenkonfiguration eines Edelgases erhalten Edelgasregel
+Für das chemische Verhalten des Atoms sind also Form und Besetzung seiner Orbitale entscheidend
+Da diese allein von der Protonenzahl bestimmt werden zeigen alle Atome mit gleicher Protonenzahl also die Isotope eines Elements nahezu das gleiche chemische Verhalten
+Nähern sich zwei Atome über die chemische Bindung hinaus noch stärker an müssen die Elektronen eines Atoms wegen des Pauli-Prinzips auf freie aber energetisch ungünstige Orbitale des anderen Atoms ausweichen was einen erhöhten Energiebedarf und damit eine abstoßende Kraft nach sich zieht
+Wechselwirkung zwischen Kern und Hülle
+Mit großer Genauigkeit wird die Wechselwirkung zwischen Kern und Hülle schon durch den einfachen Ansatz beschrieben in dem der Kern eine punktförmige Quelle eines elektrostatischen Felds nach dem Coulomb-Gesetz darstellt
+Alle genannten Atommodelle beruhen hierauf
+Aufgrund zusätzlicher Effekte die in erweiterten Modellen behandelt werden sind nur extrem kleine Korrekturen nötig die unter dem Namen Hyperfeinstruktur zusammengefasst werden
+Zu berücksichtigen sind hier drei Effekte erstens die endliche Ausdehnung die jeder Kern besitzt zweitens eine magnetische Dipolwechselwirkung wenn sowohl Kern als auch Hülle eine Drehimpulsquantenzahl von mindestens
+haben und drittens eine elektrische Quadrupolwechselwirkung wenn beide Drehimpulsquantenzahlen mindestens <num> sind
+Die endliche Ausdehnung des Kerns - verglichen mit einer theoretischen Punktladung - bewirkt eine schwächere Anziehung derjenigen Elektronen deren Aufenthaltswahrscheinlichkeit bis in den Kern hineinreicht
+Betroffen sind nur s-Orbitale Bahndrehimpuls Null
+Bei Atomen mittlerer Ordnungszahl liegt die Korrektur in der Größenordnung von <num> Prozent
+Die magnetischen Dipol- bzw elektrischen Quadrupol-Momente von Hülle und Kern bewirken eine Kopplung mit der Folge dass die Gesamtenergie eines freien Atoms je nach Quantenzahl seines Gesamtdrehimpulses äußerst geringfügig aufgespalten ist
+Im H-Atom beträgt die Aufspaltung etwa ein Millionstel der Bindungsenergie des Elektrons siehe <num>-cm-Linie
+Anschaulich gesprochen hängt die Energie davon ab in welchem Winkel die Achsen des magnetischen Dipolmoments bzw elektrischen Quadrupolmoments von Kern und Hülle zueinander stehen
+Auch bei Atomen in Flüssigkeiten und Festkörpern treten diese Wechselwirkungen in entsprechend modifizierter Form auf
+Trotz der Kleinheit der dadurch verursachten Effekte haben sie eine große Rolle in der Atom- und Kernforschung gespielt und sind in besonderen Fällen auch bei modernen Anwendungen wichtig
+Beobachtung
+Indirekte Beobachtung
+Indirekte Möglichkeiten Atome zu erkennen beruhen auf der Beobachtung der von ihnen ausgehenden Strahlung
+So kann aus Atomspektren beispielsweise die Elementzusammensetzung entfernter Sterne bestimmt werden
+Die verschiedenen Elemente lassen sich durch charakteristische Spektrallinien identifizieren die auf Emission oder Absorption durch Atome des entsprechenden Elements in der Sternatmosphäre zurückgehen
+Gasentladungslampen die dasselbe Element enthalten zeigen diese Linien als Emissionslinien Auf diese Weise wurde z B
+<num> Helium im Spektrum der Sonne nachgewiesen - über <num> Jahre bevor es auf der Erde entdeckt wurde
+Ein Atom kann ionisiert werden indem eines seiner Elektronen entfernt wird
+Die elektrische Ladung sorgt dafür dass die Flugbahn eines Ions von einem Magnetfeld abgelenkt wird
+Dabei werden leichte Ionen stärker abgelenkt als schwere
+Das Massenspektrometer nutzt dieses Prinzip um das Masse-zu-Ladung-Verhältnis von Ionen und damit die Atommassen zu bestimmen
+Die Elektronenenergieverlustspektroskopie misst den Energieverlust eines Elektronenstrahls bei der Wechselwirkung mit einer Probe in einem Transmissionselektronenmikroskop
+Beobachtung einzelner Atome
+DateiAtomic resolution Au<num>JPG Eine direkte Abbildung die einzelne Atome erkennen lässt wurde erstmals <num> mit dem Feldionenmikroskop oder Feldemissionsmikroskop erzielt
+Auf einem kugelförmigen Bildschirm in dessen Mittelpunkt sich eine extrem feine Nadelspitze befindet erscheint ein etwa millionenfach vergrößertes Bild Darin sind die obersten Atome die die Spitze bilden nebeneinander als einzelne Lichtpunkte zu erkennen
+Dies kann heute auch im Physikunterricht an der Schule vorgeführt werden
+Das Bild entsteht in Echtzeit und erlaubt z B
+die Betrachtung der Wärmebewegung einzelner Fremdatome auf der Spitze
+Auch das Rastertunnelmikroskop ist ein Gerät das einzelne Atome an der Oberfläche eines Körpers sichtbar macht
+Es verwendet den Tunneleffekt der es Teilchen erlaubt eine Energiebarriere zu passieren die sie nach klassischer Physik nicht überwinden könnten
+Bei diesem Gerät tunneln Elektronen zwischen einer elektrisch leitenden Spitze und der elektrisch leitenden Probe
+Bei Seitwärtsbewegungen zur Abrasterung der Probe wird die Höhe der Spitze so nachgeregelt dass immer derselbe Strom fließt
+Die Bewegung der Spitze bildet die Topographie und Elektronenstruktur der Probenoberfläche ab
+Da der Tunnelstrom sehr stark vom Abstand abhängt ist die laterale Auflösung viel feiner als der Radius der Spitze manchmal atomar
+Eine tomographische Atomsonde erstellt ein dreidimensionales Bild mit einer Auflösung unterhalb eines Nanometers und kann einzelne Atome ihrem chemischen Element zuordnen
+Literatur
+Weblinks
+HydrogenLab Wie sieht ein Atom aus
+Übersicht über die verschiedenen Atommodelle
+Geschichtlicher Überblick zum Atombegriff aus naturphilosophischer Perspektive von Brigitte Falkenburg im Online-Lexikon naturphilosophischer Grundbegriffe
+Einzelnachweise
+Charles Kittel Einführung in die Festkörperphysik <num> Auflage <num> Verlag R Oldenbourg München S <num>
+F Dannemann Die Naturwissenschaften in ihrer Entwicklung und in ihrem Zusammenhange Bd <num> Verlag W Engelmann <num> S <num>
+Loschmidt Zur Grösse der Luftmoleküle In Sitzungsberichte der kaiserlichen Akademie der Wissenschaften Wien Band <num> <num> Abt II S <num>-<num>
+Walther Kossel Über Molekülbildung als Frage des Atombaus Annalen der Physik Bd <num> <num> S <num>-<num> doi<num>andp<num>
+G Baur et al Production of antihydrogen In
+Physics Letters B <num> Nr <num> <num> S <num>-<num> doi<num><num>-<num><num><num>-<num> Preprint online
+DateiAuscultation of the anterior Thoraxjpg DateiRod of Asclepius<num>svg Ein Arzt Mehrzahl Ärzte weiblich Ärztin Ärztinnen ist ein medizinisch ausgebildeter und zur Ausübung der Heilkunde zugelassener Heilkundiger
+Der Arztberuf gilt der Vorbeugung Prävention Erkennung Diagnose Behandlung Therapie und Nachsorge von Krankheiten Leiden oder gesundheitlichen Beeinträchtigungen und umfasst auch ausbildende Tätigkeiten
+Der Arzt stellt sich damit in den Dienst der Gesundheit und ist bei seinem Handeln moralischen und ethischen Grundsätzen verpflichtet vergleiche Genfer Deklaration des Weltärztebundes
+Die Vielfalt an Krankheiten und Behandlungsmöglichkeiten hat in der Humanmedizin und Tierheilkunde mit der Zeit zu einer großen Anzahl von Fachgebieten und weiteren Differenzierungen geführt
+Liste medizinischer Fachgebiete
+Bezeichnungen
+Die Bezeichnung Arzt
+zog während des Mittelalters aus der lateinischen Gelehrtensprache ins Deutsche ein und zwar über die latinisierte Variante
+spätlateinisch auch
+des griechischen
+klassische Aussprache
+Oberarzt Leibarzt seit dem <num> Jahrhundert die Amtsbezeichnung von Leibärzten bei Hofe und von öffentlich bestallten Gemeindeärzten einer Zusammensetzung aus
+Kommando und
+In vielen fachsprachlichen Komposita tritt das ursprüngliche griechische Wort
+bzw die latinisierte Form
+als Wortbestandteil auf iatrogen durch ärztliches Handeln verursacht
+Psychiater
+Seelenarzt usw Über mittelhochdeutsche Vermittlung gelangte das Wort in andere Sprachen so
+Die germanische Bezeichnung für den Heilberuf
+ist beispielsweise im dänischen
+im schwedischen
+im englischen
+vgl Balds Leechbook oder im deutschen Familiennamen Lachmann erhalten und hat sich in andere Sprachen verbreitet z B
+Im polnischen
+und tschechischen
+ist die germanische Wurzel mit einem slawischen Suffix -arz -ař verbunden
+Die lateinische Bezeichnung
+ursprünglich als allgemeine vom Ausbildungsstand unabhängige Berufszeichnung seit dem <num> Jahrhundert dann vom
+bzw
+dem Wundarzt unterschieden oder eine davon abgeleitete Form findet sich vor allem in den romanischen Sprachen etwa
+aber unter romanischem Einfluss auch in anderen Sprachen
+Die Bezeichnung
+meinte meist einen akademisch ausgebildeten Arzt
+In vielen Sprachen wird der Arzt umgangssprachlich nach seinem zumeist geführten akademischen Grad Doktor
+genannt
+Gelegentlich ebenfalls als Arzt wurden vor allem ab dem <num> Jahrhundert volksmedizinisch arbeitende Laienärzte bezeichnet
+Zum Arztberuf
+Geschichte
+Die Funktion des Arztes ist eine der ältesten der Menschheit Medizingeschichtlich gesehen entstand der Arztberuf aus dem Stand der Heilkundigen die schon unter den Priestern des Altertums zu finden waren
+Erste schriftliche Belege des Arztberufs stammen aus Mesopotamien und wurden im <num> Jahrtausend v Chr verfasst
+Die Ausbildung von Ärzten der Antike fand in sogenannten Ärzteschulen z B
+Schule von Kos Schule von Knidos Alexandrinische Schule statt die sich hinsichtlich ihrer Wissenvermittlung an unterschiedlichen ärztlichen Theorien z B
+Methodiker Pneumatiker Hippokratiker und philosophischen Strömungen z B
+Epikureer Stoiker ausrichteten
+Die moderne Ausbildung von Ärzten begann im <num> Jahrhundert mit der Erweiterung des naturwissenschaftlichen Wissens und der Einführung von systematischem praktischem Unterricht am Krankenbett
+Eine einheitliche Prüfungsordnung siehe auch Approbationsordnung für Ärzte gab es in Deutschland erstmals <num>
+<num> war der Anteil der Ärztinnen an der Gesamtzahl der berufstätigen Ärzte bereits auf <num> Prozent gestiegen wenngleich der Anteil der Frauen <num> zu Beginn des Studiums bei fast zwei Dritteln lag
+Gesundheit und Krankheitsverhalten
+Während die körperliche Gesundheit von männlichen Ärzten mit derjenigen der allgemeinen männlichen Bevölkerung vergleichbar zu sein scheint scheint die körperliche Gesundheit von Ärztinnen besser zu sein als die der allgemeinen weiblichen Bevölkerung
+Hinsichtlich der psychischen Gesundheit fällt auf dass Depressionen und Suchterkrankungen bei Ärzten häufiger vorkommen als in der restlichen Bevölkerung
+Ein weiteres bei Medizinern häufig auftretendes Krankheitsbild ist das Burnout-Syndrom das bereits bei Medizinstudenten in einer erhöhten Rate nachgewiesen werden kann
+Mehrere Studien zeigten eine gegenüber der allgemeinen Bevölkerung erhöhte Suizidrate unter Ärzten
+Das gegenüber der Normalbevölkerung erhöhte relative Risiko einen Suizid zu begehen lag für Ärzte bei <num>-<num> und für Ärztinnen bei <num>-<num> Da in den Studien meist nur eine kleine Zahl von Suiziden untersucht wurde waren die Vertrauensbereiche des wahren Wertes der Risikoerhöhung weit
+Es wird vermutet dass eine beträchtliche Anzahl von Selbstmorden nicht erfasst wird da diese fälschlicherweise als Vergiftungen oder Unfälle deklariert werden
+Von den verschiedenen beruflichen Spezialisierungen sind insbesondere Psychiater Anästhesisten und Allgemeinmediziner von einer erhöhten Suizidrate betroffen
+Als Ursachen des erhöhten Suizidrisikos werden verschiedene Faktoren diskutiert
+Ein Persönlichkeitsprofil mit zwanghaften Zügen kann infolge der beruflichen Anforderungen zu einer depressiven Störung führen
+Die Schwierigkeiten Familie und Karrierewunsch miteinander zu vereinbaren können insbesondere bei Ärztinnen zu Erschöpfung und Depression führen
+Suchterkrankungen wie beispielsweise Alkohol- Drogen- und Medikamentenabhängigkeit die bei Ärzten häufiger auftreten gehen ihrerseits meistens mit Depressionen und einer erhöhten Suizidrate einher
+Dieses für Ärzte und Ärztinnen festgestellte Risikoprofil ist berufsunabhängig und trifft für die meisten Suizidenten zu
+Psychische Probleme korrelieren häufig mit Zeitdruck und mangelnder Autonomie am Arbeitsplatz sowie belastenden Patient-Arzt-Beziehungen
+Ärzte werden seltener krankgeschrieben und zeigen eine mangelhafte Inanspruchnahme medizinischer Versorgungsleistungen
+Häufig behandeln sich Ärzte selbst
+Die eigenständige Behandlung eigener psychischer Störungen ist jedoch häufig ineffektiv
+Schutzpatron
+Die heiligen Zwillingsbrüder Cosmas und Damian gelten wegen ihres Arztberufs unter anderem auch als Schutzpatrone der Ärzte Ein weiterer Schutzpatron ist der heilige Pantaleon einer der Vierzehn Nothelfer
+Nationales
+Deutschland
+Rechtliche Einordnung des Berufes
+Der Arzt gehört in Deutschland seit <num> zu den Freien Berufen und ist seit <num> ein klassischer Kammerberuf
+Ärzte unterliegen einer staatlichen Überwachung der Zulassung Approbation in Deutschland s u in anderen EU-Ländern und unter anderem dem Arztwerberecht welches weitgehende Einschränkungen in der Publikation und Veröffentlichungen bedeutet
+Ärzte haften ihren Patienten zwar in der Regel nicht auf Erfolg ihres Handelns können ihnen aber unter dem Gesichtspunkt der Arzthaftung zum Schadenersatz verpflichtet sein
+Die freie Ausübung der Heilkunde ist in Deutschland nur approbierten Ärzten erlaubt
+Mit festgelegten Einschränkungen dürfen auch Heilpraktiker Kranke behandeln wobei die klar festgelegten Grenzen einzuhalten sind
+Ausnahmsweise werden spezielle Bereiche der Diagnostik und Therapie auch meist auf Veranlassung von Ärzten von Angehörigen der Gesundheitsfachberufe durchgeführt
+Ab dem Zeitpunkt der ärztlichen Approbation darf der Arzt die gesetzlich geschützte Bezeichnung Arzt führen und erhält mit ihr die staatliche Erlaubnis zur eigenverantwortlichen und selbstständigen ärztlichen Tätigkeit
+Die bundesweit einheitliche Approbationsordnung regelt das zuvor erfolgreich abzuleistende mindestens sechsjährige Medizinstudium bezüglich der Dauer und der Inhalte der Ausbildung in den einzelnen Fächern sowie der Prüfungen
+Das Studium der Medizin umfasst u a drei Examina sowie ein Jahr praktische Tätigkeit sogenanntes Praktisches Jahr Von Oktober <num> bis Oktober <num> war zur Erlangung der Vollapprobation zusätzlich eine <num>-monatige gering bezahlte Tätigkeit als Arzt im Praktikum unter Aufsicht eines approbierten Arztes gesetzlich vorgeschrieben
+Meist arbeitet ein approbierter Arzt für mehrere Jahre als Assistenzarzt an von der Landesärztekammer anerkannten Weiterbildungsstätten wie <num> Krankenhäuser <num>
+waren <num> in privater Trägerschaft seltener einzelne Großpraxen um sich auf einem oder mehreren Spezialgebieten der Medizin anrechenbar weiterzubilden und eventuell nach zusätzlich mindestens vierjähriger Weiterbildungszeit eine Facharztprüfung abzulegen
+Die Anforderungen dazu sind in den Weiterbildungsordnungen der Landesärztekammern geregelt Niedergelassene Ärzte arbeiten in freier Praxis gegebenenfalls auch mit mehreren Ärzten in einer Berufsausübungsgemeinschaft früher Gemeinschaftspraxis oder Praxisgemeinschaft s a
+Vertragsarztrechtsänderungsgesetz
+Honorarärzte arbeiten auf Honorarbasis für verschiedene Kliniken oder niedergelassene Ärzte
+Jeder Arzt ist meldepflichtiges Pflichtmitglied der Ärztekammer des Bundeslandes in deren Gebiet er wohnt bzw seine ärztliche Tätigkeit ausübt
+Im Jahr <num> waren in Deutschland bei den Landesärztekammern <num> Ärzte gemeldet Zur Behandlung von Versicherten der gesetzlichen Krankenversicherungen benötigt der Arzt eine Zulassung Facharzt in eigener Praxis oder Ermächtigung als Arzt in einem Krankenhaus oder ähnlicher Institution und ist dann auch Pflichtmitglied der Kassenärztlichen Vereinigung seines Niederlassungsbezirks
+Die kassenärztliche Zulassung besitzen <num> Ärzte Ende <num> selbstständige <num> Hausärzte und <num> Fachärzte In den Kliniken sind <num> Ärzte angestellt
+Ende <num> arbeiteten <num> ausländische Ärzte in Deutschland öfter im Osten
+<num> betrug die Zahl der berufstätigen Ärzte in Deutschland <num>
+Strafrechtlich sind ärztliche Eingriffe der Körperverletzung gleichgesetzt
+Diese ist nicht strafbar wenn die Einwilligung der behandelten Person nach einer Aufklärung vorliegt und die Handlung auf dem Stand des aktuellen medizinischen Wissens vorgenommen wird
+<num> ff
+StGB
+Ausnahmen bestehen wenn der Patient aufgrund seines Zustandes z B
+Bewusstlosigkeit nicht in der Lage ist seine Entscheidung mitzuteilen und durch die Unterlassung des Eingriffs die Gefahr von negativen gesundheitlichen Folgen oder sogar dem Tod des Patienten besteht
+Zudem können eingeschränkt- oder nichteinwilligungsfähige Personen wie z B
+Kinder oder in bestimmten Fällen seelisch Erkrankte auch gegen ihren Willen behandelt werden
+Hierfür existieren strenge rechtliche Regelungen und Verfahrenswege bei welchen neben dem Arzt auch andere Institutionen z B
+Amtsgericht oder gesetzlicher Betreuer an der Entscheidung mitwirken
+Vor Inkrafttreten des Gesetzes zur Bekämpfung von Korruption im Gesundheitswesen haben niedergelassene für die vertragsärztliche Versorgung zugelassene Ärzte die Tatbestandsmerkmale des
+StGB nicht erfüllt da diese laut Beschluss des Bundesgerichtshofs BGH vom <num> März <num> weder als Amtsträger i S d
+<num> I Nr <num>c StGB noch als Beauftragte der gesetzlichen Krankenkassen i S d
+<num> StGB handelten Die Gesetzeslücke wurde ab <num> Juni <num> geschlossen indem
+StGB Bestechlichkeit im Gesundheitswesen und
+StGB Bestechung im Gesundheitswesen hinzugefügt sowie
+<num> und
+<num> StGB geändert wurden
+Die Erteilung der Approbation hängt seit dem <num> April <num> nicht mehr von der Staatsangehörigkeit ab Änderung des <num> BAÖ durch
+<num> des Gesetzes zur Verbesserung der Feststellung und Anerkennung im Ausland erworbener Berufsqualifikationen
+Kompetenzen und Pflichten
+Die Verordnung von rezeptpflichtigen Arzneimitteln und die meisten invasiven Maßnahmen sind in Deutschland ausnahmslos dem approbierten Arzt vorbehalten
+Hierbei ist er persönlich zur Einhaltung des anerkannten wissenschaftlichen Standes und medizinethischer Vorgaben verpflichtet
+Die Genfer Deklaration orientierte sich <num> am Eid des Hippokrates
+Weiter unterliegen Ärzte speziellen Regelungen wie dem Berufs- und Standesrecht welches auch an die Genfer Konvention anknüpft
+Insbesondere ist auch im Strafrecht die Einhaltung der ärztlichen Schweigepflicht nach
+<num> StGB festgehalten
+Akademische Grade
+In Deutschland gibt es aus historischen Gründen unterschiedliche medizinische akademische Grade
+Diese weisen im Gegensatz zum Facharzttitel nicht auf eine besondere Fachkompetenz hin sondern dienen als Beleg einer wissenschaftlichen Leistung in einem medizinischen Bereich
+Dr med - Hier wurde im Anschluss an das Staatsexamen oder das medizinische Diplom DDR eine medizinische Promotion durchgeführt
+Im Gegensatz zu anderen Studienfächern ist es in der Medizin üblich während des Studiums die Dissertation zu beginnen
+Die Promotion erfolgt erst nach dem Studienabschluss
+Einzelheiten dazu regeln die Promotionsordnungen der Universitäten
+Dr med dent - doctor medicinae dentariae Doktor der Zahnmedizin
+Dipl-Med
+- Der Grad Diplom-Mediziner aus DDR-Zeiten erworben <num> bis <num> ist noch häufig in den neuen Bundesländern anzutreffen
+Nach Ansichten verschiedener Experten ist dieser Grad vom Arbeitsaufwand des Erwerbs her mit dem Dr med der Bundesrepublik in jener Zeit zu vergleichen
+Dr med habil - Zur Habilitation in der Medizin sind ärztliche Tätigkeit und eigenständige Forschungsarbeit sowie das Durchlaufen des Habilitationsverfahrens notwendig
+Anschließend werden die akademischen Bezeichnungen Privatdozent und gegebenenfalls nach mehreren Jahren außerplanmäßiger Professor verliehen sofern regelmäßig Lehrveranstaltungen an einer Universität angeboten werden
+Für entsprechende Leistungen nicht einer Hochschule angehörender Graduierter kann die Bestellung als Honorarprofessor erfolgen
+Dr sc med - Dieser der Habilitation ebenbürtige Grad - in der DDR von <num> bis <num> verliehen - wurde im Zuge der sogenannten Promotion B erworben
+Behandlungszeit
+Laut einer Studie des Instituts für Qualität und Wirtschaftlichkeit im Gesundheitswesen haben deutsche Ärzte trotz längerer Arbeitszeiten je Patient die kürzeste Sprechzeit in Europa
+Sie liegt <num>
+niedriger als der europäische Durchschnitt
+Klinikärzte verbringen rund <num>
+ihrer Zeit für Schreibtätigkeiten und Protokolle Stand <num><num> Laut einem Projektbericht des Statistischen Bundesamts vom August <num> wenden Arzt- Psychotherapeuten- und Zahnarztpraxen jährlich durchschnittlich <num> Tage Zeit für die Erfüllung von Informationspflichten auf wobei dieser Wert den gesamten Zeitaufwand aller Praxismitarbeiter darstellt und sämtliche Informationspflichten auch die der gemeinsamen Selbstverwaltung umfasst
+Laut der deutschlandweiten MB-Online-Befragung des Marburger Bunds MB-Monitor von <num> sind <num>
+der Krankenhausärzte der Auffassung dass ihnen nicht ausreichend Zeit für die Behandlung ihrer Patienten zur Verfügung steht
+Einkommen
+Die Einkommen von Ärzten in Deutschland variieren da das Spektrum medizinischer Tätigkeiten breit gefächert ist
+Auch finden sich unter Ärzten Unterschiede bei der Arbeitszeit insbesondere zwischen klinisch tätigen bspw <num> Stdn-Schichten sowie eine hohe Anzahl an Überstunden und niedergelassenen hoher Anteil nicht-medizinischer-Tätigkeit aufgrund der Selbständigkeit
+Niedergelassene Ärzte
+Nach dem Bericht des Statistischen Bundesamtes über die Kostenstruktur bei Arztpraxen aus dem Jahr <num> lag der durchschnittliche Reinertrag Gesamteinnahmen abzüglich der Kosten je niedergelassenem Praxisinhaber im Jahr <num> bei <num> Euro
+Um einem Mangel an Landärzten entgegenzuwirken wollte die Bundesregierung <num> in einem neuen Versorgungsgesetz das Einkommen von Landärzten erhöhen Unter einer Vielzahl von Gesetzen war das GKV-Versorgungsstrukturgesetz <num> und Juni <num> das Gesetz zur Stärkung der Versorgung in der gesetzlichen Krankenversicherung
+Klinisch tätige Ärzte
+Die durchschnittlichen Gehälter klinisch tätiger Ärzte unterscheiden sich stark nach den jeweiligen Positionen
+Außendarstellung und Werbung
+Neben den strengen rechtlichen Vorgaben zur Ausübung seines Berufs ist der Arzt auch bei der Außendarstellung bzw Werbung zu seinen Leistungen und seiner Praxis umfangreichen Verordnungen und Gesetzen unterworfen
+Im Unterschied zu anderen Branchen ist Ärzten anpreisende oder vergleichende Werbung absolut verboten
+Seit dem <num>
+Deutschen Ärztetag <num> sind sachliche berufsbezogene Informationen über ihre Tätigkeit gestattet
+Hauptkriterium ist dabei das schützenswerte Interesse des mündigen Patienten
+Umstritten war ab <num> die Individuelle Gesundheitsleistung eingeführt worden
+Statistiken
+Ende <num> waren in Deutschland ca <num> Ärzte gemeldet davon <num> ohne ärztliche Tätigkeit siehe Abb Die Kassenzulassung besaßen <num> Hausärzte und <num> Fachärzte
+In den Krankenhäusern waren <num> Ärzte angestellt
+Im Jahr <num> wurden in Deutschland rund <num> berufstätige Ärzte und rund <num> Ärzte ohne ärztliche Tätigkeit gezählt
+Auf durchschnittlich <num> Einwohner kam ein berufstätiger Arzt
+DateiStruktur Aerzteschaft BRD <num>svg
+Die chronologische Entwicklung kann aus der folgenden Tabelle und der Abbildung abgelesen werden
+DateiEntwicklung Ärzteschaft BRDsvg
+In der Gesamtzahl approbierter Ärzte sind auch die nicht mehr berufstätigen und die nicht ärztlich tätigen Ärzte enthalten
+Die Bundesärztekammer und die Kassenärztliche Bundesvereinigung haben für Deutschland <num> Ärztinnen und Ärzte gezählt die <num> ärztlich tätig waren und damit <num> Ärzte mehr als im Vorjahr
+Der Anteil von Frauen stieg weiter an und erreichte <num> <num>
+nach <num>
+im Vorjahr
+Auch der Anteil älterer Ärzte stieg weiterhin an
+<num> waren <num>
+der Ärzte <num> Jahre oder älter <num> <num>
+Insgesamt waren <num> <num> Ärztinnen und Ärzte in der vertragsärztlichen Versorgung also als Niedergelassene tätig selbständig oder bei einem Vertragsarzt angestellt
+Arztbesuche Deutsche Erwachsene zwischen <num> und <num> Jahren gehen im Durchschnitt <num>-mal pro Jahr zum Arzt
+Österreich
+In Österreich ist man mit der Sponsion zunächst Doktor der gesamten Heilkunde Doctor medicinae universaeDr med univ
+Mittlerweile handelt es sich entgegen der Bezeichnung nicht um einen Doktorgrad sondern um einen Diplomgrad ähnlich dem Magister oder dem Diplomingenieur
+Vor dem Wintersemester <num><num> war das Medizinstudium in Österreich ein Doktoratsstudium welches auch Übergangsregelungen kannte
+Der eigentliche Doktorgrad der Medizin Doctor scientae medicinae bzw Dr scient med kann seitdem im Anschluss an das Diplomstudium in einem dreijährigen Doktoratsstudium erworben werden
+Selbständig als Arzt tätig werden darf man nur wenn für drei Jahre im Rahmen des Turnus verschiedene definierte Disziplinen durchlaufen wurden und die Arbeit vom jeweiligen Abteilungsvorstand positiv bewertet wurde
+Danach ist eine weiter abschließende Prüfung abzulegen
+Damit hat man das jus practicandi erworben also die Berechtigung zur selbständigen Berufsausübung als Arzt für Allgemeinmedizin
+Alternativ kann sofort nach der Sponsion die meist sechsjährige Ausbildung zu einem Facharzt erfolgen nach der wiederum eine Prüfung abzulegen ist
+Viele Fachärzte absolvieren den Turnus vor Beginn der Ausbildung ganz oder teilweise
+Es hat sich in Österreich eingebürgert die Ausbildung zum Allgemeinmediziner zuvor abzuleisten
+Viele Krankenhäuser nehmen nur Assistenzärzte mit abgeschlossener Turnusausbildung in Dienst da diese einen Nacht- oder Wochenenddienst alleine ableisten dürfen Ärzte aus anderen EU-Staaten können um Anerkennung als
+approbierte Ärzte ansuchen
+Am <num> Dezember <num> hat die EU-Kommission in ihrem Amtsblatt C<num><num> eine Änderungsmitteilung für die
+Anhang <num><num> veröffentlicht wonach ab diesem Zeitpunkt sämtliche Absolventen des österreichischen Medizinstudiums bereits mit der Promotion ihr Grunddiplom abgeschlossen haben und somit innerhalb des gesamten EU- und EWR-Raumes sowie der Schweiz und Liechtenstein eine selbständige Tätigkeit bzw Ausbildung zum Facharzt unter denselben Voraussetzungen wie einheimische Mediziner aufnehmen dürfen
+Bis dahin hatten Mediziner aus Österreich erst mit dem Abschließen der Ausbildung zum Allgemeinmediziner bzw Facharzt ein Anrecht auf automatische Anrechnung ihres Diploms in den übrigen Mitgliedsstaaten
+Der niedergelassene Arzt gehört in Österreich zu den Freien Berufen Berufe von öffentlicher Bedeutung
+Die Quote von knapp <num> Ärzten je <num> Einwohner ist mit die höchste Ärztedichte Europas und eine der höchsten weltweit
+Einwohnerquote Kassenärzte Da in Österreich eine Pflichtversicherung herrscht sind <num>
+der Bevölkerung Krankenkassenzahler
+Die Quote ist also repräsentativ
+Weiterbildung
+Ärzte müssen in Österreich pro Jahr <num> Stunden Weiterbildung absolvieren was alle <num> Jahre von der Ärztekammer kontrolliert wird
+Schweiz
+<num> arbeiteten in der Schweiz rund <num><num> <num><num> je nach Quelle Ärzte davon rund <num><num> <num>
+Frauen und <num><num> <num>
+Männer <num>
+im ambulanten und <num>
+im stationären Sektor rund <num><num> <num>
+waren Ausländer d h
+ohne Schweizer Bürgerrecht
+Qualifikation Fortbildung
+In der Schweiz ist man nach dem mit dem Staatsexamen abgeschlossenen sechsjährigen Studium zunächst eidgenössisch diplomierter Arzt und als solcher zur Arbeit als Assistenzarzt in Spitälern Krankenhäusern und Arztpraxen befugt
+Die Weiterbildung zum zur selbständigen Berufsausübung befugten Facharzt Spezialarzt dauert je nach Fach zwischen <num> praktischer Arzt und <num> Jahren nach dem Studienabschluss
+Für einen Facharzttitel muss zudem eine Facharztprüfung abgelegt werden
+Danach darf sich der Arzt Facharzt für Fachgebiet FMH nennen
+Die jeweilige Fachgesellschaft prüft ob jeder Facharzt seiner Fortbildungspflicht je nach Fachgebiet <num>-<num> Stunden pro Jahr nachkommt ref ergänzen
+Zulassung Arztpraxen
+Die Zulassung zur Berufsausübung zulasten der Krankenkassen wird vom Krankenkassenzentralverband Santésuisse erteilt ist aber bei entsprechender Qualifikation nur eine Formalität
+Die Erlaubnis zur Praxiseröffnung ist kantonal geregelt
+Aktuell besteht aber ein Praxiseröffnungs-Stopp ref ergänzen
+welcher die Berufsausübung zulasten der Krankenkassen einschränkt
+Lediglich bei Bedarfsnachweis z B
+bei einer Praxisübernahme ist eine Zulassung möglich ref ergänzen
+Arbeitszeitgesetz für Assistenz- und Oberärzte
+Seit dem <num> Januar <num> gilt nach längeren Kämpfen für die Assistenzärzte und Oberärzte an Schweizer Spitälern das landesweit gültige Arbeitszeitgesetz und damit die darin festgelegte maximale Wochenarbeitszeit von <num> Stunden Art <num> ArG Wöchentliche Höchstarbeitszeit
+Sie ist zwar bedeutend höher als die allgemein übliche Arbeitszeit in der Schweiz <num>-<num> Stunden doch ein gewisser Fortschritt - bis dahin waren Arbeitsverträge mit der Formulierung Die Arbeitszeit richtet sich nach den Bedürfnissen des Spitals üblich wodurch Arbeitszeiten von oft über <num> oder <num> Stunden pro Woche ohne finanziellen Ausgleich zu leisten waren
+Die Entgelte der Assistenzärzte lagen deswegen auf dem Niveau der Pflegenden im oberen Kader Pflegedienstleistungen
+Hierarchie der Spitäler Berufskammern
+Die Leitenden Ärzte und Chefärzte sind diesem Arbeitszeitgesetz nicht unterstellt
+Auch sind sie finanziell in der Gesamtvergütung deutlich höher gestellt
+Diese vor allem auch historisch bedingte hierarchische Trennung zeigen auch die getrennten Berufskammern der Spitalärzte VLSS und VSAO
+Hingegen ist die ältere Ärztekammer FMH allen qualifizierten Ärzten offen wie auch die fachlichen Ärzteverbände
+Die Mitgliedschaft ist freiwillig im Gegensatz zu anderen Ländern wie Deutschland oder Österreich
+Löhne Einkommen
+Referenzen FMH
+NZZ
+VSAO
+Zwar herrscht in der Schweiz immer noch <num><num> kaum Transparenz bezüglich der Einkommensverhältnisse - im allgemeinen und auch im ärztlichen Bereich
+Wobei gilt - je höher gestellt desto weniger Transparenz
+Jedoch sickern zuverlässige Angaben durch
+So bemühen sich die Spitalleitungen neuerdings um mehr Transparenz
+Wie das Zürcher Universitätsspital welches zurzeit prüft ob und in welcher Form es die Ärztelöhne künftig offenlegen soll
+Die Hälfte der Ärzte in der Schweiz arbeiten in den Spitälern
+Besonders gut bezahl sind dort Radiologen Kardiologen Gastroenterologen Intensivmediziner und Urologen
+Am unteren Ende der Lohnskala stehen Psychiater Kinderärzte und Ärzte aus dem Bereich Physikalische Medizin und Rehabilitation
+Die Normallöhne betragen p a
+Oberarzt - zwischen <num><num> und <num><num> CHF
+leitender Arzt - zwischen <num><num> und <num><num> CHF
+Chefarzt - zwischen <num><num> und <num><num> CHF
+Diese Angaben eines Beratungsunternehmens decken sich mit denjenigen des Vereins der Leitenden Spitalärzte der Schweiz VLSS - in einer seiner Umfragen deklarierten die Kaderärzte folgende durchschnittlichen Löhne
+Chefärzte - rund <num><num> CHF
+leitende Ärzte - rund <num><num> CHF
+Zu den Grundlöhnen und Boni kommen besonders bei Kaderärzten Zusatzhonorare aus Behandlungen von zusatzversicherten Patienten im stationären Bereich sowie bei Grund- und Zusatzversicherten im spitalambulanten Bereich
+Die können bei Chefärzten bis zum <num>-Fachen des Grundlohns betragen
+Einzelne Chefärzte kommen so auf Jahreslöhne von <num> Millionen Franken oder mehr sagt ein Berater der auch bemängelt dass die Chefärzte oft selbst darüber bestimmen können wie die Honorare verteilt werden
+Siehe auch
+Amtsarzt
+Ärztevereinigung
+Betriebsarzt
+Kreisarzt
+Leibarzt
+Notarzt
+Sanitätsoffizier
+Schiffsarzt
+Tierarzt
+Vertragsarzt Kassenarzt
+Zahnarzt
+Literatur
+Wolfgang U Eckart Geschichte der Medizin <num> Auflage
+Springer Berlin u a <num> ISBN <num>-<num>-<num>-<num> Relativ knappe und gut lesbare wissensch
+Darstellung des Gesamtthemas
+Wilhelm Haberling Franz Hübotter Hermann Vierordt Bearb Biographisches Lexikon der hervorragenden Ärzte aller Zeiten und Völker <num> Auflage
+Urban
+Schwarzenberg Berlin Wien <num>-<num>
+Markus Vieten Via medici-Buchreihe Berufsplaner Arzt oder was man mit einem Medizinstudium alles anfangen kann Thieme Verlag Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Vittoria Bucknall Suendoss Burwaiss Deborah MacDonald Kathy Charles Rhys Clement Mirror mirror on the ward whos the most narcissistic of them all
+Pathologic personality traits in health care
+In Canadian Medical Association Journal <num> <num> S <num>-<num>
+Ralf Bröer MedizinalgesetzgebungMedizinrecht In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte Walter de Gruyter Berlin
+New York <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin
+New York <num> ISBN <num>-<num>-<num>-<num> insbesondere S <num>-<num> Stichworte Arzt
+und S <num>-<num> Ausbildung ärztliche
+Giovanni Maio Arztbild In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte <num> S <num>-<num>
+Reinhard Platzek Verpflichtet zu heilen
+Zur Zielrichtung ärztlichen Handelns
+In Dominik Groß Monika Reininger Medizin in Geschichte Philologie und Ethnologie Festschrift für Gundolf Keil Königshausen
+Neumann <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Wolfgang Wegner Arzt In Werner E Gerabek u a Hrsg Enzyklopädie Medizingeschichte <num> S <num> f
+Weblinks
+Nationales
+Hendrik Schneider und Thorsten Ebermann
+hrr-strafrechtde
+Einzelnachweise
+Bernhard Dietrich Haage Medizinische Literatur des Deutschen Ordens im Mittelalter In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num> Heinrich Schipperges Zur Unterscheidung des physicus vom medicus bei Petrus Hispanus In III Congresso Nacional de Historia de la Medicina Valencia <num> III <num> S <num>-<num> Theodor Kirchhoff Ueberblicke über die Geschichte der deutschen Irrenpflege im Mittelalter In Allgemeine Zeitschrift für Psychiatrie und psychiatrisch-gerichtliche Medizin Band <num> <num> Heft <num> S <num>-<num> hier S <num> Johann Hermann Baas Die geschichtliche Entwicklung des ärztlichen Standes und der medicinischen Wissenschaften Berlin <num>
+In servanade Bernhard D Haage Wolfgang Wegner Medizin in der griechischen und römischen Antike In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin
+New York <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> hier S <num> Giovanni Maio Ausbildung ärztliche Neuzeit In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte De Gruyter Berlin
+New York <num> ISBN <num>-<num>-<num>-<num> S <num> f hier S <num> Ralf Bröer MedizinalgesetzgebungMedizinrecht In Werner E Gerabek Bernhard D Haage Gundolf Keil Wolfgang Wegner Hrsg Enzyklopädie Medizingeschichte Walter de Gruyter Berlin
+New York <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> hier S <num>
+In weltde <num> Februar <num> R Tyssen Health problems and the use of health services among physicians a review article with particular emphasis on Norwegian studies In
+Ind Health <num><num> Okt <num> S <num>-<num> PMID <num> Jürgen von Troschke Arztrolle In Bernhard Strauß Uwe Berger Jürgen von Troschke Elmar Brähler Lehrbuch Medizinische Psychologie und Medizinische Soziologie Hogrefe Verlag Göttingen <num> ISBN <num>-<num>-<num>-<num> S <num> T L Schwenk L Davis L A Wimsatt
+In JAMA Band <num> Nummer <num> September <num> S <num>-<num>
+doi<num>jama<num> PMID <num> Thomas Bronisch Suizidalität der Psychotherapeuten In Otto F Kernberg Birger Dulz Jochen Eckert WIR Psychotherapeuten <num> Auflage Schattauer Stuttgart <num> ISBN <num>-<num>-<num>-<num> S <num>-<num> E Schernhammer Taking their own lives - the high rate of physician suicide In
+The New England Journal of Medicine Band <num> Nummer <num> Juni <num> S <num>-<num>
+doi<num>NEJMp<num> PMID <num> K Püschel S Schalinski Zu wenig Hilfe für sich selbst - Ärzte in Suizidgefahr In Archiv für Kriminologie Band <num> Nummer <num>-<num> Sep-Okt <num> S <num>-<num>
+PMID <num> C Reimer S Trinkaus H B Jurkat Suizidalität bei Ärztinnen und Ärzten In Psychiatrische Praxis Band <num> Nummer <num> November <num> S <num>-<num>
+doi<num>s-<num>-<num> PMID <num> M Wolfersdorf Suicide and suicide prevention for female and male physicians In MMW Fortschr Med <num><num>-<num> <num> Jun <num> S <num>-<num> PMID <num> Friedbert Ficker Schutzpatrone der Ärzte und Apotheker In Bayerische Staatszeitung Band <num> Nr <num> Heimatbeilage Unser Bayern <num> Ralf Bröer MedizinalgesetzgebungMedizinrecht S <num>
+In bundesaerztekammerde <num> Oktober <num> abgerufen am <num> November <num>
+In bundesaerztekammerde abgerufen am <num> November <num>
+In bundesaerztekammerde abgerufen am <num> November <num>
+In bundesaerztekammerde <num> Dezember <num> abgerufen am <num> November <num> Zahl der Woche In FAS <num> April <num> S C<num> BGH-GS Beschl v <num> März <num> - GSSt <num><num> BeckRS <num> <num> In openjurde Änderung
+<num> Bundesärzteordnung vom <num> April <num> buzerde Pressemitteilung
+In iqwigde
+Teil I Kapitel <num> Zusammenfassung S <num>
+PDF Statistisches Bundesamt Destatis <num><num>
+In Rheinische Post <num> Mai <num> Gehälter in Kliniken nach Positionen praktischarztde
+In arzt-und-apothekenet abgerufen am <num> Februar <num> may EB Ärztestatistik - Mehr Ärzte Trend zur Anstellung In
+Deutsches Ärzteblatt Jahrgang <num> Heft <num> <num> April <num> S A<num> N Weber
+In Spiegel Online <num> September <num> wegweiseracat
+In
+Amtsblatt der Europäischen Union <num> Dezember <num> <num> hatte in Europa nur Griechenland eine höhere Ärztedichte als Österreich OECD <num> Angabe nach Ärztinnen und Ärzte Bedarf und Ausbildungsstellen <num> bis <num> Papier zu einer Studie der Gesundheit Österreich GmbH im Auftrag des Gesundheitsministeriums und Wissenschafts- und Forschungsministeriums in Kooperation mit der Österreichischen Ärztekammer Pressekonferenz <num> Juli <num> Pressezentrum Sozialministerium Abschnitt Bestandsanalyse S <num>
+bmggvat Ärzte nicht zu Reanimationsschulung verpflichtet orfat <num> Mai <num> abgerufen am <num> Mai <num>
+Web der Verbindung der Schweizer Ärztinnen und Ärzte FMH fmhch
+Web des Bundesamtes für Gesundheit BAG bagadminch Art <num> Wöchentliche Höchstarbeitszeit in SR <num> Bundesgesetz über die Arbeit in Industrie Gewerbe und Handel Arbeitsgesetz ArG in Systematischer Sammlung des Bundesrechts SR auf adminch Arbeitsgesetz Assistenz- und Oberärzte auf Web des VSAO Verband Schweizerischer Assistenz- und Oberärztinnen und -ärzte vsaoch Arbeitszeit in der Schweiz auf Web des Grenzgänger-Arbeitnehmer-Arbeitgeber-Verbands GAAV gaavde gaavch
+Web FMH fmhch
+PDF Editorial Schweizerische Ärztezeitung Nr <num> <num> auf Web FMH fmhch
+PDF Editorial Schweizerische Ärztezeitung Nr <num>-<num> <num> auf Web FMH fmhch Simon Hehli Jan Hudec
+In
+NZZ <num><num> VSAO Verband Schweizerischer Assistenz- und Oberärztinnen und -ärzte vsaoch
+VSAO Zürich auf vsao-zhch
+DateiDa Vinci Vitruve Luc Viatour <num>svg Anthropologie im <num> Jahrhundert als anthropologia gebildet aus
+und
+-logie Menschenkunde Lehre vom Menschen ist die Wissenschaft vom Menschen
+Sie wird im deutschen Sprachraum und in vielen europäischen Ländern vor allem als Naturwissenschaft verstanden
+Die naturwissenschaftliche oder Physische Anthropologie betrachtet den Menschen im Anschluss an die Evolutionstheorie von Charles Darwin als biologisches Wesen
+Dieser naturalistischen Betrachtung des Menschen die sich beispielsweise mit der Konstitution früher auch mit der Rassenlehre und Humangenetik und der Abstammung des Menschen befasst stehen verschiedene andere Ansätze gegenüber beispielsweise die philosophische Anthropologie
+Hier wird der Mensch nicht nur als Objekt sondern auch als Subjekt wissenschaftlich untersucht
+Dabei geht es unter anderem um qualitative Eigenschaften wie die Personalität die Entscheidungsfreiheit und die Möglichkeit zur Selbstbestimmung
+In der deutschen Wissenschaftspolitik ist die Anthropologie als Kleines Fach eingestuft
+Geschichte der Anthropologie
+Die Bezeichnung Anthropologie geht zurück auf den deutschen Philosophen Arzt und Theologen Magnus Hundt <num>-<num> der in einem <num> erschienenen Werk schrieb Antropologium de hominis dignitate natura et proprietatibus de elementis partibus et membris humani corporis Zu den ersten Dozenten für das Fach gehörte der Anatom und Physiologe Heinrich Palmatius Leveling der die Anthropologie <num> an der Ingolstädter Universität als Vorlesung anbot
+Ein Lehrstuhl für Allgemeine Naturgeschichte und Anthropologie wurde <num> in München eingerichtet
+Friedrich Nasse gab von <num> bis <num> in Leipzig die aus der Zeitschrift für psychische Ärzte hervorgegangene Zeitschrift für die Anthropologie heraus Auf den ersten eigenständigen Lehrstuhl Deutschlands für physische Anthropologie wurde am <num> August <num> Johannes Ranke berufen dem <num> der Schweizer Rudolf Martin <num>-<num> folgte der <num> Direktor des Anthropologischen Instituts und der Anthropologisch-Prähistorischen Staatssammlung wurde
+Martin war <num> zum Extraordinarius und <num> zum Ordinarius für Anthropologie an der Universität Zürich ernannt worden
+Naturwissenschaftlicher Ansatz
+Biologische Anthropologie
+DateiPhysical anthropologistjpg Die biologische Anthropologie ist mit ihren Teilgebieten Primatologie Evolutionstheorie Paläoanthropologie Bevölkerungsbiologie Industrieanthropologie Genetik Sportanthropologie Wachstum Auxologie Konstitution und Forensik ein Fachbereich der Humanbiologie
+Ihr Ziel ist die Beschreibung Ursachenanalyse und evolutionsbiologische Interpretation der Verschiedenheit biologischer Merkmale der Hominiden Familie der Primaten die fossile und rezente Menschen einschließt
+Ihre Methoden sind sowohl beschreibend als auch analytisch
+Institutionen im deutschsprachigen Raum gibt es an Universitäten und an Museen in Tübingen Kiel Hamburg Berlin Göttingen Jena Gießen Mainz Ulm Freiburg im Breisgau München Zürich und Wien
+Meist ist dort die Bezeichnung nur Anthropologie Zusätze wie biologisch wurden in jüngerer Zeit notwendig weil der konkurrierende US-amerikanische Begriff der
+auch hier bekannt ist
+Forensische Anthropologie
+DateiGalton at Bertillon<num>s <num>jpg
+Die forensische Anthropologie ist eine der drei gerichtlichen Wissenschaften vom Menschen neben der Rechtsmedizin und der forensischen Odontologie
+Gebiete der forensischen Anthropologie
+Identifizierung nach Bildern
+Die meisten bearbeiteten Fälle betreffen Ordnungswidrigkeiten im Verkehr also Schnellfahrer und Rotmissachter die spektakulären Fälle betreffen Bankräuber oder auch zeitgeschichtliche Personen
+Identifizierung von Skeletten und teilskelettierten Leichen auch in Massengräbern
+Altersdiagnose insbesondere bei jungen Straftätern
+Abstammungsgutachten
+Zwillingsdiagnose
+Die forensische Anthropologie dient mit den Mitteln der Anthropologie bei der Aufklärung von Verbrechen
+Forensische Anthropologen haben vor allem mit der Identifikation von Bankräubern Schnellfahrern etc zu tun aber auch häufig mit stark verwesten oder vollständig skelettierten Leichen
+Nicht selten sind sie die letzte Hoffnung zur Aufklärung eines Verbrechens
+In Deutschland gibt es eine starke institutionelle Dominanz der Rechtsmedizin aber gerade das verhindert manchmal den Zugang zu der eigenständigen Kompetenz der Anthropologie
+Geisteswissenschaftlicher Ansatz
+Sozialanthropologie
+Die Sozialanthropologie gilt als Wissenschaft der kulturellen und sozialen Vielfalt - oder allgemeiner als Wissenschaft vom Menschen in der Gesellschaft Sie analysiert die soziale Organisation des Menschen
+Im deutschen Sprachraum war der Begriff Sozialanthropologie eine seit den <num>er Jahren gebrauchte Bezeichnung für die britische
+oder die französische
+wurde dann aber zugunsten der Fachbezeichnung Ethnosoziologie aufgegeben Fachbereich der Ethnologie
+In den letzten Jahren ist jedoch eine Renaissance des Anthropologie-Begriffs zu beobachten die einer durch Transnationalisierungs- und Globalisierungsprozesse veränderten Forschungslandschaft Rechnung tragen möchte
+Kulturanthropologie
+DateiSchultuetejpg
+Die Kulturanthropologie ist eine empirisch gestützte Wissenschaft von der Kultur im Sinne von menschliche Kultur Sie entwickelte sich im <num> Jahrhundert aus der Volkskunde hat ihren Schwerpunkt im Gegensatz zu dieser aber in interkulturellen ethnologischen und soziologischen Themen und Modellen
+Unter den anthropologischen Fachrichtungen nimmt die Kulturanthropologie eine Mittelposition zwischen den biologisch und den philosophisch orientierten Richtungen ein sie ist in ihrem Themenspektrum am weitesten gefasst
+Im deutschen Sprachraum hat sich bisher keine genauere Definition des Forschungsgegenstandes durchgesetzt
+In den USA dagegen bezeichnet
+cultural anthropology
+die Ethnologie Völkerkunde
+Im Deutschen wird die ungenaue englische Bezeichnung anthropology teils falsch mit Anthropologie übersetzt während eigentlich die Ethnologie gemeint ist
+Rechtsanthropologie
+Die Rechtsanthropologie bildet eine eigenständige Unterform der Kulturanthropologie
+Sie untersucht Inhalt und Funktionsweisen rechtlicher Strukturen des Menschen unterschiedlicher kultureller Traditionen von Stämmen und Völkern siehe auch Rechtsethnologie
+Zudem bezeichnet dieser Begriff eine rechtswissenschaftliche Forschungsrichtung die sich den naturalen Grundkonstanten von Gesetzgebung und Rechtsprechung verschrieben hat
+Dabei beschäftigt sich die Rechtsanthropologie vorwiegend mit dem westlich-demokratischen Menschenbild der Verfassung das demgegenüber vom im Willen freien und eigenverantwortlich handelnden Menschen ausgeht
+Dafür wählt sie zumeist einen pragmatisch-dualen Ansatz
+Der Begriff Kultur gelegentlich auch der politischere Begriff der Zivilisation beschreibt dann die sozial-reale Welt in der der Mensch beide Sichtweisen vereint
+Philosophische Anthropologie
+Die philosophische Anthropologie ist die Disziplin der Philosophie die sich mit dem Wesen des Menschen befasst
+Die moderne philosophische Anthropologie ist eine sehr junge philosophische Fachrichtung die erst im frühen <num> Jahrhundert als Reaktion auf den Verlust von Weltorientierung entstand
+Mit Ausnahme von René Descartes der bereits Mitte des <num> Jahrhunderts in seinen Meditationen über die erste Philosophie <num> gewisse Zweifel am mittelalterlich-christlichen Weltbild hegt und Position zu Verhältnis von Körper und Seele bezieht
+Er vermittelt ein neues philosophisches Gedankengut wie Das Denken Bewusstsein
+ist es es allein kann von mir nicht abgetrennt werden ich bin ich existiere - das ist gewiss
+Demnach bin ich genau genommen ein denkendes Ding d h
+Geist bzw Seele bzw Verstand
+Historische Anthropologie
+Historische Anthropologie bezeichnet einerseits die anthropologische Forschung in der Geschichtswissenschaft andererseits eine transdisziplinäre Forschungsrichtung die die historische Veränderlichkeit von Grundphänomenen des menschlichen Daseins untersucht
+Dabei bezieht sie die Geschichtlichkeit ihrer Blickrichtungen und methodischen Herangehensweisen sowie die Geschichtlichkeit ihres Gegenstandes also das Erscheinungsbild des Menschen in den unterschiedenen Epochen aufeinander
+Theologische Anthropologie
+Die theologische Anthropologie als Teilbereich der Systematischen Theologie deutet den Menschen aus christlich-theologischer Sicht
+Dabei beschäftigt sie sich besonders mit dem Wesen des Menschen und der Bestimmung des Menschen vor Gott
+Im Unterschied dazu untersucht die Religionsethnologie als Fachgebiet der Ethnologie Völkerkunde die Religionen bei den weltweit rund <num> ethnischen Gruppen und indigenen Völkern in Abgrenzung zur Religionssoziologie vor allem bei ehemals schriftlosen Kulturen
+Industrieanthropologie
+Die Industrieanthropologie als Disziplin der Anthropologie untersucht die Gebrauchstauglichkeit
+und Benutzerfreundlichkeit von Arbeitsplätzen von Bedienelementen sowie von Produkten
+Andere Ansätze und Mischformen
+Anthropologie in den Sozialwissenschaften
+DateiDhaka street crowdsjpg
+In den Sozialwissenschaften ist die Vorstellung weit verbreitet dass der Mensch seinem Wesen nach in seinen Antrieben und Bedürfnissen unbestimmt ist weshalb erst in Vergesellschaftungsprozessen eine Orientierung und Stabilisierung des Verhaltens und Antriebslebens entstehen kann
+Dieses Menschenbild bildet die allgemeine anthropologische Voraussetzung für die Analyse von sozialen Prozessen so etwa bei Karl Marx Max Weber George Herbert Mead oder Talcott Parsons
+Darüber hinaus gibt es in den Sozialwissenschaften zwei klassische Menschenbilder die als analytische und idealtypische Modelle fungieren der
+homo oeconomicus
+der Wirtschaftswissenschaften und der
+homo sociologicus
+der Soziologie
+Eine realistische Variante des individualistischen homo oeconomicus ist das RREEMM-Modell des Menschen allerdings wird in der sozialwissenschaftlichen Theoriebildung wegen Operationalisierungsproblemen auch weiterhin überwiegend auf die einfacheren Modelle zurückgegriffen
+Ausgehend von der Einbeziehung amerikanischer Sozialforscher in den Vietnamkrieg Project Camelot wurde im Rahmen der Critical Anthropology ab <num> eine reflexive Anthropologie entwickelt Bob Scholte <num> Die Grundannahme der reflexiven Anthropologie besteht darin dass sozialwissenschaftliche Aussagen nur dann einer Kritik standhalten wenn sie die soziale und kulturelle Einbettung des Forschers und der Forschung mit bedenken reflektieren
+Gemäß dem Erkenntnisinteresse jeder Anthropologie erkenne dich selbst
+gnothi seauton
+ist auf diesem Weg eine Unterscheidung möglich zwischen einer Sozialforschung als Informationsgewinnung über andere Menschen Ausspähen vergleiche Informationelle Selbstbestimmung oder als Beitrag zur Selbsterkenntnis des Forschers und seiner Auftraggeber
+Bedeutende Ansätze zu einer reflexiven Anthropologie wurden von Michel Foucault und Pierre Bourdieu vorgelegt
+Das Konzept der reflexiven Anthropologie von Gesa Lindemann schließt sich im Gegensatz dazu an die historisch-reflexive Richtung innerhalb der deutschsprachigen philosophischen Anthropologie Helmuth Plessner an Allgemeine Aussagen der philosophischen Anthropologie werden nicht als sozialtheoretisches Fundament begriffen sondern zum Gegenstand der Beobachtung gemacht
+Bei diesem Ansatz geht es um die Bearbeitung der Frage wie in Gesellschaften der Kreis sozialer Personen begrenzt wird und welche Funktion der Anthropologie in der Moderne zukommt
+Psychologische Anthropologie
+In dem verwendeten Schema kann die Psychologie des Menschen nicht gut untergebracht werden denn die Psychologie vereint geisteswissenschaftliche biologische verhaltens- und sozialwissenschaftliche Konzepte und Methoden
+Als Wissenschaft vom Erleben und Verhalten des Menschen einschließlich der biologischen bzw neurowissenschaftlichen Grundlagen ist die Psychologie von vornherein interdisziplinär ausgerichtet
+Wegen dieses umfassenden Blicks auf den Menschen kann die empirische Psychologie in ein besonderes Spannungsverhältnis zur Philosophischen Anthropologie geraten die ebenfalls einen umfassenden theoretischen Ansatz hat jedoch die empirischen Humanwissenschaften kaum noch zu integrieren vermag
+Wichtige Themen der Psychologischen Anthropologie sind u a das Menschenbild die Persönlichkeitstheorien die Grundlagen von Motiven Emotionen in der Neurobiologie und Psychophysiologie die Beiträge der Kognitionswissenschaft Sozialpsychologie und Kulturpsychologie alle Bereiche der Angewandten Psychologie und so weiter
+Auch Psychoanalyse und Psychosomatik galten als anthropologische Disziplinen
+Pädagogische Anthropologie
+Die pädagogische Anthropologie ist der Teilbereich der Pädagogik der sich mit dem Ertrag anthropologischer Fragen den Zugangsweisen und den Ergebnissen innerhalb der Pädagogik befasst
+Grob lassen sich hier zwei Richtungen unterscheiden Die Realanthropologie widmet sich der empirischen Betrachtung der Wirklichkeit des Menschen unter dem Fokus der sich aus der Pädagogik ergibt
+Die Sinnanthropologie fragt nach dem Sinn und den Zielen menschlichen Handelns die in den pädagogischen Kontext eingearbeitet werden
+Die Sinnanthropologie weist so besondere Bezüge zur Bildungstheorie auf indem sie aus einem je spezifischen Menschenbild Bildungsansprüche ableitet
+Sie weist innerhalb der verschiedenen Anthropologien eine besondere Nähe zur philosophischen und theologischen Anthropologie auf
+Die Realanthropologie steht besonders der biologischen daneben auch der philosophischen Anthropologie nahe
+Die Einteilung setzt sich fort in der Unterscheidung zwischen integrativen und philosophischen Ansätzen
+Die integrativen Ansätze versuchen vor allem anthropologische Erkenntnisse verschiedener Teildisziplinen insbesondere der Biologie der Soziobiologie und so weiter für pädagogische Fragen nutzbar zu machen
+Vertreter dieses Ansatzes sind unter anderem Heinrich Roth und Annette Scheunpflug
+Der philosophische Ansatz hat sich in verschiedenen Richtungen ausdifferenziert
+So besteht Otto Friedrich Bollnows Ansatz darin anthropologische Fragen beispielsweise nach dem Wesen des Menschen und seiner Bestimmung für pädagogische Zusammenhänge nutzbar zu machen
+Ähnlich wie andere Autoren orientierte er sich in seinen Arbeiten aber auch an der Phänomenologie
+Er versuchte also nicht aus der Philosophie oder etwa der Biologie ein Menschenbild zu gewinnen und es pädagogisch auszuwerten sondern widmete sich dem pädagogischen Handeln und darin auftretenden Phänomenen wie Krise oder Begegnung unmittelbar um sie als Bestimmungsgrößen des Menschen zu reflektieren
+Der Mensch kommt bei diesen Untersuchungen im Hinblick auf Erziehung in drei Rollen vor als Erziehender als Zögling und als Erzieher
+In der neueren pädagogischen Anthropologie wird zum einen der integrative Ansatz fortgeführt beispielsweise auch in der Betrachtung neuerer humanmedizinischer Ergebnisse für Pädagogik
+Die philosophische Anthropologie wird heute verstärkt als historische pädagogische Anthropologie fortgesetzt indem reflektiert wird dass anthropologische Kenntnisse sowohl auf bestimmte Menschen in bestimmten Epochen bezogen als auch aus einer je spezifischen historischen Position heraus gewonnen werden und deshalb keine überzeitlich allgemeine Gültigkeit beanspruchen können
+Kybernetische Anthropologie
+Kybernetische Anthropologie bezeichnet den Versuch der begrifflichen Kopplung von Anthropologie und Kybernetik mit dem Vorhaben den Gegensatz zwischen Natur- und Geisteswissenschaften zu überwinden
+Die Cyberanthropologie ist ein neueres Fachgebiet der Ethnologie Völkerkunde oder Sozialanthropologie und untersucht transnational zusammengesetzte Online-Gemeinschaften unter Berücksichtigung kybernetischer Perspektiven
+Medizinische Anthropologie
+Die im <num> Jahrhundert aufgekommene medizinische Anthropologie beschäftigt sich mit der Wechselwirkung von Kultur und Medizin
+Anthropologie als Oberbegriff und Dachwissenschaft
+DateiCleveland Museum of Art - damaged Thinkerjpg
+Manchmal wird Anthropologie als Oberbegriff für mehrere der oben genannten Einzel- und Humanwissenschaften aufgefasst
+Insbesondere in den USA gibt es dementsprechende Bestrebungen biologische Anthropologie Kulturanthropologie Ethnolinguistik und Archäologie unter einem Dach zu vereinen sog Vier-Felder-Anthropologie
+Diese weit verbreitete Auffassung leitet sich von dem Tatbestand her dass Anthropologie -- im Gegensatz und oft in Konkurrenz zur Theologie -- Selbsterkenntnis des Menschen als Mensch ist gemäß der delphischen Maxime
+Gnothi seauton
+erkenne dich selbst
+Die Systematische Anthropologie ein <num> veröffentlichtes Werk der deutschen Ethnologen Wolfgang Rudolph und Peter Tschohl bringt anthropologisch grundlegende Erkenntnisse in einen integrierten Zusammenhang
+Mit Hilfe eines eigenen Begriffssystems wird ein gesamtanthropologisches Modell entwickelt das die Grenzen und Überschneidungen von Disziplinen wie Ethnologie Biologie Humangenetik Psychologie Soziologie Philosophie Geschichte theoretisch auflöst vergl zu diesem Ansatz Interdisziplinarität
+Ziel der Untersuchung ist eine wissenschaftliche Theorie die dasjenige abdeckt was systematisch sinnvoll zu einem Mensch genannten Untersuchungsgegenstand gerechnet werden kann und die damit nicht von einer einzelnen Fachrichtung beherrscht wird
+Die Untersuchung erschließt ausgehend von allgemeinen Bedingungen der Gesamtwirklichkeit die besonderen Bedingungen des biotischen und humanen Bereichs
+Dafür wurde eine global orientierte Auswahl an Studien ausgewertet und die daraus entwickelte interdisziplinäre Systematik theoretisch konsequent ausformuliert
+So lautet ein zentrales Untersuchungsergebnis in Kurzform Anthropologie ist zu explizieren als Theorie der Klassenexistenz Menschliche Existenz ME
+Sie hat damit den vorverständlichen Gegenstandsbereich Mensch als Existenzklasse M aufzufassen und systematisch darzulegen Gegenstand ist die menschliche Existenz als empirisch beschreibbare Tatsache
+Die Theorie transportierte einen damals fortschrittlichen humanen und weit gefassten Kulturbegriff
+Wegen technokratisch anmutender Formulierung wurde sie aber nur in der ethnologisch und soziologisch orientierten Fachwelt rezipiert
+Gerüst und Inhalt der Theorie müssten heute aktualisiert werden bieten jedoch eine Basis für Einzeluntersuchungen von beliebigen Ausschnitten des Gegenstandsbereichs Mensch
+Die praktische Relevanz und damit die Rezeption der systematischen Anthropologie von Rudolph und Tschohl waren bereits bei Erscheinen des Werks <num> äußerst begrenzt
+Kritiker wiesen darauf hin dass die positivistische Begriffssystematik völlig abgehoben von den aktuellen Diskussionen in den Sozialwissenschaften entwickelt worden war
+Ihr theoretischer Wert lag in der Einübung einer hierarchisch vernetzten Nomenklatur die zwar als Ausgangspunkt für empirische Untersuchungen hätte dienen können wenn sie allgemeine Akzeptanz gefunden hätte aber über die Wirklichkeit menschlicher Lebensverhältnisse nicht viel mehr aussagte als ein systematisch geordneter Katalog der europäischen wissenschaftlichen Terminologie in den Humanwissenschaften
+Ungeklärt blieb auch die Frage wie die Begriffssystematik von Rudolph und Tschohl in andere Sprach- und Kultursysteme hätte übertragen werden können
+Fruchtbarere Ansätze wie das Konzept der reflexiven Anthropologie vergl dazu Pierre Bourdieu und Ethnomethodologie wurden dagegen aus dem anthropologischen Lehrbetrieb verdrängt
+Die Basis-Theorie der Anthropologie
+ist ebenfalls Orientierungswissen das Zusammenhänge zwischen den Disziplinen und Schulen der Humanwissenschaften aufzeigt
+Ein Bezugsrahmen ergibt aus den vier Grundfragen der biologischen Forschung nach Nikolaas Tinbergen Verursachungen
+Ursache-Wirkungs-Beziehungen bei den Funktionsabläufen Ontogenese Anpassungswert Phylogenese
+Diese vier Aspekte sind jeweils auf verschiedenen Bezugsebenen zu berücksichtigen vgl Nicolai Hartmann beispielsweise Zelle Organ Individuum Gruppe
+Dem tabellarischen Orientierungsrahmen aus Grundfragen und Bezugsebenen lassen sich alle anthropologischen Fragestellungen siehe PDF-Übersichtstabelle Absatz A ihre Ergebnisse siehe Tabelle Absatz B und Spezialgebiete zuordnen siehe Tabelle Absatz C er ist Grundlage für eine Strukturierung der Ergebnisse
+Mit Hilfe der Basistheorie kann die anthropologische Forschung in Theorie und Empirie vorangetrieben und fundiertes sowie spekulatives Wissen besser auseinandergehalten werden betrifft z B
+den Schulenstreit in der Psychotherapie
+Siehe auch
+Medienanthropologie
+Literatur
+Allgemein
+Axel W Bauer Was ist der Mensch
+Antwortversuche der medizinischen Anthropologie
+In Fachprosaforschung - Grenzüberschreitungen <num><num> <num><num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num>
+Der blaue reiter
+Journal für Philosophie
+Themenheft Grenzpunkt Mensch
+Nr <num> <num>
+Verlag der blaue Reiter ISBN <num>-<num>-<num>-<num>-<num>
+Joachim Bauer Prinzip Menschlichkeit
+Warum wir von Natur aus kooperieren
+Hoffmann und Campe Hamburg <num> ISBN <num>-<num>-<num>-X
+Eike Bohlken Christian Thies Hrsg Handbuch Anthropologie
+Der Mensch zwischen Natur Kultur und Technik
+Metzler Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Martin Buber Ich und Du Insel Leipzig <num> Reclam Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Zeno Bucher Die Abstammung des Menschen als naturphilosophisches Problem Koenigshausen
+Neumann Würzburg <num> ISBN <num>-<num>-<num>-<num>
+Werner Fuchs u a Hrsg Lexikon zur Soziologie
+Westdeutscher Verlag Opladen <num> <num> ISBN <num>-<num>-<num>-<num>
+Hans-Georg Gadamer Paul Vogler Hrsg Neue Anthropologie Thieme Stuttgart und dtv München <num>-<num> Band <num> und <num> Biologische Anthropologie Band <num> Sozialanthropologie Band <num> Kulturanthropologie Band <num> Psychologische Anthropologie Band <num> und <num> Philosophische Anthropologie
+Gisela Grupe u a Anthropologie
+Ein einführendes Lehrbuch
+Springer Berlin <num> ISBN <num>-<num>-<num>-<num>
+Marvin Harris Menschen DTV München <num> ISBN <num>-<num>-<num>-<num>
+Winfried Henke Hartmut Rothe Menschwerdung Fischer Frankfurt <num> ISBN <num>-<num>-<num>-<num>
+Uwe Hoßfeld Geschichte der biologischen Anthropologie in Deutschland Von den Anfängen bis in die Nachkriegszeit
+Steiner Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Holger Jebens Karl-Heinz Kohl Hrsg The End of Anthropology Sean Kingston Wantage <num> ISBN <num>-<num>-<num>-<num>-<num> englisch deutsche Professoren ausführliche Fachbesprechung doi<num><num><num>
+Rainer Knußmann Hrsg Anthropologie Handbuch der vergleichenden Biologie des Menschen
+Bd <num>I <num>II
+Fischer Stuttgart <num><num> ISBN <num>-<num>-<num>-<num>
+Marc Rölli Kritik der anthropologischen Vernunft Matthes
+Seitz Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+Max Scheler Die Stellung des Menschen im Kosmos In Max Scheler Gesammelte Werke Band <num> Francke Bern <num> ISBN <num>-<num>-<num>-<num>
+Friedemann Schrenk Timothy G Bromage Henrik Kaessmann Die Frühzeit des Menschen
+Zurück zu den Wurzeln
+In Biologie in unserer Zeit Nr <num> Weinheim <num>
+S <num>-<num>
+Thomas Suddendorf Der Unterschied
+Was den Mensch zum Menschen macht
+Berlin Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>
+Ferdinand Tönnies Schriften und Rezensionen zur Anthropologie hg von Rolf Fechner Profil München und Wien <num> ISBN <num>-<num>-<num>-<num>-<num>
+Christoph Wulf Anthropologie
+Geschichte Kultur Philosophie
+Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num>
+Geschichte
+Wilhelm E Mühlmann Geschichte der Anthropologie
+<num> Auflage
+Aula Wiesbaden <num> ISBN <num>-<num>-<num>-<num>
+Christoph Wulf Hrsg Vom Menschen
+Handbuch Historische Anthropologie
+Beltz WeinheimBasel <num>
+Glenn H Penny Matti Bunzl Hrsg Worldly Provincialism
+German Anthropology in the Age of Empire
+Ann Arbor <num>
+Bernhard Rathmayr Die Frage nach den Menschen
+Eine historische Anthropologie der Anthropologien
+Barbara Budrich Opladen <num>
+Medizinische Anthropologie
+Eduard Seidler Hrsg Medizinische Anthropologie
+Beiträge für eine Theoretische Pathologie
+BerlinHeidelbergNew YorkTokyo <num>
+Veröffentlichungen aus der Forschungsstelle für Theoretische Pathologie der Heidelberger Akademie der Wissenschaften
+Vergleichende Anthropologie
+Rainer Knußmann Vergleichende Biologie des Menschen
+Lehrbuch der Anthropologie und Humangenetik
+Fischer Stuttgart <num> <num> ISBN <num>-<num>-<num>-X
+Pädagogische Anthropologie
+Herbert Becker Hrsg Anthropologie und Pädagogik Klinkhardt Bad Heilbrunn <num> ISBN <num>-<num>-<num>-<num>
+D Kamper Ch Wulf Hrsg Anthropologie nach dem Tode des Menschen Suhrkamp Frankfurt <num> ISBN <num>-<num>-<num>-<num>
+Norbert Kühne Aspekte und Probleme früher Entwicklung und Erziehung In
+Unterrichtsmaterialien Pädagogik-Psychologie
+Nr <num> Stark VerlagMediengruppe Pearson Hallbergmoos <num>-<num>
+Johanna Uher Hrsg Pädagogische Anthropologie und Evolution Erlangen <num> ISBN <num>-<num>-<num>-<num>
+Christoph Wulf Einführung in die pädagogische Anthropologie Beltz WeinheimBasel <num> ISBN <num>-<num>-<num>-<num>
+Spezielle Themen
+Manfred Engel Romantische Anthropologie
+Skizze eines Forschungsprojekts
+In Historische Anthropologie Band <num> <num> S <num>-<num>
+Michael Post Entwurf der Grundlegung der fundamentalontologischen Anthropologie und natürlichen Theologie Neuss <num> ISBN <num>-<num>-<num>-<num>-<num>
+Bernhard Verbeek Die Anthropologie der Umweltzerstörung die Evolution und der Schatten der Zukunft Primus Darmstadt <num> ISBN <num>-<num>-<num>-<num>
+Rüdiger Zymner Manfred Engel Hrsg Anthropologie der Literatur
+Poetogene Strukturen und ästhetisch-soziale Handlungsfelder
+Poetogenesis
+Studien und Texte zur empirischen Anthropologie der Literatur
+Mentis Paderborn <num> ISBN <num>-<num>-<num>-<num>
+Weblinks
+Gesellschaft für Anthropologie
+Einzelnachweise
+Axel W Bauer Bemerkungen zur Verwendung des Terminus Anthropologie in der Medizin der Neuzeit <num>-<num> Jahrhundert In Eduard Seidler Hrsg Medizinische Anthropologie <num> S <num>-<num> Seite der Arbeitsstelle Kleine Fächer zur Anthropologie abgerufen am <num> April <num> Axel W Bauer Was ist der Mensch Antwortversuche der medizinischen Anthropologie In Fachprosaforschung - Grenzüberschreitungen <num><num> <num><num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num> insbesondere S <num>-<num> hier S <num> f Christian Friedrich Nasse Hrsg Zeitschrift für die Anthropologie Cnobloch Leipzig <num>-<num> vorher Friedrich Nasse Hrsg Zeitschrift für psychische Ärzte Band <num>-<num> Leipzig <num>-<num> derselbe Hrsg Zeitschrift für psychische Ärzte mit besonderer Berücksichtigung des Magnetismus Leipzig <num>-<num> Nachruf Martin Rudolf Jahrbuch <num> Mollier - badwde Gerfried Ziegelmayer <num> Jahre Anthropologie in München In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num>-<num> Wulf Kamper Anthropologie In Heinz-Elmar Tenorth Rudulf Tippelt Hrsg BELTZ Lexikon Pädagogik Beltz WeinheimBasel <num> S <num>-<num> Axel Honneth Hans Joas Soziales Handeln und menschliche Natur Anthropologische Grundlagen der Sozialwissenschaften Campus Frankfurt am Main <num> S
+I L Horowitz The life and death of project Camelot In American Psychologist Band <num> Nr <num> <num> S <num>-<num> doi<num>h<num> Wolf Lepenies Soziologische Anthropologie Materialien München Hanser <num> S <num> Gesa Lindemann Das Soziale von seinen Grenzen her denken Velbrück Weilerswist <num> S
+Axel W Bauer Was ist der Mensch Antwortversuche der medizinischen Anthropologie <num><num> <num> S <num> f Erich Weber Pädagogische Anthropologie Donauwörth Ludwig Auer Verlag <num> Aufl <num> S <num> f Christoph Wulf Zur Einleitung Grundzüge einer historisch-pädagogischen Anthropologie In Derselbe Hrsg Einführung in die pädagogische Anthropologie Beltz Weinheim u a <num> S <num> Winfried Effelsberg Interkulturelle Konflikte in der Medizin Medizinanthropologische Überlegungen In Würzburger medizinhistorische Mitteilungen Band <num> <num> S <num>-<num> hier S <num> zitiert Axel W Bauer Was ist der Mensch Antwortversuche der medizinischen Anthropologie In Fachprosaforschung - Grenzüberschreitungen <num><num> <num><num> ISBN <num>-<num>-<num>-<num>-<num> S <num>-<num> insbesondere S <num>-<num> Übersicht <num> aus Gerhard Medicus Was uns Menschen verbindet Humanethologische Angebote zur Verständigung zwischen Leib- und Seelenwissenschaften <num> Auflage VWB Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+DateiNapoli BW <num>-<num>-<num> <num>-<num>-<num>jpg Alexander der Große
+bzw Alexander III
+von Makedonien
+<num> Juli <num> v Chr in Pella
+<num> Juni <num> v Chr in Babylon war von <num> v Chr
+bis zu seinem Tod König von Makedonien und Hegemon des Korinthischen Bundes
+Alexander dehnte die Grenzen des Reiches das sein Vater Philipp II aus dem vormals eher unbedeutenden Kleinstaat Makedonien sowie mehreren griechischen Poleis errichtet hatte durch den sogenannten Alexanderzug und die Eroberung des Achämenidenreichs bis an den indischen Subkontinent aus
+Nach seinem Einmarsch in Ägypten wurde er dort als Pharao begrüßt
+Nicht zuletzt aufgrund seiner großen militärischen Erfolge wurde das Leben Alexanders ein beliebtes Motiv in Literatur und Kunst während Alexanders Beurteilung in der modernen Forschung wie auch schon in der Antike zwiespältig ausfällt
+Mit seinem Regierungsantritt begann das Zeitalter des Hellenismus in dem sich die griechische Kultur über weite Teile der damals bekannten Welt ausbreitete
+Die kulturellen Prägungen durch die Hellenisierung überstanden den politischen Zusammenbruch des Alexanderreichs und seiner Nachfolgestaaten und wirkten noch jahrhundertelang in Rom und Byzanz fort
+Leben
+Frühe Jahre <num>-<num> v Chr
+DateiAlexander amp Bucephalus by John SteellJPG
+Alexander wurde im Jahre <num> v Chr als Sohn König Philipps II von Makedonien und der Königin Olympias geboren
+Viele Einzelheiten seiner Biografie vor allem aus der Kindheit wurden später legendenhaft ausgeschmückt oder frei erfunden
+So berichtet der Geschichtsschreiber Plutarch dass Alexander ohne Zweifel seinen Stammbaum väterlicherseits auf Herakles und Karanos den ersten König der Makedonen zurückverfolgen konnte wodurch Plutarch zugleich die Abstammung Alexanders vom Göttervater Zeus implizit hervorhebt Ebenso berichtet er dass Olympias und Philipp Träume gehabt hätten die ihnen der Seher Aristander so deutete dass ihnen die Geburt eines Löwen bevorstehe Olympias nahm für sich in Anspruch in direkter Linie von dem griechischen Heros Achilleus und Aiakos einem weiteren Sohn des Zeus abzustammen Nach einer vermutlich ebenfalls legendären Erzählung Plutarchs soll Alexander in jungen Jahren sein Pferd Bukephalos das ihn später bis nach Indien begleitete gezähmt haben nachdem es zuvor niemandem gelungen war es zu bändigen
+Alexander erkannte was den Fehlschlägen der anderen zugrunde lag Das Pferd schien den eigenen Schatten zu scheuen
+Daraufhin habe Philipp zu ihm gesagt
+Geh mein Sohn suche dir ein eigenes Königreich das deiner würdig ist
+Makedonien ist nicht groß genug für dich
+Abgesehen von den Legenden ist wenig über Alexanders Kindheit bekannt
+Makedonien war ein Land das im Norden des Kulturraums des antiken Griechenlands lag
+Es wurde von vielen Griechen als barbarisch unzivilisiert angesehen obwohl das Königsgeschlecht als griechisch anerkannt wurde
+In der Antike gab es ohnehin keinen einheitlichen Staat Griechenland sondern eine durch gemeinsame Kultur Religion und Sprache verbundene Gemeinschaft der griechischen Klein- und Stadtstaaten
+Im frühen <num> Jahrhundert v Chr wurden erstmals Makedonen zu den Olympischen Spielen zugelassen nachdem König Alexander I eine Abstammung aus dem griechischen Argos in Anspruch genommen hatte Noch heute birgt die Diskussion um die ethnische Zugehörigkeit politischen Konfliktstoff
+Aus den verfügbaren Quellen ist ersichtlich dass das Makedonische von dem nur wenige Wörter überliefert sind für die Griechen wie eine fremde Sprache klang Ob das Makedonische ein griechischer Dialekt oder eine mit dem Griechischen verwandte eigenständige Sprache war ist immer noch umstritten
+Kulturell und gesellschaftlich unterschieden sich die Makedonen recht deutlich von den Griechen keine städtische Kultur als Binnenreich kaum Kontakte zum mediterranen Kulturraum Königtum was in Griechenland nicht die Regel war
+Auf viele Griechen wird die makedonische Gesellschaft archaisch gewirkt haben Erst im <num> Jahrhundert v Chr
+verstärkte sich der griechische kulturelle Einfluss in der makedonischen Oberschicht
+DateiKarte Makedonien <num> vC-desvg
+Alexanders Vater Philipp II
+hatte das bisher eher unbedeutende Makedonien das vor ihm Streitobjekt der Adelsfamilien des Hoch- und des Tieflands gewesen war zur stärksten Militärmacht der damaligen Zeit gemacht
+Er hatte Thessalien und Thrakien erobert und alle griechischen Stadtstaaten mit Ausnahme Spartas in ein Bündnis unter seiner Führung gezwungen Korinthischer Bund
+Schon an diesen Kriegszügen war Alexander beteiligt etwa in der Schlacht von Chaironeia <num> v Chr in der die griechischen Städte unter Führung Athens unterworfen wurden
+Die makedonische Phalanx erwies sich dabei als ein wichtiges Element für den militärischen Erfolg zentral war jedoch die Rolle der Hetairenreiterei
+Alexanders spätere Erfolge gehen zweifellos zu einem bedeutenden Teil auf die Militärreformen seines Vaters zurück
+Philipp umgab sich außerdem mit sehr fähigen Offizieren wie etwa Parmenion die auch einen großen Anteil an Alexanders späteren Siegen hatten
+Philipp holte den griechischen Philosophen Aristoteles in die makedonische Hauptstadt Pella und beauftragte ihn Alexander in Philosophie Kunst und Mathematik zu unterrichten
+Der Einfluss des Aristoteles sollte wohl nicht zu hoch veranschlagt werden doch sicher war Alexander sehr gebildet seine Abschrift der
+Ilias
+hütete er wie einen Schatz und er brachte der griechischen Kultur große Bewunderung entgegen
+Das Verhältnis zwischen Vater und Sohn war keineswegs frei von Konflikten gerade in Hinsicht auf die Liebschaften des Vaters
+Philipp hatte <num> v Chr Kleopatra die Nichte seines Generals Attalos als Nebenfrau geheiratet
+Während eines Banketts soll Attalos Öl ins Feuer gegossen und gesagt haben er hoffe dass Philipp nun einen legitimen Erben erhalten würde
+Alexander sei daraufhin wutentbrannt aufgefahren und habe Attalos angeschrien
+Soll das heißen ich sei ein Bastard
+Alexander warf einen Becher nach Attalos und wollte auf ihn losgehen
+Auch Philipp erhob sich und zog sein Schwert jedoch nicht um Alexander in Schutz zu nehmen sondern um Attalos zu helfen
+Da aber Philipp bereits betrunken war stolperte er und fiel hin
+Alexander soll ihn höhnisch angeblickt haben und sich den versammelten Makedonen zugewandt haben
+Seht ihn euch an meine Herren
+Dieser Mann will euch von Europa nach Asien führen aber er scheitert schon bei dem Versuch von einem Liegebett zum nächsten zu gehen
+Plutarch Alexander <num>
+Alexander befürchtete nun offenbar von der Thronfolge ausgeschlossen zu werden
+Schließlich floh er mit seiner Mutter über Epeiros nach Illyrien
+Nach einem halben Jahr kehrte er nach Pella zurück doch seine Thronfolge blieb weiterhin unsicher
+Philipp wurde im Sommer <num> v Chr in der alten Hauptstadt Aigai auch bekannt als Vergina während der Hochzeit seiner Tochter Kleopatra mit dem König Alexander von Epeiros von dem Leibgardisten Pausanias ermordet Das Motiv des Täters scheint offensichtlich Pausanias war ein Vertrauter Philipps gewesen und war von Attalos beleidigt worden dabei fühlte er sich von Philipp ungerecht behandelt
+Es gab aber bald darauf Gerüchte wonach Alexander an der Tat beteiligt gewesen war
+Die Mutmaßungen über die Hintergründe des Mordes und über eine Verwicklung von Olympias und Alexander sind weitgehend spekulativ auch wenn eine Mitwisserschaft nicht ausgeschlossen werden kann
+Regierungsübernahme und Sicherung der Macht <num>-<num> v Chr
+DateiAlexanderTheGreat Bust Transparentpng
+Im Jahre <num> v Chr folgte der zwanzigjährige Alexander seinem Vater auf den Thron Dass es keinen nennenswerten Widerstand gab ist offenbar Antipater zu verdanken der das Heer dazu bewog Alexander als König anzuerkennen
+Schon in den ersten Tagen ließ er Mitglieder des Hofstaats exekutieren die das Gerücht gestreut hatten Alexander habe etwas mit der Ermordung seines Vaters zu tun gehabt
+Als nächstes wandte er sich seinem Erzfeind Attalos zu der sich auf der Flucht befand jedoch von seinem Schwiegervater Parmenion getötet wurde
+Sowohl Antipater als auch Parmenion standen deswegen lange in Alexanders besonderer Gunst und profitierten nicht unerheblich davon Antipater blieb während des Asienfeldzugs als Reichsverweser in Makedonien während Parmenion sich seine Unterstützung mit großem Einfluss im Heer vergelten ließ
+Noch <num> ließ sich Alexander in Korinth die Gefolgschaft der griechischen Städte versichern
+Die Völker in Thrakien und Illyrien versuchten jedoch die Situation zu nutzen und die makedonische Herrschaft abzuwerfen
+Alexander zog im Frühjahr <num> v Chr
+mit <num> Mann nach Norden ins heutige Bulgarien und Rumänien überquerte die Donau und warf die thrakische Revolte nieder Anschließend verfuhr er ebenso mit den Illyrern siehe auch Balkanfeldzug Alexanders des Großen
+Während Alexander im Norden kämpfte beschlossen die Griechen im Süden dass dies der Zeitpunkt sei sich von Makedonien zu befreien
+Ihr Wortführer war Demosthenes der die Griechen davon zu überzeugen versuchte dass Alexander in Illyrien gefallen und Makedonien herrscherlos sei
+Als erste erhoben sich die Einwohner Thebens und vertrieben die makedonischen Besatzungssoldaten aus der Stadt
+Alexander reagierte augenblicklich und marschierte direkt von seinem Illyrienfeldzug südwärts nach Theben
+Die Phalanx seines Generals Perdikkas eroberte die Stadt wo Alexander zur Bestrafung sämtliche Gebäude mit Ausnahme der Tempel und des Wohnhauses des Dichters Pindar zerstören ließ
+Sechstausend Einwohner wurden getötet die übrigen <num> wurden in die Sklaverei verkauft
+Die Stadt Theben existierte nicht mehr und sollte erst zwanzig Jahre später wieder aufgebaut werden aber nie mehr zur alten Bedeutung zurückfinden
+Abgeschreckt von Alexanders Strafgericht brachen die anderen Städte Griechenlands ihre Revolte ab und ergaben sich
+Von den Korinthern ließ sich Alexander von neuem die Gefolgschaft versichern und verschonte sie daraufhin da er sie als Verbündete in seinem Persienfeldzug brauchte
+Beginn des Persienfeldzugs <num>-<num> v Chr
+DateiMakedonischesReichjpg
+Das Perserreich war zu Alexanders Zeit die größte Territorialmacht der Erde
+Die Perserkönige hatten in den zurückliegenden Jahrhunderten die Levante Mesopotamien Ägypten und Kleinasien erobert und zwischen <num> und <num> v Chr mehrere Versuche unternommen auch Griechenland zu unterwerfen siehe Perserkriege
+Aus Sicht von Griechen wie Isokrates ebenso wie der älteren Forschung war das Reich aber um <num> v Chr geschwächt und hatte seinen Zenit überschritten
+In der neueren Forschung wird dies allerdings bestritten so war den Persern wenige Jahre vor dem Alexanderzug die Rückeroberung des zwischenzeitlich abgefallenen Ägypten gelungen
+Ob Persien für die Makedonen eine leichte Beute war ist daher umstritten
+Als sich Alexander <num> v Chr
+dem Perserreich zuwandte wurde dies von Dareios III aus dem Haus der Achämeniden beherrscht
+Schon Alexanders Vater Philipp hatte Pläne für einen Angriff auf die Perser geschmiedet angeblich um Rache für die Invasion Griechenlands rund <num> Jahre zuvor zu nehmen wobei es sich dabei eher um Propaganda handelte und machtpolitische Gründe den Ausschlag gegeben haben dürften Eine Armee unter Parmenion einem der fähigsten makedonischen Generäle war bereits über den Hellespont nach Asien gegangen wurde von den Persern aber zurückgeschlagen
+Alexander überschritt den Hellespont im Mai <num> v Chr mit einer Armee aus etwa <num> Makedonen und Griechen um in die Kämpfe einzugreifen während rund <num> Makedonen unter Antipatros Makedonien und Griechenland sichern sollten
+In der Schlacht am Granikos Mai <num> v Chr kam es zur ersten Begegnung mit den persischen Streitkräften unter der Führung eines Kriegsrates der Satrapen
+Der für die Perser kämpfende Grieche Memnon von Rhodos führte <num> griechische Söldner doch konnte er sich im Kriegsrat mit einer defensiven Taktik nicht durchsetzen
+Alexander errang auch aufgrund einer ungünstigen Aufstellung der Perser einen deutlichen Sieg
+Memnon konnte mit einem Teil der Söldner entkommen
+Dadurch war die Befreiung der Städte Ioniens möglich geworden die Alexander als Motiv für seinen Feldzug genannt hatte
+Nach dem Sieg ernannte Alexander eigene Statthalter für die bisherigen Satrapien und übernahm damit die politischen und wirtschaftlichen Strukturen der persischen Verwaltung Kleinasiens
+In Lydien zog Alexander kampflos in Sardes ein
+Er weihte den örtlichen Tempel dem Zeus und nutzte die Reichtümer der Stadt um seine Männer zu bezahlen
+Dann zog er weiter nach Ephesos
+Dort war kurz zuvor Memnon mit den Resten der Söldner vom Granikos hindurchgezogen und hatte Unruhen unter den städtischen Parteien entfacht
+Alexander ließ die alten Institutionen wiederherstellen und regelte die Befugnisse des Tempels der Artemis
+Nach einer Ruhe- und Planungspause brach der König mit dem Gros des Heeres nach Milet auf der größten Stadt an der Westküste Kleinasiens
+Der dortige Satrap kapitulierte als Einziger nicht da ihm die Ankunft einer persischen Hilfsflotte von <num> Schiffen versprochen worden war
+Da auch Alexander von dieser Flotte gehört hatte wies er Nikanor einen Bruder Parmenions an mit <num> Schiffen die Einfahrt zur Bucht von Milet zu versperren
+Anschließend gelang ihm die Einnahme der Stadt
+Belagerung von Milet
+Die Perser die immer noch unter dem Befehl Memnons standen allerdings hatten Unstimmigkeiten im persischen Oberkommando einen effektiven Widerstand erschwert sammelten sich nun in Halikarnassos der Hauptstadt Kariens und bereiteten die Stadt auf eine Belagerung vor
+Die Kämpfe waren für Alexander sehr verlustreich
+Zwischenzeitlich handelte er einen Waffenstillstand aus um die makedonischen Gefallenen zu bergen - etwas was er nie zuvor getan hatte und nie wieder tun sollte
+Als er letztlich die Mauern durchbrach entkam Memnon mit dem Großteil seiner Soldaten auf Schiffen aus der fallenden Stadt
+Belagerung von Halikarnassos
+Indem Alexander der karischen Satrapentochter Ada die Herrschaft über Halikarnassos versprach sicherte er sich das Bündnis mit dem Volk Kariens
+Manche Quellen sprechen davon dass Ada Alexander adoptierte
+Hier zeigte Alexander erstmals seine Taktik Großzügigkeit gegenüber besiegten Völkern walten zu lassen um sie nicht gegen die Makedonen aufzubringen
+Das ursprüngliche Ziel des Persienfeldzugs die Eroberung der Westküste Kleinasiens war hiermit erreicht
+Dennoch beschloss Alexander die Expedition fortzusetzen
+Entlang der Küsten Lykiens und Pamphyliens traf die makedonisch-griechische Streitmacht auf keinerlei nennenswerten Widerstand
+Eine Stadt nach der anderen ergab sich kampflos
+Alexander ernannte seinen Freund Nearchos zum Statthalter von Lykien und Pamphylien
+Im Winter <num><num> v Chr
+eroberte Alexander das anatolische Binnenland
+Er stieß vom Süden vor sein General Parmenion von Sardes im Westen
+Die beiden Armeen trafen sich in Gordion der Hauptstadt der persischen Satrapie Phrygien
+Hier soll Alexander der Große der Legende nach den Gordischen Knoten mit seinem Schwert durchschlagen haben über den ein Orakel prophezeit hatte nur derjenige der diesen Knoten löse könne die Herrschaft über Asien erringen
+Es gibt aber auch die Version dass Alexander mit der Breitseite des Schwertes auf die Wagendeichsel schlug so dass der Druck den Knoten auseinanderriss
+Die Makedonen blieben einige Zeit in Gordion um Nachschub an Männern und die Einfuhr der Ernte abzuwarten
+Während dieser Zeit starb Memnon der Befehlshaber der persischen Armee im August <num> v Chr
+an einer Krankheit
+Zu seinem Nachfolger wurde Pharnabazos ernannt und da sich die Perser bereits wieder formierten brach Alexander erneut auf
+In Gordion ließ er seinen General Antigonos als Statthalter Phrygiens zurück und übertrug ihm die Aufgabe den Norden Anatoliens zu unterwerfen und die Nachschubwege zu sichern
+Durch Kappadokien marschierte Alexanders Heer nach Kilikien
+Dort nahm er nach einem kurzen Gefecht die Hauptstadt Tarsos ein wo er bis zum Oktober blieb
+Schlacht bei Issos <num> v Chr
+DateiAlexander Sarcophagusjpg
+In Tarsos erfuhr Alexander dass Dareios III die Bedrohung endlich ernst genug nahm um selbst ein Heer aus dem persischen Kernland nach Westen zu führen
+Plutarch zufolge war dieses persische Heer <num> Mann stark - eine Angabe die sicherlich maßlos übertrieben ist Der berühmte Althistoriker Karl Julius Beloch der den Quellen immer sehr skeptisch gegenüberstand schätzte die tatsächliche Zahl der Perser auf höchstens <num> die Stärke des makedonischen Heeres dagegen auf ca <num> - <num> Mann
+Dareios gelang es Alexanders Armee im Norden zu umgehen und Issos zu besetzen wodurch er die Nachschubwege blockierte
+Auch ließ Dareios die in Issos zurückgebliebenen Verwundeten töten
+In der Schlacht bei Issos trafen die Armeen im Kampf aufeinander bis Dareios aufgrund der großen Verluste der Perser vom Schlachtfeld floh
+Die Makedonen beklagten <num> Tote und <num> Verwundete
+Unbekannt sind die persischen Verluste sie dürften aber weit höher gewesen sein
+Insgesamt hatte die persische Führung während der Schlacht mehrere Fehler begangen angefangen bei der Aufstellung - man hatte auf die Umgruppierungen Alexanders nicht reagiert
+Auch als Symbol kam der Schlacht große Bedeutung zu Dareios hatte sich als seinem Gegner nicht gewachsen gezeigt
+Zur Sicherung des Lagers der Perser sandte Alexander seinen General Parmenion nach Damaskus
+Neben dem reichen Kriegsschatz befanden sich hier auch mehrere Mitglieder der königlichen Familie Zu den Gefangenen die in die Hände der Makedonen fielen gehörten die Mutter des Dareios seine Frau Stateira ein fünfjähriger Sohn und zwei Töchter
+Alexander behandelte sie mit Respekt
+Außerdem wurde Barsine gefangen genommen die Witwe des Memnon
+Es kam zu einer Liebesaffäre zwischen Alexander und Barsine aus der später ein Sohn hervorgehen sollte der Herakles genannt wurde
+Schon bald bat Dareios Alexander um den Abschluss eines Freundschaftsvertrags und die Freilassung seiner Familie
+Alexander antwortete Dareios solle zu ihm kommen und Alexander als König von Asien anerkennen dann würde seine Bitte erfüllt andernfalls solle er sich auf den Kampf vorbereiten
+Nach der Schlacht gründete Alexander die erste Stadt in Asien die er nach sich benannte Alexandretta das heutige İskenderun
+Hier siedelte er die <num> Verwundeten der Schlacht an
+Lage nach der Schlacht von Issos
+Der Ausgang der Schlacht überraschte die antike Welt
+Die Erwartungen der Herrscher von Karthago in Italien Sizilien von Sparta bis Zypern die Kalkulationen der Handelsherren im westlichen Mittelmeerraum in Athen auf Delos und in Phönizien erfüllten sich nicht
+statt der erwarteten Siegesnachricht aus Kilikien kam die von der gänzlichen Niederlage des Großkönigs von der völligen Vernichtung des Perserheeres
+Auch die Delegationen aus Athen Sparta und Theben die im Hauptquartier des Großkönigs in Damaskus den Verlauf der Feldzüge verfolgten wurden von Alexanders Feldherrn Parmenion gefangen gesetzt
+Alexander selbst widerstand der Versuchung den Krieg durch einen Marsch nach Babylon rasch zu entscheiden doch hatte er es nicht einfach seine Befehlshaber und Gefährten von einer Defensivstrategie zu überzeugen
+Nach wie vor beherrschte die persische Flotte das östliche Mittelmeer - sie verfügte zwar über keine Häfen mehr in Kleinasien jedoch nach wie vor in Phönizien
+Durch die Münzgeldtribute hier waren die finanziellen Mittel der Perser noch wenig eingeschränkt und auch Ägypten stand ihnen noch als logistische und militärische Basis zur Verfügung
+Die kommenden Winterstürme ließen zwar keine Flottenunternehmungen mehr erwarten und damit auch keine Gefahr einer raschen Erhebung der Griechen gegen Makedonien - insbesondere des Spartanerkönigs Agis IV - doch kam es nun auch auf das Verhalten der phönizischen Geschwader an die einen Großteil der persischen Flotte stellten
+Zwar verblieben sie in dieser Jahreszeit noch in der Fremde doch nahm Alexander an dass er diese Kontingente durch eine sofortige Besetzung ihrer Heimatstädte zumindest neutralisieren könne
+Auch die kyprischen Könige glaubten für ihre Insel fürchten zu müssen sobald die phönikische Küste in Alexanders Gewalt war Nach einer Besetzung Phöniziens und Ägyptens könne dann ein Feldzug nach Asien von einer gesicherten Basis aus geführt werden obwohl die Perser natürlich auch Zeit für neue Rüstungen gewannen
+Die Versammlung stimmte Alexanders Plan zu
+Die Schlacht von Issos hatte noch keine grundsätzliche Entscheidung gebracht Entgegen den Erwartungen wurde das makedonische Heer nicht vernichtet und Alexander besaß mit der persischen Kriegskasse in Damaskus die Mittel zur Fortführung des Feldzuges
+Eine Entscheidung des Krieges war dadurch nicht bewirkt worden
+Eingezogen wurden in Damaskus <num> Talente in Münzgeld und <num> Pfund Silber die ausreichten alle Soldschulden der Armee und Sold für etwa sechs weitere Monate zu bezahlen
+Belagerung von Tyros und das zweite Angebot des Dareios <num> v Chr
+Während die Städte in der nördlichen Hälfte Phöniziens - Marathos Byblos Arados Tripolis und Sidon - sich dem Makedonen bereitwillig ergaben war die dominierende Handelsmetropole Tyros allenfalls zu einem Vergleich bereit
+Sie baute dabei auf ihre Insellage knapp vor der Küste auf ihre vor Ort verfügbare eigene Flotte und die Unterstützung ihrer mächtigen Tochterstadt Karthago
+Nachdem Alexander der Zutritt zur Stadt verwehrt worden war - sein Prüfstein war das Verlangen nach einem Opfer im Tempel des Stadtgottes Melkart des tyrischen Herakles - brach der König die Verhandlungen ab
+Er beschloss Tyros um jeden Preis einzunehmen denn er plante schon den Vorstoß nach Ägypten und wollte eine feindliche Stadt die sowohl mit den Persern als auch mit rebellischen Kräften in Griechenland kooperieren würde nicht unbezwungen in seinem Rücken lassen
+Eine von Arrian überlieferte angebliche Rede Alexanders vor seinen Offizieren in der die strategischen Überlegungen erläutert werden ist allerdings eine literarische Fiktion die auf der Kenntnis des späteren Verlaufs des Feldzugs beruht Vor dem Beginn der Belagerung bot Alexander den Tyrern Schonung an falls sie kapitulierten
+Sie töteten jedoch seine Unterhändler und warfen die Leichen von den Stadtmauern
+Damit war der Weg zu einer Einigung endgültig versperrt
+Ohne Flotte blieb nur die Möglichkeit eines Dammbaues durch das zumeist seichte Gewässer das die vorgelagerte Inselstadt von der Küste trennte und der Versuch mit Belagerungsmaschinen Teile der Mauern zu zerstören
+Die Finanzierung dieser aufwendigen Methode die eine entwickelte Technik und die dafür entsprechenden Materialien und Fachkräfte erforderte konnte Alexander durch die Beute aus dem persischen Hauptquartier in Damaskus bewerkstelligen
+Ein erster Dammbau wurde von den Tyrern erfolgreich bekämpft es gelang ihnen bei stürmischem Wetter mit einem Brander die zwei Belagerungstürme an der Spitze des Dammes zu entzünden und durch Begleitschiffe mit Geschützen jeden Löschversuch zu vereiteln
+Der Sturm riss zudem den vorderen Teil des Dammes weg
+Der Vorfall löste im makedonischen Heer Entmutigung aus zumal wieder Gesandte des Dareios eintrafen und ein neues Friedensangebot des Großkönigs überbrachten das Alexander den Besitz des Landes diesseits des Euphrat <num> Talente Lösegeld für seine gefangene Gemahlin und die Hand seiner Tochter anbot
+In diese Zeit fiel auch die - vermutlich von Kallisthenes übermittelte - Reaktion des Befehlshabers Parmenion Wäre er Alexander so würde er akzeptieren
+Alexander entgegnete das würde er auch tun wenn er Parmenion wäre
+Alexander ließ Dareios mitteilen er Alexander werde sich nehmen was er wolle wenn Dareios etwas von ihm erbitten wolle solle er zu ihm kommen
+Der Damm wurde in größerer Breite wiederhergestellt und neue Türme gebaut In der Zwischenzeit - nach den Winterstürmen - trafen auch die phönizischen Flottenkontingente und die Geschwader der Könige von Zypern in ihren Heimathäfen ein und standen nun Alexander zur Verfügung insgesamt <num> Schiffe darunter auch Vier- und Fünfruderer
+Diese Bundesgenossenschaft lag auch in der Feindschaft der kleineren Städte Phöniziens gegen Tyros begründet Die Metropole hatte zwanzig Jahre zuvor zwar einen Aufstand unter Führung von Sidon gegen die Perser befürwortet und Hilfe zugesagt dann jedoch den Verlauf der Auseinandersetzungen abgewartet und war von den Persern für diese Haltung belohnt worden
+Nach der Niederschlagung der Erhebung und der Zerstörung von Sidon errang Tyros die Vorherrschaft unter den phönizischen Handelsstädten
+Während die neu gewonnene Flotte ausgerüstet wurde unternahm Alexander eine Expedition durch das küstennahe Gebirge des Antilibanon um die Festungen von Gebirgsstämmen zu bezwingen den Nachschub Holz für den Maschinenbau und die Verbindung nach Damaskus zu sichern
+Die Karthager konnten den Tyrern nicht helfen da sie sich im Krieg mit Syrakus befanden Nach weiteren wechselvollen Kämpfen um die Stadtmauern und zur See die die Tyrer immer mehr Schiffe kosteten war die Zeit zum Sturmangriff reif
+Alexander beschloss einen kombinierten Land- und Seeangriff
+Auf der durch den Damm erreichbaren Seite gelang es Breschen in die Mauern zu schlagen und ein Landeunternehmen durchzuführen die phönizischen Schiffe sprengten die Sperrketten im Südhafen und bohrten die dort liegenden Schiffe in den Grund die zyprische Flotte verfuhr ebenso im Nordhafen - dort gelang es den Truppen zusätzlich in die Stadt einzudringen
+Die überlieferte Zahl von <num> Gefallenen der Stadt soll sich auf die gesamte Belagerungszeit beziehen Ob die anschließende angebliche Kreuzigung von <num> Kämpfern den Tatsachen entspricht ist umstritten
+Im Vorfeld des letzten Angriffes ließ Alexander Schiffe der Karthager und seiner verbündeten Phönizier zur Evakuierung der Bevölkerung passieren In Heiligtümer oder Tempel Geflüchtete wurden verschont
+Zahlreiche Einwohner - die überlieferte Zahl von <num> gilt allerdings als stark übertrieben - wurden in die Sklaverei verkauft Das war in der Antike eine gängige Praxis um die Kriegskassen aufzufüllen
+Alexander soll allerdings sehr selten zu diesem Mittel gegriffen haben da er die Bevölkerung für sich gewinnen wollte denn er konnte sich eine ständige Bedrohung durch Aufständische in seinem kaum durchgängig besetzbaren Hinterland nicht leisten
+Tyros wurde wieder aufgebaut und neu besiedelt um unter makedonischer Hoheit die beherrschende Position in Phönizien zu sichern
+Die Nachricht von diesem mit modernster Kriegstechnik errungenen Sieg - die Belagerungstürme sollen eine Höhe von <num> Metern erreicht haben - machte in der antiken Welt weit über die betroffene Region hinaus einen starken Eindruck
+Eroberung von Gaza
+Alexander der während der Belagerung auch die Verwaltung und Logistik in den neu gewonnenen Gebieten ordnete brach etwa Anfang September <num> von Tyros auf Die Städte und Stämme im südlichen Syrien ergaben sich bis auf die Hafenstadt Gaza
+Die Stadt war seit Jahrhunderten der Hauptumschlagplatz des Gewürzhandels
+Mit einer Eroberung der Stadt konnte Alexander einen der lukrativsten Handelsbereiche zwischen Ost und West unter seine Kontrolle bringen doch standen den Makedonen damit nicht nur Perser sondern auch arabische Söldnertruppen gegenüber
+Mit entsprechender Härte wurde der Kampf geführt
+DateiOlympias<num>JPG
+Einen unmittelbaren Gewinn konnte sich Alexander von einer Eroberung nicht versprechen denn die Gewürzhandelsgeschäfte des Jahres waren abgeschlossen da die Route nur einmal im Jahr befahren wurde Wetterverhältnisse und Orientierungsschwächen beschränkten die Aktivitäten mediterraner Seefahrt auf das halbe Jahr zwischen Mai und Oktober in dem das Wetter in der Regel verläßlich gut war
+Faktisch lag der Zeitpunkt Mitte August Hesiod <num> v Chr denn es stand auch noch die Rückreise an Organisiert war diese Fahrt bis in die Spätantike als riesiges Kauffahrtgeschwader zuerst entlang der östlichen Küsten - vor allem Kornfrachter Sklaven- und Baumaterial-Transporten sowie Postschiffen und anderen die dann übers Meer von Kriegsschiffen begleitet wurden Durch die Belagerung von Tyros waren die Handelsunternehmen <num> v Chr schon stark beeinträchtigt worden
+Alexander nahm sofort den Hafen von Gaza zum Antransport der zerlegten Belagerungsmaschinen in Beschlag
+Die Stadt selbst lag nahe dem Meer auf einem flachen Hügel Gaza war auch der letzte freie Ankerplatz für die persische Flotte in Syrien und somit auch an der kompletten östlichen Mittelmeerküste
+Die Flotte war mittlerweile in Auflösung begriffen da die griechischen Kontingente nun ebenfalls - klimabedingt - im Herbst in ihre Heimathäfen zurück segelten
+Mit erneut hohem Aufwand schütteten die Makedonen einen Damm zur Südseite der Stadt auf der danach mit weiteren konzentrisch angelegten Dämmen ergänzt wurde
+Die Kämpfe - vor allem mit den arabischen Söldnern - wurden als wild bezeichnet Alexander wurde zweimal verwundet durch einen Messerstich und - gefährlicher - mit einem Katapultpfeil der durch den Panzer in die Schulter drang
+Nach zwei Monaten und dem vierten Ansturm fiel die Stadt um die <num> Verteidiger sollen umgekommen sein Frauen und Kinder wurden als Sklaven verkauft
+Dass der Kommandant Batis wie Hektor durch Achilles vor Troja um die Stadt geschleift worden sein soll wird angezweifelt Alexander zog die Bevölkerung der umliegenden philistäischen und arabischen Ortschaften in die Stadt eine dauernde Besatzung machte sie zu einem Waffenplatz der für Syrien und für Ägypten gleich wichtig war
+Es wird davon ausgegangen dass der Gewürztransport nach Gaza danach in der Felsenstadt Petra - der davor liegenden Station der Weihrauchstraße - angehalten wurde
+Petra war zentrales Weihrauchlager da die Stadt in einem Talkessel gewaltige Lagerhallen Höhlen besaß
+In Petra saßen die Ökonomen die kontrollierten was sie zu welchem Preis an die mediterranen Küsten bringen wollten Für <num> war das Geschäft allerdings schon gelaufen
+Den jahreszeitlichen Bedingungen zufolge kehrten im Herbst auch die Kauffahrtsflotten zurück und trafen in Phönizien überall in Häfen ein die von den Makedonen kontrolliert wurden
+Die Auflösung der persischen Kriegsflotte im Herbst war ebenfalls eine Routineangelegenheit doch war es allen Beteiligten klar dass die Kontingente auf Grund der makedonischen Besetzung sämtlicher Festlandshäfen im östlichen Mittelmeer im nächsten Frühjahr nicht wieder unter persischem Kommando zusammengeführt werden würden
+Seekrieg <num> v Chr
+Während Alexander mit dem Heer <num> v Chr den größten Teil des Jahres mit Belagerungen zur Vervollständigung seiner Blockade der persischen Seemacht verbrachte - und dabei die phönizischen Hafenstädte und ihren Handel unter seine Kontrolle nahm - war die Flotte der Perser durch den bereits im Frühjahr erfolgten Abzug der phönikischen und kyprischen Kontingente geschwächt und verhielt sich defensiv
+Die Admirale Pharnabazos und Autophradates versuchten - meist mit Hilfe begünstigter oder eingesetzter Machthaber - die wichtigsten Inseln unter ihrer Kontrolle zu behalten
+In Griechenland das Alexanders Statthalter Antipater bis auf die Peloponnes fest im Griff hatte rührte sich kein Widerstand
+Lediglich der Spartanerkönig Agis III setzte noch auf die persische Karte und hatte Kreta durch seinen Bruder und Mitregenten Agesilaos besetzen lassen
+Doch schon im Vorjahr noch während des Aufenthalts in Gordion <num> v Chr hatte Alexander Amphoteros den Bruder des Orestiden Krateros beauftragt in Übereinstimmung mit den Abmachungen des Bündnisses eine neue griechische Flotte auszurüsten Dank der erbeuteten Schätze aus Sardis gelangen die Anfänge dazu und nach dem Sieg bei Issos und dem darauf folgenden Winter der keine Flottenunternehmungen zuließ stand Alexanders neue Flotte im Frühjahr <num> v Chr bereit
+Nun konnten die makedonischen Nauarchen Hegelochos und Amphoteros ihrerseits systematisch die Inseln besetzen - von Tenedos und Chios wo der persische Admiral Pharnabazos mit der Besatzung von <num> Trieren in Gefangenschaft geriet - bis nach Kos und schließlich Lesbos
+Dort handelte der athenische Söldnerführer Chares mit zweitausend Mann freien Abzug aus und begab sich nach Tainaron dem Hafen und Söldnermarkt südlich von Sparta
+Amphoteros unterwarf zuletzt noch die kretischen Stützpunkte während Hegelochos bereits nach Ägypten steuerte um selbst die Meldung vom Ausgang des Kampfes gegen die persische Seemacht zu überbringen zugleich die Gefangenen abzuliefern
+So war mit dem Ausgang des Jahres <num> der letzte Rest einer persischen Seemacht die das makedonische Heer im Rücken zu gefährden und dessen Bewegungen zu hindern vermocht hätte vernichtet
+Besetzung Ägyptens <num>-<num> v Chr
+Nach der Eroberung von Gaza machte sich Alexander mit einem Teil seines Heeres auf den Weg nach Ägypten
+Ägypten war in den vorangegangenen sieben Jahrzehnten mehrfach von den Persern angegriffen und besetzt worden und ging ihnen regelmäßig durch Aufstände wieder verloren
+Erst seit drei Jahren war es wieder in der Hand des Großkönigs doch Ägypten war von Truppen entblößt weil der Satrap Sabakes mit einem großen Aufgebot nach Issos gekommen und selbst dort gefallen war
+Mazakes vom Großkönig
+zum neuen Satrapen ernannt konnte nicht an Widerstand denken Er übergab unter Auslieferung von <num> Talenten für freies Geleit die Grenzfestung Pelusion
+Ein Teil der makedonischen Flotte segelte nun den Nil aufwärts zur Hauptstadt Memphis während sich Alexander mit den Truppen auf dem Landmarsch über Heliopolis dorthin begab
+In Memphis opferte Alexander wie er auch den Göttern anderer eroberter Länder Opfer darbrachte dem ägyptischen Gott Apis anstatt ihn zu verachten wie der persische Großkönig Artaxerxes III der den heiligen Stier des Gottes töten ließ
+Als Gegengabe scheint Alexander als Pharao des Oberen und Unteren Ägyptens gekrönt worden zu sein wenngleich diese Ehrung nur in dem frei erfundenen
+erwähnt wird Die Krönung kann nicht auf einen Monat genau datiert werden bestätigt wird sie aber durch die Pharaonentitel die ihm in ägyptischen Tempelinschriften zugeschrieben sind Der Verlag veröffentlichte dazu das Foto eines Reliefs im Amun-Tempel von Luxor
+Alexander zog danach am westlichen Nil entlang nordwärts und gründete im Januar <num> v Chr an der Mittelmeerküste Alexandria die bedeutendste all seiner Stadtgründungen
+Im März zog Alexander von Paraetonium
+aus <num> km südwestwärts durch die Wüste zum Orakel von Siwa einem dem Gott Amun geweihten Tempel Was er dort an Botschaften empfing ist unbekannt
+Antike Quellen berichten Alexander habe dort erfahren dass er der Sohn des Zeus sei so soll ihn der oberste Priester als Sohn des Zeus begrüßt haben
+Jedoch hatte Alexander sich schon vorher als Sohn des Zeus bezeichnet
+Von Siwa kehrte Alexander nach Memphis zurück verweilte dort einige Wochen und führte seine Truppen dann zurück nach Palästina
+Eroberung des persischen Kernlands <num>-<num> v Chr
+Im Mai <num> v Chr kehrte Alexander nach Tyros zurück
+Er befahl hier den Wiederaufbau der Stadt die er mit befreundeten Phöniziern wieder besiedeln ließ
+<num> zusätzliche Soldaten waren im Frühling aus Makedonien entsandt worden und bei Tyros trafen sie im Juli mit Alexander zusammen
+Seine Armee bestand nun aus <num> Fußsoldaten und <num> Reitern
+Alexander zog ostwärts durch Syrien und überquerte den Euphrat
+Sein Plan mag gewesen sein von hier aus südwärts nach Babylon zu ziehen doch eine Armee unter dem persischen Satrapen Mazaeus verstellte den Weg
+Alexander vermied die Schlacht die ihn viele Männer gekostet hätte und zog stattdessen nordwärts
+Derweil zog Dareios selbst eine neue große Streitmacht in Assyrien zusammen und dieses Heer war es das Alexander treffen wollte
+Im September <num> v Chr überquerte das Heer den Tigris
+Am <num> September unmittelbar vor der Schlacht kam es zu einer Mondfinsternis die die Perser verunsicherte und von ihnen als schlechtes Omen gedeutet wurde
+Das Heer Alexanders lagerte <num> km von der persischen Armee entfernt bei einem Dorf namens Gaugamela weshalb die folgende Schlacht als Schlacht von Gaugamela bekannt wurde
+Am <num> Oktober kam es zum Kampf
+Wenngleich das Heer des Dareios auch diesmal den Truppen Alexanders zahlenmäßig weit überlegen war siegte abermals Alexander
+Er vermochte aber nicht Dareios selbst zu töten oder gefangen zu nehmen
+Obwohl dieser damit erneut entkommen war war seine Armee praktisch vernichtet
+Alexander dagegen hatte nun die Herrschaft über die Satrapie Babylonien gewonnen und konnte ungehindert ins reiche Babylon einziehen
+Mazaeus der sich nach der Schlacht von Gaugamela nach Babylon zurückgezogen hatte übergab die Stadt an Alexander der sie durch das Ischtar-Tor betrat und sich zum König von Asien ausrufen ließ
+Während die Griechen die Völker Asiens zuvor als Barbaren verachtet hatten sah Alexander sie mit anderen Augen
+Fasziniert von der Pracht Babylons befahl er die Schonung aller Bauwerke
+Alexander verzieh dem persischen Satrapen Mazaeus und ernannte ihn zu seinem Statthalter in Babylon
+Nach fünfwöchigem Aufenthalt zog Alexander weiter ostwärts um die großen persischen Städte im Kernland anzugreifen
+Susa ergab sich kampflos
+Im Januar <num> v Chr erreichten die Makedonen die persische Hauptstadt Persepolis
+Zahlreiche Einwohner begingen vor seinem Einzug Selbstmord oder flohen
+Die ältere Meinung Alexander habe die Stadt plündern und den Königspalast niederbrennen lassen ist inzwischen von der jüngeren Quellenkritik relativiert worden
+Archäologische Funde bestätigen dass lediglich die Gebäude die Xerxes I errichtet hatte brannten was die Darstellung Arrians wahrscheinlicher macht
+Verfolgung und Tod des Dareios <num> v Chr
+DateiDarius IIIjpg
+Zwar war Persien nun in Alexanders Hand doch König Dareios III war noch immer am Leben und auf der Flucht
+Da Alexander mitgeteilt worden war dass Dareios sich in Medien aufhalte folgte er seiner Spur im Juni nach Nordwesten nach Ekbatana
+Doch auch Dareios Anhängerschaft hatte jetzt keine Hoffnung mehr Persien zurückzugewinnen
+Die Vollkommenheit der Niederlage ließ nur die Möglichkeit zu sich zu ergeben oder zeitlebens zusammen mit Dareios zu fliehen
+Bisthanes ein Mitglied der Königsfamilie entschied sich in Ekbatana zu bleiben wo er Alexander empfing und ihm die Stadt übergab
+Alexander zeigte sich wiederum großzügig und ernannte einen Perser zu seinem Statthalter in Medien
+In Ekbatana entließ Alexander auch die griechischen Verbündeten und die thessalischen Reiter was als Zeichen zu verstehen war dass der vom Korinthischen Bund beschlossene Rachefeldzug damit beendet war
+Teile des Bundesheeres wurden jedoch von Alexander als Söldner angeworben
+Dareios setzte inzwischen seine Flucht fort
+Er hoffte Zuflucht in Baktrien zu erhalten wo ein Verwandter namens Bessos Satrap war
+Bessos aber setzte Dareios gefangen und schickte einen Unterhändler zu Alexander
+Er bot ihm an Dareios an die Makedonen zu übergeben wenn im Gegenzug Baktrien frei bliebe
+Alexander ging nicht auf die Verhandlungen ein und setzte die Verfolgung fort
+Bessos tötete seine Geisel im Juli und floh seinerseits
+Die Leiche des Dareios wurde von Alexander nach Persepolis gebracht und dort feierlich beigesetzt
+Verfolgung des Bessos <num>-<num> v Chr
+In der Zwischenzeit hatte Alexander erkannt dass er zur Sicherung der Herrschaft über das Perserreich die Unterstützung der persischen Adligen brauchte
+Er nutzte Dareios Ermordung daher die Perser zu einem Rachezug gegen Bessos aufzurufen der sich nun den Namen Artaxerxes gegeben hatte und sich Großkönig von Persien nannte
+Die Soldaten waren wenig begeistert davon dass sie den Tod ihres Erzfeindes vergelten und zudem gemeinsam mit Persern kämpfen sollten
+Außerdem war ihnen das Land im Nordosten vollkommen unbekannt
+Die dortigen Provinzen Baktrien und Sogdien lagen in etwa auf den Territorien der heutigen Staaten Afghanistan Usbekistan und Turkmenistan
+Im August <num> v Chr brach Alexander zu einem neuen Feldzug auf und eroberte zunächst Hyrkanien die persische Satrapie an der Südküste des Kaspischen Meeres
+Unter jenen die mit Alexander kämpften war Oxyartes ein Bruder des Dareios
+Statt von Hyrkanien den direkten Weg nach Baktrien zu wählen ging Alexander über Aria dessen Satrap Satibarzanes an Dareios Gefangennahme beteiligt gewesen war
+Alexander eroberte die Hauptstadt Artacoana verkaufte die Einwohner in die Sklaverei und benannte die Stadt in Alexandreia um der heutige Name der Stadt ist Herat
+Auf seinem weiteren Weg kam es zu einem Zwischenfall als Philotas der Sohn des Parmenion beschuldigt wurde einen Anschlag auf Alexanders Leben unternommen zu haben
+Ob dieser Versuch wirklich unternommen worden war ist unklar
+Vielleicht diente die Affäre Alexander bloß als Vorwand sich Parmenions zu entledigen der zum Wortführer seiner Kritiker avanciert war
+Sie missbilligten Alexanders Neigung die Perser zu ehren und ihre Gewänder zu tragen und sahen dies als Anbiederung an ein barbarisches Volk an
+Philotas wurde an Ort und Stelle mit einem Speer getötet
+Ein Kurier wurde dann zu den Adjutanten des in Ekbatana gebliebenen Parmenion gesandt
+Sie töteten Parmenion auf Alexanders Befehl
+Nach beschwerlicher Reise entlang des Flusses Tarnak erreichte Alexander im April <num> das Zentrum des heutigen Afghanistan und gründete Alexandria am Hindukusch heute Chârikâr
+Von hier aus wollte Alexander das Gebirge überschreiten und auf diesem Wege in Baktrien einfallen
+Einer Legende zufolge fand man hier den Berg an den der Titan Prometheus gekettet worden war
+Als die Nachricht nach Baktrien gelangte dass Alexander dabei war den Hindukusch zu übersteigen fürchteten die Einwohner von Baktra heute Balch die Bestrafung ihrer Stadt und vertrieben Bessos
+Die beschwerliche Überquerung des Gebirges hatte die Soldaten indessen gezwungen manche ihrer Lasttiere zu schlachten
+Als sie erschöpft in Baktrien ankamen wurde das Land ihnen kampflos übergeben
+Alexander ernannte seinen persischen Vertrauten Artabazos den Vater der Barsine zum Satrapen
+Alexander hielt sich nicht lange in Baktra auf und folgte weiterhin Bessos der nordwärts zum Oxus Amudarja geflohen war
+Der <num> km lange Marsch durch wasserlose Wüste wurde vielen zum Verhängnis
+Bessos hatte inzwischen alle Schiffe zerstören lassen mit denen man den Amudarja hätte überqueren können
+Die Makedonen brauchten fünf Tage um genügend Flöße für die Überquerung des Flusses anzufertigen
+Dann setzten sie in die Satrapie Sogdien im heutigen Turkmenistan über
+Die Begleiter des Bessos wollten nun nicht länger fliehen
+Sie meuterten gegen ihn nahmen ihn gefangen und händigten ihn an Alexander aus
+Dieser zeigte sich gnadenlos und ließ Bessos die Nase und die Ohren abschneiden
+Anschließend übergab Alexander den Verstümmelten an Dareios Bruder Oxyartes damit er ihn nach Medien an den Ort brächte wo Dareios ermordet worden war
+Dort wurde Bessos gekreuzigt
+Alexander ging indessen weiter nach Norden und erreichte die sogdische Hauptstadt Marakanda heute Samarkand
+Alle Satrapien des Perserreichs unterstanden nun Alexander und niemand außer ihm selbst erhob mehr Anspruch auf den Königstitel über Persien
+Alexander in Sogdien <num>-<num> v Chr
+DateiAlexandreLouvrejpg
+Nach der Einnahme von Marakanda zog Alexander noch weiter bis zum Syrdarja und gründete dort im Mai <num> v Chr die Stadt Alexandria Eschatê das entfernteste Alexandria das heutige Chudschand in Tadschikistan
+Etwa gleichzeitig erhob sich die Bevölkerung Sogdiens gegen ihn
+Anführer der Rebellion die Alexander erhebliche Schwierigkeiten bereitete war ein Mann namens Spitamenes der zuvor Bessos verraten und an Alexander übergeben hatte
+Die Sogdier die Alexander zunächst begrüßt hatten nun jedoch sahen dass eine Fremdherrschaft durch eine andere ersetzt wurde machten die makedonischen Besatzungen nieder
+Alexander zog Truppen zusammen und marschierte von einer rebellischen Stadt zur anderen belagerte sieben von ihnen und tötete anschließend sämtliche männlichen Einwohner wohl um ein abschreckendes Exempel zu statuieren
+In der Zwischenzeit eroberte Spitamenes Marakanda zurück doch Alexander gewann die Stadt erneut wobei Spitamenes allerdings entkam
+Da das Heer geschwächt und stark reduziert war musste Alexander von der Verfolgung ablassen
+Im Zorn brannte er Dörfer und Felder jener Bauern nieder die die sogdische Revolte unterstützt hatten
+Für den Winter <num><num> v Chr zog er sich nach Baktra zurück und erwartete neue Truppen die bald darauf aus dem Westen eintrafen und bitter benötigt wurden
+Im Frühling <num> v Chr kehrte Alexander nach Sogdien zurück
+Den Quellen zufolge gründete er am Amudarja ein weiteres Alexandria das vielleicht mit der heutigen Siedlung Ai Khanoum identisch ist
+Der Kampf gegen die sogdischen Rebellen dauerte das ganze Jahr
+Erst Monate später zeigte sich dass die Anhänger des Spitamenes ihren Befehlshaber zu verlassen begannen
+Das Haupt des Rebellenführers wurde Alexander schließlich im Dezember <num> v Chr überbracht
+Während der Sieg gefeiert wurde kam es zu einem Streit zwischen Alexander und seinem General Kleitos
+Kleitos der altmakedonisch gesinnt war sollte demnächst nach Baktrien aufbrechen
+Grund war vermutlich sein Alter aber Kleitos sah dies als Herabsetzung an
+Es ist auch möglich dass Kleitos bei dieser Gelegenheit Kritik an der Proskynese einem von Alexander übernommenen persischen Hofritual geübt hat
+Die Streitenden waren zu diesem Zeitpunkt betrunken und Kleitos hatte Alexanders Vater Philipp zu loben begonnen
+Hierdurch fühlte sich Alexander so beleidigt dass es zum Streit kam in dessen Verlauf Alexander vergeblich nach seinen Waffen suchte da sie vorsichtshalber von einem Leibwächter beiseitegelegt worden waren
+Alexander der möglicherweise Verrat befürchtete rief in höchster Erregung auf Makedonisch nach einer Lanze entriss einer Wache eine und tötete mit ihr Kleitos seinen Lebensretter am Granikos
+Als Alexander wieder bei Besinnung war bereute er diese Tat zutiefst Es heißt er solle geklagt und geweint und versucht haben sich das Leben zu nehmen
+Er sah diese Tat jedenfalls als einen seiner schwersten Fehler an
+Alexanders Neigung zu übermäßigem Alkoholgenuss - er trank allerdings fast ausschließlich in Gesellschaft - blieb eine Schwäche bei der er häufig die Selbstkontrolle verlor
+Das gemeinsame Trinken der Männer selbst gehörte fest zum gesellschaftlichen Leben in der griechischen Welt siehe Symposion
+Im folgenden Jahr <num> v Chr eroberte Alexander noch zwei sogdische Bergfestungen
+Dann war niemand mehr übrig der ihm Widerstand hätte leisten können
+Zwei Jahre hatten die Sogdier sich gegen Alexander erhoben und ihn in immer neue Scharmützel verwickelt
+Nach dieser Zeit waren die meisten von ihnen tot oder versklavt
+Bevor Alexander nach Baktrien zurückkehrte ließ er <num> Mann Besatzung in den eroberten Gebieten Sogdiens zurück
+Alexander in Baktrien <num> v Chr
+Zurück in Baktra gab Alexander eine Reihe von Befehlen die seine makedonische Generalität weiter von ihm entfremdete
+Da sich baktrische Reiter bei den Feldzügen in Sogdien als hilfreich erwiesen hatten befahl Alexander seinen Generälen <num> junge Perser und Baktrier zu Phalanx-Soldaten auszubilden
+Auch in die Kavallerie wurden Einheimische integriert
+Die Soldaten akzeptierten die Auflagen widerstrebend denn noch immer trauten sie den Persern nicht
+Alexander heiratete in Baktra die sogdische Prinzessin Roxane Tochter eines Mannes namens Oxyartes nicht identisch mit dem gleichnamigen Bruder des Dareios
+Durch diese politische Heirat gedachte er zur Befriedung Sogdiens beizutragen
+Dafür schickte Alexander seine langjährige Geliebte Barsine und den gemeinsamen unehelichen Sohn Herakles fort
+Die Heirat war auch eine Beleidigung für Alexanders Verbündeten Artabazos den Vater der Barsine seinen Statthalter in Baktrien
+Außerdem versuchte Alexander das persische Hofritual der Proskynese einzuführen Jeder der vor den König treten wollte musste sich vor ihm verbeugen und das Gesicht auf den Boden pressen
+Freie Makedonen und Griechen unterzogen sich einer solchen Unterwerfungsgeste allerdings nur vor den Göttern
+Es heißt dass mehrere von Alexanders Generälen sich weigerten sich derart vor ihm zu erniedrigen
+Fortan galt sie nur noch für Perser
+Alexanders Anordnungen wurden als so befremdlich empfunden dass es diesmal zur offenen Revolte unter den griechischen Soldaten zu kommen drohte
+Im Rahmen der sogenannten Pagenverschwörung ließ Alexander auch eine Reihe von einstigen Gefolgsleuten hinrichten darunter seinen Hofbiografen Kallisthenes
+Indienfeldzug <num> v Chr
+DateiTetradrachm Ptolemaeus I obverse CdM Paris FGM<num>jpg
+Nach der Eroberung des gesamten Perserreichs fasste Alexander den Beschluss sein Imperium weiter nach Osten auszudehnen
+Indien war für die Griechen ein halblegendäres Land über das sie kaum etwas wussten
+Das Land das damals Indien genannt wurde ist nicht identisch mit dem heutigen Staat Indien
+Es begann dort wo Persien endete im Osten Afghanistans und umfasste Pakistan und das heutige Indien
+Eine definierte Ostgrenze gab es nicht da kein Reisender jemals weit nach Indien vorgedrungen war
+Die westlichsten Teile jenes Indiens hatten zu Zeiten Dareios I zu Persien gehört wobei Indien selbst kein geeinter Staat war sondern aus einer Vielzahl wenig bekannter Kleinstaaten bestand
+Für den Indienfeldzug gab es keinerlei militärische Notwendigkeit
+Die Gründe werden auch heute noch in der Forschung diskutiert ohne dass bisher eine Einigung erzielt worden wäre
+Möglicherweise waren es Alexanders Neugier und Kriegslust eine Art irrationales Streben und Sehnsucht nach Erfolgen pothos aber auch Thesen wie die von dem Bestreben seine Autorität durch immer neue militärische Siege zu festigen werden angeführt
+Jedenfalls sollte sich der Indienfeldzug als schwere Belastungsprobe erweisen
+Anfang des Jahres <num> v Chr
+stieß Alexander mit zwei Heeren ins Tal des Flusses Kabul vor das damals ein Teil Indiens war
+Der Vorstoß war von besonderer Grausamkeit gekennzeichnet
+Immer seltener ließ Alexander gegenüber eroberten Regionen Großmut walten
+Städte und Dörfer wurden zerstört und ihre Bevölkerung ermordet
+Die zwei Armeen trafen einander am Indus
+Alexander machte das Land zwischen Kabul und Indus zur Provinz Gandhara und ernannte seinen Gefolgsmann Nikanor zu deren Statthalter
+Am anderen Ufer des Indus wurden Alexanders Truppen von Omphis empfangen dem König von Taxila das etwa <num> km vom heutigen Islamabad entfernt lag
+Hier traf Alexander einen Mann namens Kalanos den er aufforderte ihn auf seinen weiteren Feldzügen zu begleiten
+Kalanos stimmte zu und wurde Alexanders Ratgeber offensichtlich war er bei den kommenden Verhandlungen mit indischen Führern sehr von Nutzen
+Vom Hof des Omphis aus rief Alexander die anderen Staaten des Punjab auf sich ihm zu unterwerfen und ihn als Gott anzuerkennen
+Dies verweigerte Poros der König von Pauravas das von Taxila durch den Fluss Hydaspes heute Jhelam getrennt war
+Im Mai überquerte Alexander während eines Platzregens den Hydaspes und besiegte eine berittene Einheit unter dem Sohn des Poros
+Die Griechen und Perser zogen weiter ostwärts
+Zahlenmäßig waren sie dem kleinen Heer des Poros das sie erwartete überlegen doch kamen sie in dem üppig bewaldeten Land mit seinen ständigen Regenfällen schwer zurecht
+Außerdem waren Berichte zu ihnen gedrungen dass Poros eine Einheit von Kriegselefanten unterhielt mit denen sich die Griechen nie zuvor gemessen hatten
+In der Schlacht am Hydaspes wurden die Inder besiegt
+In dieser Schlacht soll Alexanders Pferd Bukephalos im Hydaspes zu Tode gekommen sein obwohl andere Quellen sagen es sei schon vor der Schlacht an Altersschwäche eingegangen
+Seinem langjährigen Reittier zu Ehren gründete Alexander die Stadt Bukephala heute wahrscheinlich Jhelam in Pakistan
+Poros wurde begnadigt und zu Alexanders Statthalter in Pauravas ernannt
+Weiter im Osten am Ganges lag das Königreich Magadha das selbst den Menschen des Punjab kaum bekannt war
+Alexander wollte auch dieses Land erobern
+Bei heftigem Monsunregen quälte sich die weitgehend demoralisierte Armee ostwärts und hatte einen Hochwasser führenden Fluss nach dem anderen zu überqueren
+Ende Juli stand die Überquerung des Hyphasis heute Beas an und von Magadha waren die Soldaten noch weit entfernt
+Hier meuterten die Männer und weigerten sich weiterzugehen ihr einziges Bestreben war die Heimkehr
+Alexander war außer sich wurde aber letztlich zur Umkehr gezwungen
+Am Ufer des Hyphasis gründete er ein weiteres Alexandreia und siedelte hier viele Veteranen an die damit wenig Hoffnung hegen durften jemals wieder nach Griechenland zurückzukehren
+Rückkehr nach Persien <num>-<num> v Chr
+Der beschwerliche Rückweg zum Hydaspes dauerte bis zum September
+In Bukephala war mit dem Bau von <num> Schiffen begonnen worden die den Fluss abwärts zum Indischen Ozean segeln sollten
+Dies waren jedoch nicht genug um Alexanders gesamte Armee zu transportieren so dass Fußsoldaten die Schiffe am Ufer begleiten mussten
+Im November brachen sie von Bukephala auf doch nach zehn Tagen trafen sie am Zusammenfluss des Hydaspes mit dem Acesines heute Chanab auf Stromschnellen in denen mehrere Schiffe kenterten und viele Griechen ihr Leben verloren
+Der weitere Weg führte durch indische Staaten die Alexander nicht unterworfen hatte
+Immer wieder wurde das Heer angegriffen und die Perser und Griechen zerstörten Städte und Dörfer wo sie ihnen in den Weg kamen
+Im Kampf gegen die Maller wurde Alexander bei der Erstürmung einer Stadt vielleicht Multan
+durch einen Pfeil schwer verletzt
+Das Geschoss drang in seine Lunge obwohl Alexander überlebte sollte er den Rest seines Lebens unter den Folgen dieser Verwundung leiden
+Vom Krankenlager aus befahl er dass am Zusammenfluss von Acesines und Indus ein weiteres Alexandreia nahe dem heutigen Uch gegründet und Roxanes Vater Oxyartes zum Statthalter der neuen Provinz ernannt werden solle
+Als Nächstes griff Alexander die Staaten von Sindh an um seiner Armee den Weg nach Süden freizukämpfen
+Die Könige Musicanos Oxicanos und Sambos wurden unterworfen
+Musicanos der später eine Rebellion anzettelte wurde letztlich gekreuzigt
+Erst als der Monsun wieder einsetzte erreichte das Heer <num> v Chr die Indusmündung und den Indischen Ozean
+Alexander gründete hier die Stadt Xylinepolis heute Bahmanabad und machte die Flotte gefechtsbereit
+Während etwa ein Viertel der Armee so auf dem Seeweg die Rückkehr antreten sollte musste der Großteil über den Landweg nach Persien zurückkehren
+Im August <num> v Chr machte sich das Landheer unter Alexanders Führung auf den Weg
+Die Flotte unter dem Befehl des Nearchos brach einen Monat später überstürzt auf da sich die Einheimischen zu erheben begonnen hatten
+Praktisch unmittelbar nach dem Abzug des Heeres fielen die gerade eroberten Kleinstaaten Indiens ab und erhoben sich gegen die in den neuen Städten zurückgebliebenen Veteranen über deren weiteres Schicksal in den wenigsten Fällen etwas bekannt ist
+Das heutige Belutschistan war damals als Gedrosien bekannt
+Obwohl die Perser vor der Durchquerung der gedrosischen Wüste warnten ging Alexander dieses Risiko ein wahrscheinlich weil dieser Weg der kürzeste war
+Die Hintergründe sind in der Forschung jedoch umstritten
+Ob er wirklich die sagenhafte Königin Semiramis übertreffen wollte ist wenigstens fraglich wenn dann ging es Alexander wohl darum die Rückschläge des Indienfeldzugs durch dieses Unternehmen zu relativieren
+Auch die Stärke seines Heeres zu diesem Zeitpunkt ist ungewiss von wohl sicher übertriebenen <num> Mann bis zu wahrscheinlich realistischeren <num>
+Die sechzigtägigen Strapazen ließen zahllose Soldaten durch Erschöpfung Hitzschlag oder Verdursten ums Leben kommen dabei spielte auch der Umstand eine Rolle dass Alexanders Führer offenbar recht unfähig waren
+Im Dezember erreichten die Soldaten Pura heute Bampur einen der östlichsten Vorposten Persiens und waren damit in Sicherheit
+Massenhochzeit von Susa Revolte in Opis und Tod Hephaistions <num> v Chr
+DateiIstanbul - Museo archeol
+- Sarcofago di Alessandro sec IV aC - Foto G Dall<num>Orto <num>-<num>-<num> <num>jpg
+Alexander gründete im Januar <num> v Chr ein weiteres Alexandreia heute Golashkerd
+Auf dem Weg westwärts stieß er in Susa auf Nearchos und seine Männer die den Seeweg weitgehend unversehrt überstanden hatten
+Neue Feiern wurden genutzt um <num> persische Frauen mit Soldaten zu verheiraten - die Massenhochzeit von Susa
+Die Ehen wurden von Alexander als Notwendigkeit gesehen um das Zusammenwachsen von Persern und MakedonenGriechen weiter voranzutreiben
+Er selbst heiratete zwei Frauen nämlich Stateira eine Tochter des Dareios und Parysatis
+Er war somit nun mit drei Frauen verheiratet
+Die Hochzeiten wurden nach persischem Ritual begangen
+Schon Alexanders Vater hatte die Ehe mit mehreren Frauen als diplomatisches Mittel zur Stabilisierung und Ausweitung seines Machtbereiches eingesetzt
+In der Forschung wurde dies als Versuch interpretiert eine Art Verschmelzungspolitik zu betreiben Johann Gustav Droysen
+Der britische Historiker Tarn sah darin gar den Versuch einer Vereinigung der Menschheit viele andere moderne Historiker wie Badian oder Bosworth lehnen dies jedoch ab
+Um weitere Attribute eines persischen Staates zu übernehmen ernannte Alexander seinen langjährigen Freund Hephaistion und nach dessen Tod Perdikkas zum
+Chiliarchen
+Wesir und seinen General Ptolemaios zum Vorkoster
+Beide Titel waren im Westen unbekannt
+Außerdem wurden gegen mehrere Statthalter die sich bereichert hatten oder ihren Aufgaben nicht sachgerecht nachgekommen waren Prozesse eröffnet
+Harpalos ein Jugendfreund Alexanders und sein Schatzmeister befürchtete aufgrund seines Verhaltens einen solchen Prozess
+Er setzte sich mit <num> Söldnern und <num> Talenten Silber nach Griechenland ab wurde jedoch bald darauf auf Kreta ermordet
+Die Neuerungen Alexanders vergrößerten die Kluft zwischen ihm und seiner makedonischen Generalität
+Da die Zahl der Soldaten iranischer Herkunft im Heer die der Makedonen zu übertreffen begann fürchteten sie bald gänzlich bedeutungslos zu sein
+Perser durften nun auch höhere Ränge in der Armee bekleiden was die Makedonen als unerhört ansahen
+Als die Armee die Stadt Opis am Tigris erreichte erlaubte Alexander vielen Makedonen die Rückkehr nach Hause
+Was sie vorher ersehnt hatten sahen sie nun als Affront da dies das erste Zeichen ihrer Ersetzung durch Orientalen zu sein schien
+Quellen berichten dass manche der Soldaten Alexander wüste Beleidigungen entgegen geschrien hätten
+Alexander reagierte indem er sie ihrer Stellungen enthob und drohte die persischen Soldaten gegen sie zu schicken
+Die Soldaten entschuldigten sich und ihnen wurde verziehen
+<num> griechische Soldaten wurden in den Folgetagen nach Hause geschickt
+Im Herbst des Jahres <num> v Chr ging Alexander nach Ekbatana wo Hephaistion nach einem von vielen Trinkgelagen erkrankte und starb
+Alexander der wohl lange Jahre Hephaistions Geliebter gewesen war zumindest bis zum Feldzug im Iran war außer sich vor Trauer
+Er ließ laut Plutarch den Arzt seines Freundes kreuzigen die Haare von Pferden und Maultieren abrasieren und opfern fastete mehrere Tage und richtete dann ein monumentales Begräbnis aus
+Danach ließ er sämtliche Kossaier umbringen
+Die Beziehung zwischen Alexander und Hephaistion wird oft mit der zwischen Achilleus und Patroklos gleichgesetzt
+Denn da sich das Geschlecht von Alexanders Mutter Olympias auf den Helden aus dem Trojanischen Krieg zurückführte verglich Alexander selbst sich mit Achilles und seinen Freund mit Patroklos
+Alexander hatte so wie auch sein Vater Philipp und viele andere Makedonen bzw Griechen seiner Zeit Beziehungen sowohl zu Frauen - er hatte mehrere deren bekannteste und wohl ernsthafteste die zu Roxane war - als auch zu Männern wobei diese teils auch sexueller Natur waren
+Gleichgeschlechtliche Beziehungen wurden zu jener Zeit nicht geächtet es kam aber sehr wohl auf den sozialen Status der Partner an
+Alexanders letztes Jahr und sein Tod in Babylon <num> v Chr
+DateiMid-nineteenth century reconstruction of Alexander<num>s catafalque based on the description by Diodorusjpg
+Alexander ließ den persischen königlichen Schatz ausmünzen und warf damit das Vermögen der Achämeniden in das Austauschsystem des Nahen Ostens womit ein steiler Anstieg im Volumen der Markttransaktionen im Mittelmeergebiet finanziert wurde
+Dass der attische Münzfuß nunmehr - außer im ptolemäischen Ägypten - allgemein in der hellenistischen Welt galt erleichterte den internationalen Handel und die Schifffahrt
+Bei den Olympischen Spielen des Jahres <num> v Chr ließ Alexander das sogenannte Verbanntendekret verkünden mit dem er den griechischen Poleis befahl die jeweils aus politischen Gründen ins Exil getriebenen Bürger wieder aufzunehmen
+Dies stellte einen massiven Eingriff in die Autonomie der Städte dar führte zu heftigen Konflikten in den Gemeinwesen und war letztlich der Anlass dafür dass sich Athen und mehrere andere Städte nach dem Tod des Königs im Lamischen Krieg gegen die makedonische Herrschaft erhoben
+Im Februar <num> v Chr kehrte Alexander nach Babylon zurück
+Hier bereitete er neue Feldzüge vor die zur Einnahme der Arabischen Halbinsel führen sollten
+Ob er überdies wie Diodor berichtet auch plante anschließend den westlichen Mittelmeerraum mit Karthago zu erobern ist seit langer Zeit umstritten
+In der neueren Forschung geht man zumeist davon aus dass Alexander in der Tat eine solche Expedition vorbereiten ließ da den Makedonen im Jahr <num> während des Lamischen Krieges eine sehr große Flotte zur Verfügung stand die mutmaßlich ursprünglich für das Unternehmen gegen Karthago gebaut worden war Im Mai kurz vor dem geplanten Aufbruch des Heeres gen Arabien verkündete Alexander dass sein toter Freund Hephaistion fortan als Halbgott zu verehren sei nachdem ein Bote aus der Oase Siwa eingetroffen war wo Alexander wegen einer Vergöttlichung Hephaistions angefragt hatte
+Aus diesem Anlass veranstaltete er Feiern bei denen er sich wieder dem unmäßigen Trunk hingab
+Am nächsten Tag erkrankte er an einem Fieber und am <num> Juni starb er schließlich
+Hinsichtlich der Todesursache wurden seither mehrere Thesen diskutiert darunter eine nach der Alexander am West-Nil-Fieber erkrankte
+Auch eine Alkoholvergiftung wird immer wieder in Erwägung gezogen
+Nach einer in der Antike verbreiteten Überlieferung ist er hingegen vergiftet worden angeblich mit dem giftigen Wasser des Styx
+Wahrscheinlicher ist dass seine körperliche Schwächung durch zahlreiche Kampfverletzungen und übermäßigen Weinkonsum zu einer Krankheit geführt hat
+Da die Ärzte damals auf die reinigende Wirkung von herbeigeführtem Erbrechen und Durchfall vertrauten war es üblich Weißen Germer in geringen Dosen zu verabreichen
+Die überlieferten Symptome Alexanders sind typisch für eine Vergiftung durch Weißen Germer
+Möglicherweise verschlechterten die Ärzte seinen Zustand daher durch wiederholte Gaben des Mittels
+Der Leichnam Alexanders soll zur Konservierung in Honig gelegt worden sein
+Entgegen dem Wunsch des Verstorbenen im Ammonium von Siwa begraben zu werden wurde er in Alexandria beigesetzt
+Alexanders letzte Worte auf die Frage wem er sein Reich hinterlassen werde sollen gelautet haben Dem Besten Des Weiteren äußerte Alexander eine dunkle Prophezeiung Er glaube dass seine Freunde große Begräbnisspiele für ihn veranstalten werden Seinen Siegelring übergab er Perdikkas der nach Hephaistions Tod sein engster Vertrauter gewesen war
+Alexandergrab
+DateiPtolemaeus IampBerenike Ijpg
+Alexander hatte eine Beisetzung im Ammonheiligtum der Oase Siwa gewünscht
+Erst nach zweijährigen Vorbereitungen setzte sich der Leichenzug in Babylon in Bewegung
+Er wurde in Syrien von Ptolemaios dem künftigen König Ptolemaios I in Empfang genommen und nach Ägypten geleitet
+Dort wurde der Leichnam aber nicht in die Oase gebracht sondern zunächst in Memphis bestattet Später wohl noch in der Regierungszeit Ptolemaios I spätestens einige Jahre nach seinem Tod wurde er nach Alexandria verlegt nachdem dort eine prächtige Grabstätte für ihn errichtet worden war
+Sie wurde unter König Ptolemaios IV durch ein neues Mausoleum ersetzt das dann auch als Grabstätte der Ptolemäer diente die sich wie alle Diadochen auf Alexanders Vorbild beriefen
+Die mumifizierte Leiche befand sich in einem goldenen Sarkophag der aber im <num> Jahrhundert v Chr von König Ptolemaios X durch einen gläsernen ersetzt wurde der den Blick auf den einbalsamierten Leichnam freigab
+Dieser Schritt Ptolemaios X der später irrtümlich als Grabschändung gedeutet wurde sollte den Alexanderkult fördern
+Für Caesar Augustus Septimius Severus und Caracalla sind Besuche am Grab bezeugt
+Möglicherweise wurde es während der Stadtunruhen in der Spätantike oder bei einer Naturkatastrophe zerstört
+In den Wirren der Spätantike ging die Kenntnis über den Ort der Grabstätte verloren zumindest die Leiche soll laut Libanios noch Ende des <num> Jahrhunderts zu sehen gewesen sein
+Der Kirchenvater Johannes Chrysostomos
+<num> stellte in einer Predigt die rhetorische Frage nach dem Ort des Alexandergrabs um die Vergänglichkeit des Irdischen zu illustrieren er konnte also mit Sicherheit davon ausgehen dass keiner seiner Hörer wusste wo sich das berühmte Bauwerk befunden hatte Die Erinnerung daran blieb aber noch in islamischer Zeit erhalten im <num> Jahrhundert wurde eine angebliche Grabstätte gezeigt
+Im <num> und <num> Jahrhundert berichteten europäische Reisende von einem kleinen Gebäude in Alexandria das als Alexandergrab ausgegeben wurde
+Seit dem <num> Jahrhundert sind viele Lokalisierungsversuche unternommen worden die bisher alle fehlgeschlagen sind
+Geschichtlicher Ausblick
+DateiDiadochen<num>png
+Nach Alexanders Tod erwies sich die Loyalität zu seiner Familie die keinen herrschaftsfähigen Nachfolger stellen konnte als sehr begrenzt
+Zwar wurde zunächst der Erbanspruch seines geistesschwachen Halbbruders und auch der seines postum geborenen Sohnes anerkannt doch hatte diese Regelung keinen Bestand
+Seine Mutter Olympias von Epirus seine Frau Roxane sein Sohn Alexander IV sein illegitimer Sohn Herakles seine Schwester Kleopatra seine Halbschwester Kynane deren Tochter Eurydike und sein Halbbruder Philipp III
+Arrhidaios
+fanden einen gewaltsamen Tod
+Statt der Angehörigen des bisherigen makedonischen Königsgeschlechts übernahmen Alexanders Feldherren als seine Nachfolger Diadochen die Macht
+Da keiner von ihnen stark genug war sich als Alleinherrscher durchzusetzen kam es zu einer langen Reihe von Bürgerkriegen in denen man in wechselnden Koalitionen um die Macht rang
+Im Verlauf der Diadochenkriege wurde das riesige Reich in Diadochenreiche aufgeteilt
+Drei dieser Reiche erwiesen sich als dauerhaft das der Antigoniden in Makedonien bis <num> v Chr das der Seleukiden in Vorderasien bis <num> v Chr und das der Ptolemäer in Ägypten bis <num> v Chr Alexander hinterließ zahlreiche neu gegründete Städte von denen viele seinen Namen trugen die bedeutendste war Alexandreia in Ägypten
+Rezeption
+Antike
+Quellen
+Alexander wurde schon zu Lebzeiten eine mythische Gestalt wozu sein Anspruch auf Gottessohnschaft beitrug
+Die zeitgenössischen erzählenden Quellen sind nicht oder nur in Fragmenten erhalten Dabei handelte es sich neben den Fragmenten der angeblichen Kanzleidokumente Alexanders Ephemeriden größtenteils um Berichte von Teilnehmern des Alexanderzugs
+Der Hofhistoriker Kallisthenes begleitete Alexander um die Taten des Königs aufzuzeichnen und zu verherrlichen
+Sein Werk Die Taten Alexanders reichte vielleicht nur bis <num> v Chr hatte jedoch einen enormen Einfluss auf die späteren Alexanderhistoriker
+Weitere Verfasser von Alexandergeschichten waren König Ptolemaios I von Ägypten der als Offizier und Hofbeamter in der Nähe Alexanders gelebt hatte Aristobulos der für Alexander Unvorteilhaftes leugnete oder abschwächte sowie Alexanders Flottenbefehlshaber Nearchos und dessen Steuermann Onesikritos
+Die stärkste Nachwirkung unter diesen frühen Alexanderhistorikern erzielte Kleitarchos der zwar ein Zeitgenosse aber selbst kein Feldzugsteilnehmer war sondern in Babylon Informationen von Offizieren und Soldaten Alexanders zusammentrug und zu einer rhetorisch ausgeschmückten Darstellung verband wobei er auch sagenhafte Elemente einbezog Zu diesen frühen Legenden gehörte beispielsweise die falsche Behauptung Alexander und Dareios seien einander wiederholt im Nahkampf begegnet
+Im <num> Jahrhundert n Chr schrieb der römische Senator Arrian auf der Grundlage der älteren Quellen unter denen er Ptolemaios und Aristobulos bevorzugte seine Anabasis die verlässlichste antike Alexanderquelle
+Wahrscheinlich behandelte auch Strabon in seinen nicht erhaltenen Historika Hypomnemata Historische Denkwürdigkeiten das Leben Alexanders seine erhaltene Geographie enthält Informationen aus verlorenen Werken der frühen Alexanderhistoriker
+Weitere Nachrichten finden sich im <num> Buch der Universalgeschichte Diodors der sich auf Kleitarchos stützte
+Plutarch verfasste eine Lebensbeschreibung Alexanders wobei es ihm mehr auf das Verständnis des Charakters unter moralischem Gesichtspunkt als auf den historischen Ablauf ankam
+Quintus Curtius Rufus schrieb eine in der Antike wenig beachtete Alexandergeschichte
+Justin wählte für seine Darstellung aus seiner verlorenen Vorlage der Universalgeschichte des Pompeius Trogus vor allem Begebenheiten aus die geeignet waren seine Leserschaft zu unterhalten
+Die Berichte von Curtius Diodor und Pompeius Trogus hängen von einer gemeinsamen Quelle ab das Nachrichtenmaterial das sie übereinstimmend überliefern stammt wohl von Kleitarchos
+Diese Tradition Vulgata bietet teils wertvolle Informationen Curtius wird in der französischen Forschung leicht gegenüber Arrian favorisiert
+Zusätzliches Material ist bei Athenaios sowie in der Metzer Epitome und dem Itinerarium Alexandri überliefert
+Nur wenige Fragmente sind von den Werken des Chares von Mytilene und des Ephippos von Olynth erhalten
+Legende
+DateiNiketerion Alexander CdMjpg
+Als Quelle für den historischen Alexander von relativ geringem Wert aber literarisch von außerordentlicher Bedeutung ist der Alexanderroman Mit diesem Begriff bezeichnet man eine Vielzahl von antiken und mittelalterlichen Biografien Alexanders welche seine sagenhaften Taten schildern und verherrlichen
+Im Lauf der Jahrhunderte wurde der Stoff fortlaufend literarisch bearbeitet und ausgeschmückt
+Die griechische Urfassung in drei Büchern die den Ausgangspunkt für alle späteren Versionen und Übersetzungen in viele Sprachen bildet ist wahrscheinlich im späten <num> Jahrhundert in Ägypten entstanden
+Ihr unbekannter Autor der wohl ein Bürger von Alexandria war wird als Pseudo-Kallisthenes bezeichnet weil ein Teil der handschriftlichen Überlieferung das Werk irrtümlich dem Alexanderhistoriker Kallisthenes von Olynth zuschreibt
+Diesem Werk lagen ältere nicht erhaltene romanhafte Quellen fiktive Briefe Alexanders und kleinere Erzählungen zugrunde
+Der bekannteste unter den Briefen ist ein angeblich von Alexander an Aristoteles gerichtetes Schreiben über die Wunder Indiens das in verkürzter Fassung in den Roman eingebaut wurde und auch separat überliefert ist
+Die gängige Bezeichnung Roman bezieht sich auf die literarische Gattung des Antiken Romans
+Im Gegensatz zum modernen Roman hielten der Verfasser und seine antike und mittelalterliche Leserschaft an dem Anspruch fest der Inhalt sei Geschichtsschreibung und nicht literarische Erfindung
+Die Idee des historischen Alexander er sei ein Sohn des ägyptischen Gottes Ammon Amun verfremdet der Romanautor indem er aus Alexander ein uneheliches Kind macht
+Alexanders Vater ist im Roman der aus Ägypten nach Makedonien geflohene König und Zauberer Nektanebos der als Ammon auftritt gemeint ist der Pharao Nektanebos II
+Nektanebos verführt die Königin Olympias während der Abwesenheit ihres Gemahls Philipp
+Später tötet Alexander der als Sohn Philipps aufwächst seinen leiblichen Vater erst dann erfährt er seine wahre Abstammung
+So macht der ägyptische Autor Alexander zum Ägypter Eine weitere wesentliche Neuerung des Pseudo-Kallisthenes ist die Einführung eines nicht historischen Italienzugs Alexanders auf dem der Makedone nach Rom kommt
+Rom unterstellt sich ihm ebenso wie alle anderen Reiche des Westens kampflos
+Dann unterwirft er in schweren Kämpfen die Völker des Nordens bevor er gegen das Perserreich zieht
+Hier zeigt sich das literarische Bedürfnis den Helden auch den Westen und Norden erobern zu lassen damit seine Weltherrschaft vollendet wird
+Roxane ist im Roman eine Tochter des Perserkönigs Dareios die dieser sterbend Alexander zur Frau gibt
+Das letzte der drei Bücher das den Indienfeldzug und den Tod des Helden behandelt ist besonders stark von Wundern und phantastischen Elementen geprägt
+Es schildert auch Alexanders angeblichen Besuch bei der Königin Kandake von Meroe wobei der König in Verkleidung auftritt aber enttarnt wird eine Episode der spätere Bearbeiter des Stoffs eine ursprünglich völlig fehlende erotische Komponente verleihen
+Schließlich wird Alexander vergiftet
+Im frühen <num> Jahrhundert fertigte Iulius Valerius eine freie lateinische Übersetzung des Alexanderromans an Res gestae Alexandri Magni
+Dabei nahm er Hunderte von Erweiterungen Änderungen und Auslassungen vor
+Er beseitigte Ungereimtheiten und Formulierungen die den Makedonenkönig in ein ungünstiges Licht rücken konnten und fügte für Alexander vorteilhafte Details ein
+Sein Alexander ist eine mit allen Herrschertugenden ausgestattete Idealgestalt er begeht zwar Fehler lernt aber daraus
+Ein weiterer Bestandteil der antiken Alexandersage sind fiktive Dialoge des Königs mit den indischen Brahmanen sowie Briefe die angeblich zwischen ihnen ausgetauscht wurden
+Dabei versuchen die Inder die Überlegenheit östlicher Weisheit und einer einfachen naturnahen Lebensweise gegenüber der griechischen Zivilisation und dem Machtstreben Alexanders aufzuzeigen
+Auch dieses Schrifttum war sowohl griechisch als auch lateinisch verbreitet
+Da es um grundsätzliche Fragen der Lebensführung und um Askese ging war die Wirkung in christlicher Zeit beträchtlich
+Kult und Vorbildfunktion
+Die Herrscher die nach Alexanders Tod in den verschiedenen Teilen seines Reichs an die Macht kamen waren nicht mit ihm blutsverwandt und soweit in Makedonien Loyalität zur herkömmlichen Ordnung vorhanden war galt sie dem Herrscherhaus insgesamt wobei es nicht speziell auf die verwandtschaftliche Nähe zu Alexander ankam
+Daher gab es in den Diadochenreichen wenig Anlass für einen offiziellen staatlichen Alexanderkult dieser blieb den einzelnen Städten überlassen
+Erst in hoch- und späthellenistischer Zeit wurde der politische Rückgriff auf Alexander zu einem wichtigen propagandistischen Mittel
+Einen Sonderfall bildete jedoch Ägypten dessen neue Hauptstadt Alexandria eine Gründung Alexanders und der Ort seines Grabes war
+Die dort regierenden Ptolemäer förderten von Anfang an den Alexanderkult im Rahmen ihrer Propaganda
+Er bildete aber zunächst keinen zentralen Bestandteil ihrer Herrschaftslegitimation und wurde erst von Ptolemaios X der den Doppelnamen Ptolemaios Alexandros führte intensiv politisch instrumentalisiert
+Ein prominenter Gegner der Römer König Mithridates VI von Pontos
+<num> v Chr fiel durch seine mit Nachdruck betriebene Alexander-Imitation auf
+Er bekleidete sich mit dem Mantel Alexanders den er von den Ptolemäern erbeutet hatte und illustrierte so seinen Anspruch Vorkämpfer des Griechentums und Retter der hellenistischen Monarchie vor den Römern zu sein
+Später erbeutete der römische Feldherr Gnaeus Pompeius Magnus der Mithridates besiegte diesen Mantel und trug ihn bei seinem Triumphzug Mit Pompeius dessen Beiname der Große an Alexander erinnerte begann die offenkundige römische Alexander-Imitation zunächst als Reaktion auf die Propaganda des Mithridates
+Mehrere römische Feldherren und Kaiser stellten sich propagandistisch in Alexanders Nachfolge sie verglichen sich mit ihm und versuchten seine Erfolge im Osten zu wiederholen
+Dabei steigerte sich die Verehrung Alexanders in manchen Fällen zu einer demonstrativen Nachahmung von Äußerlichkeiten
+Zu den Verehrern und Nachahmern Alexanders zählten unter den Kaisern insbesondere Trajan Caracalla und mit Vorbehalten Julian Augustus trug zeitweilig auf seinem Siegelring ein Bildnis Alexanders Caligula legte sich den aus Alexandria geholten angeblichen Panzer Alexanders an Nero stellte für einen geplanten Kaukasusfeldzug eine neue Legion auf die er Phalanx Alexanders des Großen nannte Trajan setzte sich einen Helm auf den Alexander getragen haben soll
+Kaiser Severus Alexander der ursprünglich Alexianus hieß änderte seinen Namen in Anknüpfung an den Makedonen
+Urteile
+Einen sehr tiefen und dauerhaften Eindruck hinterließ in Griechenland die Zerstörung Thebens
+Sie wurde nicht nur von den Zeitgenossen sondern jahrhundertelang noch in der römischen Kaiserzeit als unerhörte Grausamkeit empfunden die man Alexander zur Last legte und als historisches Musterbeispiel einer entsetzlichen Katastrophe zitiert
+Besonders die antiken Redner kamen mit Vorliebe darauf zu sprechen und nutzten diese Gelegenheit bei ihrem Publikum starke Emotionen zu wecken
+Es hieß Alexander habe wie ein wildes Tier und als Unmensch apánthrōpos gehandelt
+Noch in byzantinischer Zeit wurde diese Deutungstradition rezipiert
+Aus philosophischer Sicht wurde Alexander meist negativ beurteilt da seine Lebensweise einen Kontrast zu den philosophischen Idealen der Mäßigung Selbstbeherrschung und Seelenruhe bildete
+Insbesondere die Stoiker kritisierten ihn heftig und warfen ihm Hochmut vor ihre Kritik richtete sich auch gegen Aristoteles den Gründer einer rivalisierenden Philosophenschule der als Erzieher Alexanders versagt habe
+Auch die Kyniker pflegten Alexander abschätzig zu beurteilen wobei die Anekdote von der Begegnung des Königs mit dem berühmten kynischen Philosophen Diogenes von Sinope den Ansatzpunkt bildete
+Ihr zufolge hatte Diogenes Alexander der ihm einen Wunsch freistellte nur gebeten Geh mir aus der Sonne und Alexander soll gesagt haben Wenn ich nicht Alexander wäre wollte ich Diogenes sein In der von Aristoteles gegründeten Philosophenschule der Peripatetiker war die Ablehnung Alexanders ebenfalls ausgeprägt wenn auch nicht durchgängig
+Ihr Anlass waren anscheinend ursprünglich Spannungen zwischen Aristoteles und Alexander die noch in der römischen Kaiserzeit ein spätes Echo in einem haltlosen Gerücht fanden wonach Aristoteles ein Gift zubereitet hatte mit dem Alexander ermordet wurde Das negative Alexander-Bild der Philosophen teilte auch Cicero
+Er überliefert die berühmte Anekdote von dem gefangenen Seeräuber der von Alexander wegen seiner Übeltaten zur Rede gestellt wurde worauf der Pirat erwiderte er handle in kleinem Maßstab aus demselben Antrieb aus dem der König weltweit dasselbe tue
+Besonders drastisch drückte Seneca die stoische Sichtweise aus
+Er bezeichnete Alexander als wahnsinnigen Burschen zum Bersten aufgeblasenes Tier Räuber und Plage der Völker Ähnlich äußerte sich Senecas Neffe der Dichter Lucan Der philosophisch orientierte Kaiser Julian der Alexander als Feldherrn bewunderte kritisierte ihn zugleich scharf wegen Maßlosigkeit und unphilosophischer Lebensführung
+Unter den philosophisch orientierten Autoren gab es auch eine kleine Minderheit die Alexander Lob spendete
+Dazu gehörte Plutarch der in seinen zwei Deklamationen Über das Glück oder die Tugend Alexanders des Großen aus dem König einen Philosophenherrscher machte dessen Eroberungen barbarischen Völkern Recht und Frieden brachten und die Unterworfenen so humanisierten Bei diesen Jugendwerken Plutarchs handelte es sich allerdings um rhetorische Stilübungen die nicht notwendigerweise seine wirkliche Auffassung spiegeln
+In seiner Lebensbeschreibung Alexanders äußerte sich Plutarch weit kritischer bemühte sich aber auch um eine Rechtfertigung Alexanders
+Dion von Prusa der den an Alexander anknüpfenden Kaiser Trajan bewunderte würdigte die heldenhafte Gesinnung des Makedonenkönigs
+Bei den Römern war ein beliebtes Thema die hypothetische Frage wie ein militärischer Konflikt zwischen dem Römischen Reich und Alexander verlaufen wäre
+Der Historiker Livius befasste sich eingehend damit und kam zum Ergebnis dass die römischen Heerführer dem Makedonenkönig überlegen waren
+Alexander habe seine Siege der militärischen Untüchtigkeit seiner Gegner verdankt
+Diese Einschätzung verband Livius mit einem vernichtenden Urteil über Alexanders Charakter der durch die Erfolge des Königs verdorben worden sei
+Ähnlich urteilte Curtius Rufus der die Siege des Makedonen mehr auf Glück als auf Tüchtigkeit zurückführte und meinte die Herausbildung tyrannischer Züge in Alexanders Charakter sei ein Ergebnis übermäßigen Erfolgs gewesen
+Aus jüdischer Sicht fiel das Urteil über Alexander sehr vorteilhaft aus
+Der jüdische Geschichtsschreiber Flavius Josephus beschreibt Gunstbezeugungen des Makedonen für die Juden und behauptet Alexander habe sich als er nach Jerusalem kam vor dem Gott den die Juden verehrten niedergeworfen
+Dabei handelt es sich um eine jüdische Abwandlung einer griechischen Erzählung
+Im <num> Jahrhundert wurden im Osten des Reichs Bronzemünzen Alexanders wie Amulette getragen
+Unter den Kirchenvätern hebt sich Orosius als radikalster Kritiker Alexanders ab
+In seiner auf Justin fußenden Historia adversus paganos Geschichte gegen die Heiden schildert er ihn als blutdürstigen grausamen Unmenschen und großen Zerstörer
+Mittelalter
+DateiThe coronation of Alexanderjpg
+Die mittelalterliche Alexander-Rezeption war außerordentlich intensiv und vielfältig Dabei stand das Sagengut im Vordergrund
+Die antike Gestalt wurde mittelalterlichen Vorstellungen angepasst beispielsweise erhält der König eine Ritterpromotion Schwertleite
+Besonders Dichter regte der Stoff im Westen ebenso wie im Orient zur Bearbeitung an es entstanden über <num> Dichtungen in <num> Sprachen
+Quellen
+Die grundlegenden antiken Quellen die im Mittelalter in West- und Mitteleuropa zur Verfügung standen waren neben Pseudo-Kallisthenes der eifrig rezipierte Curtius Rufus der nur als Nebenquelle dienende Justin und der viel beachtete Orosius dessen negative Bewertung Alexanders allerdings wenig Beachtung fand
+Besonders die märchenhaften Elemente des Alexanderromans machten Eindruck und regten die Phantasie der Bearbeiter zu weiteren Ausformungen an
+Der Roman wurde in zahlreiche europäische Sprachen übersetzt wobei lateinische Fassungen die Grundlage bildeten hinzu kamen die teils stark abweichenden Versionen in orientalischen Sprachen Armenisch Altsyrisch Hebräisch Arabisch Persisch Türkisch Äthiopisch Koptisch
+Eine wesentliche Rolle spielte ferner die Prophetie im biblischen Buch Daniel
+über den Untergang der aufeinanderfolgenden Weltreiche in diesem Licht erschien Alexander der nach mittelalterlicher Deutung das zweite der vier Weltreiche vernichtete und das dritte gründete als Werkzeug Gottes Auch dem ersten Kapitel des ersten Makkabäerbuchs war eine knappe Zusammenfassung von Alexanders Lebensgeschichte zu entnehmen dort las man dass er bis ans Ende der Welt gelangte und die Welt vor ihm verstummte Dieser biblische Hintergrund verlieh ihm zusätzliche Bedeutung
+Heldenkatalog
+Im Spätmittelalter zählte man Alexander zum Kreis der Neun Guten Helden einem in der volkssprachlichen Literatur beliebten Heldenkatalog der für die Zeit des Alten Testaments die griechisch-römische Antike und die christliche Zeit jeweils die drei größten Helden benannte für die Antike waren es Hektor Alexander und Caesar
+Noch breiter als in der Literatur wurde diese Heldenreihe in der Bildenden Kunst Skulptur Malerei Textilkunst rezipiert
+Mittellateinische Literatur
+DateiAlexander the Great Ghent Ms <num>jpg Das Alexanderbild in der lateinischsprachigen Welt des Mittelalters war großenteils vom lateinischen Alexanderroman geprägt
+Im Frühmittelalter ging die Hauptwirkung nicht von der ursprünglichen Fassung der von Iulius Valerius stammenden Übersetzung aus von der nur drei vollständige Handschriften überliefert waren weit bekannter war ein in mehr als <num> Handschriften erhaltener spätestens im <num> Jahrhundert entstandener Auszug Epitome aus diesem Werk
+Um <num><num> fertigte der Archipresbyter Leo von Neapel eine neue lateinische Übersetzung des Pseudo-Kallisthenes aus dem Griechischen an die Nativitas et victoria Alexandri Magni Geburt und Sieg Alexanders des Großen die mehrfach - zuletzt noch im <num> Jahrhundert - überarbeitet und erweitert wurde die überarbeiteten Fassungen sind unter dem Titel Historia de preliis Alexandri Magni Geschichte von den Schlachten Alexanders des Großen bekannt
+Der Dichter Quilichinus von Spoleto schrieb <num><num> eine Versfassung der Historia de preliis in elegischen Distichen die im Spätmittelalter populär wurde
+Noch weit einflussreicher war aber die schon zwischen <num> und <num> verfasste Alexandreis Walters von Châtillon ein Epos in zehn Büchern auf der Grundlage der Darstellung des Curtius Rufus das zur Schullektüre wurde und im <num> Jahrhundert als Schulbuch Vergils Aeneis an Beliebtheit übertraf
+Walter verzichtete fast gänzlich auf die Auswertung des im Alexanderroman vorliegenden Materials
+Für ihn war Alexander der stets siegreiche Held der sich selbst ebenso wie alle Feinde überwand und so unsterblichen Ruhm erlangte
+Das Verhältnis dieser Autoren und ihres Publikums zu Alexander war vor allem von Bewunderung für außerordentliche Heldentaten und von Staunen über das Märchenhafte und Exotische geprägt
+Besondere Beachtung fand Alexanders Tod er bot Anlass zu unzähligen religiös-erbaulichen Betrachtungen die auf die Endlichkeit und Nichtigkeit aller menschlichen Größe angesichts des Todes abzielten
+Auf diesen Aspekt wiesen unter anderem viele Kleindichtungen hin darunter insbesondere fingierte Grabschriften Alexanders
+Besonders fasziniert waren mittelalterliche Leser von einer Erzählung von Alexanders Himmelsflug und Tauchexpedition die Leo von Neapel nach dem griechischen Roman wiedergab
+Dieser Sage zufolge wollte der König nicht nur auf der Erdoberfläche die äußersten Grenzen erreichen sondern auch den Himmel und die Tiefe des Ozeans erkunden
+Zu diesem Zweck ersann und baute er mit seinen Freunden ein von Greifen gezogenes Luftfahrzeug und ein von Ketten gehaltenes gläsernes Tauchfahrzeug
+Der Himmelsflug wurde von mittelalterlichen Künstlern häufig abgebildet
+Aus dem <num> Jahrhundert stammt das Iter ad Paradisum Paradiesfahrt die lateinische Version einer jüdischen Sage über Alexanders Versuch das irdische Paradies zu finden den in der Genesis beschriebenen Garten Eden
+Neben der Heldenverehrung kamen vereinzelt auch extrem negative Deutungen der Persönlichkeit Alexanders vor
+So setzten ihn im <num> Jahrhundert die prominenten Theologen Hugo von St Viktor und Gottfried von Admont mit dem Teufel gleich
+Erzählungen aus dem Alexanderroman wurden in Weltchroniken und Enzyklopädien aufgenommen was ihre Rezeption zusätzlich erweiterte
+Die lateinische Überlieferung bildete die Grundlage für die volkssprachliche Rezeption
+In den volkssprachlichen Literaturen entstanden zahlreiche Prosawerke und Dichtungen über Stoffe der Alexandersage wobei vor allem die verschiedenen lateinischen Fassungen des Pseudo-Kallisthenes die Historia Alexandri des Curtius Rufus und die Alexandreis Walters von Châtillon verarbeitet wurden
+Romanische Literaturen
+DateiJean Fouquet- The Coronation of Alexander from the book Histoire AncienneJPG
+Alberich von Bisinzo Albéric de Pisançon der im frühen <num> Jahrhundert die älteste volkssprachliche Alexander-Biografie verfasste ein nur teilweise erhaltenes Gedicht in frankoprovenzalischem Dialekt verwarf nachdrücklich die Legende von Alexanders unehelicher Geburt und hob seine hochadlige Abstammung von väterlicher und mütterlicher Seite hervor
+Er betonte auch die hervorragende Bildung des Herrschers die - einem mittelalterlichen Bildungsideal entsprechend - neben dem Griechischen das der Makedone wie eine Fremdsprache lernen musste auch Latein- und Hebräischkenntnisse umfasst habe Nach der Mitte des <num> Jahrhunderts entstanden weitere französische Gedichte die einzelne Episoden aus Alexanders Leben Belagerung von Tyros Indienfeldzug Lebensende behandelten
+Sie wurden im späten <num> Jahrhundert zur Standardversion des altfranzösischen Roman dAlexandre auch Roman dAlixandre zusammengefügt die von allen im romanischen Sprachraum verbreiteten volkssprachlichen Bearbeitungen des Stoffs die stärkste Wirkung erzielte
+Dieses Epos besteht aus über <num> <num> Versen Zwölf- und Dreizehnsilbern vom Roman dAlexandre erhielt dieses Versmaß später die Bezeichnung Alexandriner
+Der Roman schildert Alexanders Leben durch Verknüpfung von vier Gedichten unterschiedlichen Ursprungs
+Dabei kommt zum Altbestand der Alexanderlegende noch eine Reihe von frei erfundenen Personen und Begebenheiten hinzu
+Der Autor stellt Alexander im Stil der Chanson de geste wie einen sehr standesbewussten ritterlichen Lehnsherrn des Mittelalters dar
+Er hebt dabei besonders die Großzügigkeit seines Helden hervor und präsentiert das Ideal eines harmonischen Verhältnisses zwischen König und Vasallen
+Neben epischen Partien besonders in den Kampfschilderungen finden sich auch stärker romanhafte und vom Phantastischen geprägte
+Mehrere Dichter fügten später Ergänzungen hinzu insbesondere die einem Publikumsbedürfnis entsprechende Darstellung der Rache für den Giftmord an Alexander In England schrieb Thomas von Kent im späten <num> Jahrhundert einen Alexanderroman in Alexandrinern in anglonormannischer Sprache mit dem Titel Le roman de toute chevalerie
+Er akzeptierte im Gegensatz zu allen älteren romanhaften Bearbeitungen des Stoffs problemlos die Vorstellung dass Alexander aus einem Ehebruch seiner Mutter hervorging was für die früheren Autoren ein nicht akzeptabler Makel gewesen war
+Im <num> Jahrhundert entstanden Prosafassungen des Roman dAlexandre
+Der altfranzösische Prosa-Alexanderroman fand weite Verbreitung
+Einen Höhepunkt erreichte die Alexander-Bewunderung im Herzogtum Burgund am Hof Herzog Philipps des Guten
+<num> und seines Nachfolgers Karls des Kühnen
+Die bedeutendste spanische Bearbeitung des Stoffs ist El libro de Alexandre
+Dieses Epos umfasst über <num> <num> Verse Alexandriner und ist damit die umfangreichste epische Dichtung Spaniens aus dem <num> Jahrhundert
+Der unbekannte Verfasser ein vorzüglich gebildeter Geistlicher verfolgt ein moralisches Ziel er will dem Leser anhand der erzählten Begebenheiten die vorbildliche Tugendhaftigkeit des Helden vor Augen stellen
+In Italien entstand eine Reihe von volkssprachlichen Werken über Alexanders Lebens in Prosa und in Versen deren Grundlage meist die lateinische Historia de preliis war
+Die älteste vollständig erhaltene italienische Alexanderdichtung ist die Istoria Alexandri regis von Domenico Scolari aus der ersten Hälfte des <num> Jahrhunderts
+Scolari christianisiert seinen Helden weitgehend Alexander ist ein frommer geradezu heiliger Wundertäter
+Als Universalmonarch beglückt er die Welt durch Recht und Frieden
+Im <num> Jahrhundert erreichte das Interesse an der Alexandersage in Italien seinen Höhepunkt
+Deutsche Literatur
+Die deutschsprachige Alexandersage und Alexanderdichtung setzte um die Mitte des <num> Jahrhunderts mit dem Alexanderlied des Pfaffen Lamprecht ein der sich eng an Alberichs Versroman hielt
+Die drei erhaltenen später bearbeiteten Fassungen von Lamprechts Gedicht der Vorauer Alexander der Straßburger Alexander und der Basler Alexander setzten jedoch in der Bewertung Alexanders unterschiedliche Akzente
+Im Vorauer Alexander wird deutliche Kritik am König geübt
+Alexander handelt zwar nach dem Willen Gottes wird aber als hochmütig und herrschsüchtig dargestellt die Zerstörung von Tyros wird als schweres Unrecht verurteilt da die Tyrer als treue Untertanen des Perserkönigs nur ihre Pflicht erfüllten
+Überdies erscheint er als mitleidlos da er nicht über den Tod der vielen Gefallenen trauert
+Andererseits verfügt er aber über Umsicht die ihn seine Neigung zu jähzorniger Unbeherrschtheit überwinden lässt womit er ein Beispiel gibt und sich von dem sehr negativ gezeichneten Dareios abhebt
+Alexander wird bewusst als zwiespältige Persönlichkeit gezeichnet Ein einfacheres Alexanderbild entwirft ein aus ritterlich-aristokratischer Sicht wertender Autor im Straßburger Alexander hier wird der König als vorbildlicher Kämpfer Feldherr und Herrscher idealisiert
+Als solcher handelt er nicht eigenmächtig sondern sucht den Rat seiner Vasallen
+Er ist klug gerecht und gütig und seine schon in der Antike negativ bewertete Neigung zum Jähzorn wird als einigermaßen berechtigt dargestellt Allerdings ist er nicht frei von Hochmut zum vollkommenen Herrscher fehlt ihm die Mäßigung die er aber in seiner letzten Lebensphase doch noch erlangt womit er das Ideal restlos verwirklicht
+Im Basler Alexander dominiert ein anderes in der mittelalterlichen Alexander-Rezeption ebenfalls zentrales Element die Freude am Wunderbaren Seltsamen und Exotischen
+Diese Behandlung des Stoffs zielt auf das Unterhaltungsbedürfnis eines breiten nicht mehr primär an ritterlichen Idealen orientierten spätmittelalterlichen Publikums
+Im <num> Jahrhundert verfasst der Dichter Rudolf von Ems das allerdings unfertig gebliebene Epos Alexander
+Er schildert den König als vorbildlich tugendhaften Helden und ritterlichen Fürsten der sich durch seine moralischen Qualitäten als Herrscher legitimiert
+Alexander vollzieht als Werkzeug Gottes dessen Willen
+Durch ihn werden die Perser die mit ihrem Verhalten den Zorn des Allmächtigen hervorgerufen haben gezüchtigt
+Sein Handeln ist Teil der Heilsgeschichte er kann christlichen Herrschern als Vorbild dienen
+Ulrich von Etzenbach beschreibt in seinem zwischen <num> und <num> entstandenen Gedicht Alexander <num> Verse den König nicht nur als edlen Ritter sondern auch als überaus frommen Mann Gottes der seine Siege seinem gottgefälligen Verhalten und Gottvertrauen verdankt die ihm zugeschriebenen Tugenden stammen aus der Heiligendarstellung
+Ulrich missbilligt allerdings einzelne Taten wie die Ermordung Parmenions darin unterscheidet er sich von Rudolf bei dem Alexander makellos ist und Parmenion sein Schicksal selbst verschuldet
+<num> vollendet der nur aus seinem einzigen Werk bekannte Dichter Seifrit seine Alexanderdichtung in der er besonders die Rolle Alexanders als Weltherrscher betont und sich bemüht von seinem Helden den gängigen Vorwurf des Hochmuts fernzuhalten
+Im <num> und im <num> Jahrhundert war der Alexanderstoff in neuen Prosabearbeitungen weit verbreitet die eine befindet sich im
+Großen Seelentrost
+Mitte des <num> Jahrhunderts die andere ist Johann Hartliebs Histori von dem grossen Alexander die nach der Mitte des <num> Jahrhunderts entstand
+Beide dienten einem moralischen Zweck doch ihre Verfasser gingen dabei auf völlig entgegengesetzte Weise bewertend vor
+Im Großen Seelentrost bietet Alexander das abschreckende Lehrbeispiel eines durch und durch gierigen Menschen den seine Neugier Besitzgier und Machtgier letztlich ins Verderben führt denn er versucht die dem Menschen gesetzten Grenzen zu überschreiten
+Bei Hartlieb hingegen ist er ein Vorbild an Mannes- und Fürstentugend und überdies von einem wissenschaftlichen Erkenntnisstreben beseelt
+Für mittelalterliche Verhältnisse auffallend ist die positive Wertung der Wissbegierde eines auf die Natur gerichteten Forscherdrangs der Alexander zugeschrieben wird
+Im <num> Jahrhundert wurden auch Alexanderdramen geschaffen und aufgeführt doch sind ihre Texte nicht erhalten
+Während die mit literarischem Anspruch gestalteten Werke Alexander in der Regel verherrlichen oder zumindest in überwiegend positivem Licht erscheinen lassen werden im religiös-erbaulichen und moralisch belehrenden Prosaschrifttum oft negative Züge des Makedonenkönigs betont dort wird er als abschreckendes Beispiel für Maßlosigkeit und Grausamkeit angeführt
+Sein Himmelsflug dient Geistlichen wie Berthold von Regensburg als Symbol für frevelhaften Übermut
+Andererseits heben bedeutende Dichter wie Walther von der Vogelweide und Hartmann von Aue Alexanders vorbildliche milte Freigebigkeit hervor
+Englische Literatur
+Trotz des traditionell großen Interesses am Alexanderstoff in England gab es erst im Spätmittelalter einen Alexanderroman in englischer Sprache die mittelenglische Dichtung Kyng Alisaunder die wohl aus dem frühen <num> Jahrhundert stammt
+Sie schildert den König als Helden und hebt seine Großmut hervor verschweigt aber auch nicht seine Maßlosigkeit und Unbesonnenheit Eine Reihe von weiteren Schilderungen von Alexanders Leben fußte auf der Historia de preliis Alexandri Magni die im mittelalterlichen England beliebt war
+Byzanz und slawische Länder
+DateiSan marco alexanderjpg Auch für die volkstümliche byzantinische Alexander-Rezeption bildete der Roman des Pseudo-Kallisthenes den Ausgangspunkt
+Er lag zunächst in einer mittelgriechischen Prosabearbeitung aus dem <num> Jahrhundert vor
+In spätbyzantinischer Zeit entstanden mehrere Neufassungen
+Hier hat Alexander die Gestalt eines byzantinischen Kaisers angenommen er ist von Gott gesandt und mit allen Ritter- und Herrschertugenden ausgestattet wird aber nicht zum Christen gemacht sondern dem Bereich des Alten Testaments zugeordnet
+Er ist mit dem Propheten Jeremia befreundet und wird von ihm beschützt <num> entstand das byzantinische Alexandergedicht
+Die beliebteste Szene aus der Alexandersage war in Byzanz der Himmelsflug der in der Bildenden Kunst oft dargestellt wurde
+In den süd- und ostslawischen Literaturen wurde der Alexanderstoff stark rezipiert wobei der Weg des Überlieferungsguts vom griechischen Alexanderroman über kirchenslawische Bearbeitungen in die Volkssprachen führte
+Eine altbulgarische Fassung des Romans Aleksandria wurde zum Ausgangspunkt der Rezeption in russischen Chroniken
+In Russland war der Alexanderroman im Hochmittelalter in mehreren Versionen verbreitet
+Im <num> Jahrhundert begann eine neue Version zu dominieren die vom byzantinischen Volksroman ausging und sich durch stark ausgeprägte Merkmale des mittelalterlichen Ritterromans auszeichnete
+Besonders beliebt war die serbische Fassung serbischer Alexander oder serbische Alexandreis die auch in Russland Verbreitung fand und Vorlage für die spätmittelalterliche georgische Prosaübersetzung war
+In Russland der Ukraine Bulgarien und Rumänien setzte sich dieser Typus der Alexanderlegende durch
+Arabische Literatur
+In der mittelalterlichen arabischsprachigen Literatur war Alexander unter dem Namen al-Iskandar bekannt da der Anfang seines Namens mit dem arabischen Artikel al verwechselt wurde
+Er wurde schon in der vorislamischen Dichtung erwähnt
+Folgenreich war seine Identifizierung mit der koranischen Figur des Dhū l-Qarnain der Zweihörnige von dem in Sure <num> erwähnt wird dass er einen Damm gegen Gog und Magog errichtete Verse <num>-<num>
+Diese Identifizierung wurde von den muslimischen Gelehrten mehrheitlich aber nicht einhellig akzeptiert
+Nach heutigem Forschungsstand ist die Ableitung der Figur Dhū l-Qarnains von Alexander sowie die Herkunft des Motivs aus der altsyrischen christlichen Alexanderlegende eine gesicherte Tatsache Die im Orient verbreitete Bezeichnung Alexanders als zweihörnig taucht schon in einer spätantiken Alexanderlegende in altsyrischer Sprache auf wo Alexander ein christlicher Herrscher ist dem Gott zwei Hörner auf dem Kopf wachsen ließ womit er ihm die Macht verlieh die Königreiche der Welt zu erobern Den ursprünglichen Anlass zur Bezeichnung der Zweihörnige bot die antike bildliche Darstellung Alexanders mit Widderhörnern die auf seine Vergöttlichung deutete Der Gott Zeus Ammon Amun als dessen Sohn Alexander sich betrachtete wurde als Widder oder widderköpfig dargestellt
+Im Koran wird die Geschichte des Zweihörnigen dem Propheten geoffenbart denn er soll sie mitteilen wenn er danach gefragt wird
+Alexander erscheint darin als frommer Diener Gottes dem die Macht auf der Erde gegeben war und ein Weg zu allem Er gelangte bis zum äußersten Westen der Welt wo die Sonne in einer verschlammten Quelle untergeht und erlangte die Herrschaft über das dort lebende Volk hier ist ein Nachhall von Pseudo-Kallisthenes zu erkennen der Alexander nach Italien kommen und den gesamten Westen einnehmen ließ
+Dann schlug der Zweihörnige den Weg zum äußersten Osten ein und gelangte an den Ort wo die Sonne aufgeht daher deuteten die mittelalterlichen Koranausleger die Zweihörnigkeit meist als Zeichen für die Herrschaft über Westen und Osten
+Schließlich begab er sich in eine andere Richtung und kam in eine Gegend wo Menschen lebten die von Angriffen zweier Völker der Yāǧūǧ und Māǧūǧ biblisch Gog und Magog bedroht waren und ihn um Hilfe baten
+Zum Schutz der Bedrohten baute er ohne einen Lohn zu verlangen zwischen zwei Berghängen einen gigantischen Wall aus Eisen den die Angreifer nicht übersteigen oder durchbrechen konnten Dieser Schutzwall wird bis zum Ende der Welt bestehen
+- Eine altsyrische Version der Sage von Alexanders Aussperrung von Gog und Magog in den Revelationes des Pseudo-Methodius wurde ins Griechische und ins Lateinische übersetzt und fand in Europa viel Beachtung
+Auch die voranstehende Passage der <num> Sure Verse <num>-<num> scheint von der Alexanderlegende beeinflusst zu sein obwohl in der Version des Korans Mose statt Alexander der Protagonist ist
+Ein dort erzähltes Wunder Wiederbelebung eines getrockneten Fisches stammt anscheinend aus dem Alexanderroman es kommt auch in einer spätantiken altsyrischen Version der Legende vor Es ist davon auszugehen dass der Stoff des Alexanderromans zur Entstehungszeit des Korans bereits in arabischer Übersetzung verbreitet war
+Die islamische Wertschätzung für Alexander die sich aus seiner Schilderung im Koran ergab führte dazu dass einige Autoren ihn zu den Propheten zählten
+Die mittelalterlichen arabischsprachigen Historiker behandelten die Regierung Alexanders eher knapp
+Im Gegensatz zu den europäischen christlichen Chronisten gingen bedeutende muslimische Geschichtsschreiber wie Ṭabarī Masʿūdī Ibn al-Aṯīr und Ibn Chaldūn auf die Alexandersage nicht oder nur nebenbei ein sie hielten sich primär an die Überlieferung über den historischen Alexander
+Ṭabarī betrachtete seine Quellen kritisch er stützte sich insbesondere auf die Darstellung des bedeutenden Gelehrten Ibn al-Kalbī
+<num><num> und stellte die Vernichtung des Perserreichs als notwendig und berechtigt dar da Dareios tyrannisch regiert habe
+Die Auseinandersetzung mit dem Legendenstoff war kein Thema der Geschichtsschreiber sondern ein Anliegen der Theologen die sich mit der Koranauslegung befassten Reichhaltiges Legendenmaterial über Alexander war im muslimischen Spanien Al-Andalus verbreitet dort hieß es er habe die Iberische Halbinsel als König beherrscht und in Mérida residiert
+Außerdem kommt Alexander auch in der arabischen Weisheitsliteratur vor wo er als Gelehrter und Musikliebhaber beschrieben wird
+Sehr oft taucht sein Name in Spruchsammlungen auf wobei die Sprüche teils ihm zugeschrieben werden teils von ihm handeln
+Persische und türkische Literatur
+DateiIskandar Alexander the Great at the Talking Treejpg
+Im Persischen wurde Alexander Iskandar Sikandar oder Eskandar genannt
+In der Spätantike war im persischen Sassanidenreich eine Legende verbreitet wonach er der persischen Religion dem Zoroastrismus einen schweren Schlag versetzte indem er religiöse Schriften vernichten ließ
+Daher war Alexander bei den Anhängern dieser Religion verhasst und wurde als teuflisches Wesen betrachtet Nach der Islamisierung wirkte sich diese Sage aber im gegenteiligen Sinne aus denn nun machte man aus Alexander einen Vorkämpfer des Monotheismus gegen heidnische Götzendiener
+Der berühmte persische Dichter Firdausī
+<num> baute eine Version der Alexanderlegende in das iranische Nationalepos
+Šāhnāmeh
+ein wobei er in manchen Einzelheiten von Pseudo-Kallisthenes abwich
+Für ihn war Alexander ein römischer Kaiser und Christ der unter dem Kreuzeszeichen kämpfte offenbar dachte er dabei an die byzantinischen Kaiser Außerdem machte er - wie schon Ṭabarī der persischer Abstammung war - Alexander zu einem Halbbruder des Dareios womit er ihn für das Persertum vereinnahmte aus der Vernichtung des Perserreichs wurde ein Bruderzwist innerhalb der iranischen Herrscherfamilie
+<num> schuf der persische Dichter Nezāmi das
+Eskandar-Nāme
+Alexander-Buch Sein Alexander ist völlig islamisiert er ist ein monotheistischer Held der den Zoroastrismus der Perser mit Feuer und Schwert ausrottet und dafür den Beifall des Dichters erhält
+Er unterwirft nicht nur Indien sondern auch China und gelangt im Westen bis nach Spanien
+Wie schon bei Firdausī sucht Alexander auch Mekka auf und reinigt dort die Kaaba
+Außerdem ist er auch Philosoph und ein großer Förderer der Wissenschaft er befiehlt den Gelehrten das Wissen aller Völker zusammenzutragen
+Das Eskandar-Nāme wurde zum Vorbild für einige spätere Dichtungen ähnlicher Art
+Die Handschriften der persischen Alexander-Bücher wurden trotz islamischer Bilderverbote ab dem <num> Jahrhundert mit Buchmalerei geschmückt
+In Nordindien sorgten die Mogul-Kaiser des <num> Jahrhunderts für die Bebilderung solcher Bücher
+Im Jahr <num> verfasste der türkische Dichter Tāǧ ed-Dīn Ibrāhīm Aḥmedī das türkische Alexanderepos Iskendernāme die erste türkische Bearbeitung des Alexanderstoffs
+Dafür bildete Nezāmis Alexanderbuch die Grundlage doch verfügte Aḥmedī auch über andere Quellen aus denen er zusätzliches Sagenmaterial bezog
+Sein Werk war im Osmanischen Reich lange berühmt und gelangte auch nach Iran und Afghanistan
+Hebräische Literatur
+Die jüdische Alexanderrezeption war von dem Umstand geprägt dass der Makedone schon in der Antike als Freund des jüdischen Volkes und Diener Gottes betrachtet wurde
+In der mittelalterlichen hebräischen Alexanderliteratur floss Material aus unterschiedlichen Traditionen zusammen
+Einerseits handelte es sich um Stoff aus dem griechischen Alexanderroman bzw der Historia de preliis andererseits um einzelne Sagen jüdischer Herkunft Verhalten Alexanders in Jerusalem seine Schutzmaßnahme gegen Gog und Magog sein Aufenthalt im irdischen Paradies und weitere Geschichten
+Die hebräische Überlieferung wurde nicht nur von der griechischen und lateinischen beeinflusst sondern wirkte auch ihrerseits auf die westeuropäische Alexandersage ein
+Weit verbreitet war in der lateinischsprachigen Welt eine von Petrus Comestor eingeführte Variante der Erzählung von Gog und Magog wonach Alexander nicht die wilden Völker Gog und Magog sondern die zehn jüdischen Stämme aussperrte um sie für ihre Abwendung vom wahren Gott zu bestrafen
+Äthiopische Alexanderlegende
+Ins christliche Äthiopien gelangte der Alexanderroman auf dem Umweg über eine arabische Fassung
+Der Stoff wurde für die Bedürfnisse eines geistlich orientierten Publikums stark umgestaltet
+Alexander wird zu einem christlichen König der den christlichen Glauben predigt
+Er lebt keusch und ist ein Vorbild der Tugendhaftigkeit
+Er stirbt wie ein Einsiedler nachdem er sein Vermögen an die Armen verteilt hat
+Durch diese besonders weitreichende Umarbeitung des Romans wird er zu einem Erbauungsbuch
+Humanismus und Frühe Neuzeit
+DateiCharles Le Brun - Entry of Alexander into BabylonJPG
+Petrarca behandelte in seinem Werk Über berühmte Männer auch Alexander wobei er sich an Curtius Rufus hielt dessen negative Äußerungen er herausgriff Positives verschwieg er
+Die außerordentliche Bekanntheit der Legendengestalt Alexander hielt auch in der Frühen Neuzeit an
+So schrieb der Chronist Johannes Aventinus
+<num> es sei kein Herr kein Fürst unseren Leuten auch dem gemeinen ungelehrten Mann so bekannt wie Alexander Andererseits drangen aber in der Renaissance die Humanisten zum historischen Alexander vor und taten die Alexandersage als Märchen ab
+Die Wiederentdeckung griechischer Quellen insbesondere Arrians die im Mittelalter unbekannt waren ermöglichte einen neuen Zugang zur Epoche Alexanders
+Schon der Portugiese Vasco da Lucena der <num> am Hof Karls des Kühnen von Burgund die erste französische Übersetzung der Alexanderbiografie des Curtius Rufus anfertigte übte scharfe Kritik an der Legende in deren Übertreibungen und Wunderglauben er eine Verdunkelung der wahren historischen Leistung Alexanders sah
+<num><num> schuf der Maler Albrecht Altdorfer sein berühmtes Gemälde Die Alexanderschlacht
+Charles Le Brun malte ab den frühen sechziger Jahren des <num> Jahrhunderts eine Reihe von Szenen aus Alexanders Leben für König Ludwig XIV
+Auf Dichter und Romanautoren übte die Gestalt Alexanders weiterhin eine starke Faszination aus
+Ab dem <num> Jahrhundert handelt es sich allerdings großenteils um Werke deren Handlung sich - ganz im Gegensatz zur traditionellen Alexandersage - um frei erfundene erotische Verwicklungen dreht und nur noch geringe Ähnlichkeit mit dem ursprünglichen Legendenstoff aufweist
+Hans Sachs schrieb <num> eine Tragedia von Alexandro Magno die in sieben Akten die ganze Geschichte Alexanders darstellt
+In Frankreich verfasste Jacques de la Taille <num> die Tragödien La Mort de Daire und La Mort dAlexandre und Alexandre Hardy wählte dieselben Titel für zwei seiner Tragödien La Mort dAlexandre <num> und La Mort de Daire <num>
+Im weiteren Verlauf des <num> Jahrhunderts folgten zahlreiche Tragödien und Tragikomödien darunter Racines Alexandre le Grand Uraufführung <num>
+Noch intensiver war die Rezeption in italienischer Sprache
+Antonio Cesti komponierte die Oper Alessandro vincitor di se stesso Uraufführung Venedig <num> Francesco Lucio ein dramma musicale Glamori di Alessandro Magno e di Rossane Libretto von Giacinto Andrea Cicognini <num> zahlreiche Dramen Melodramen Opern und Ballette folgten
+Unter den Opern waren besonders erfolgreich Alessandro Magno in Sidone von MarcAntonio Ziani <num> Libretto von Aurelio Aureli die tragicommedia per musica Alessandro in Sidone von Francesco Bartolomeo Conti <num> Libretto Apostolo Zeno und
+Alessandro nellIndie
+von Leonardo Vinci <num> Libretto Pietro Metastasio sowie vor allem
+Alessandro
+von Händel Uraufführung in London <num> Libretto von Paolo Antonio Rolli
+Gluck verwertete Elemente des Alexanderstoffs sowohl in seiner Oper Poro Alessandro nellIndia Uraufführung Turin <num> Libretto von Metastasio als auch in dem Ballett Alessandro
+Zu Beginn des <num> Jahrhunderts schrieb in Spanien der Dichter Lope de Vega die Tragikomödie Las grandezas de Alejandro
+Der englische Schriftsteller John Lyly schrieb die Komödie Campaspe Uraufführung <num> die auch unter dem Titel Alexander and Campaspe bekannt ist und von einem Aufenthalt Alexanders in Athen handelt
+John Dryden dichtete <num> die Ode Alexanders Feast welche die Basis für das Libretto des <num> vollendeten und uraufgeführten gleichnamigen Oratoriums von Georg Friedrich Händel HWV <num> bildete
+In Griechenland wurde von <num> bis ins frühe <num> Jahrhundert die Alexanderlegende in gedruckten Volksbüchern verbreitet zunächst vorwiegend in Versform Rimada <num> Drucke von <num> bis <num> ab dem <num> Jahrhundert meist in Prosa Phyllada
+Von insgesamt <num> Drucken der Phyllada aus dem Zeitraum von ca <num> bis <num> erschienen <num> in der zweiten Hälfte des <num> Jahrhunderts
+Rezeption in Nordmazedonien
+DateiAlexander-Statue-Skopjejpg
+Seit der Unabhängigkeitserklärung der früheren jugoslawischen Teilrepublik Mazedonien der heutigen Republik Nordmazedonien im Jahr <num> knüpfte der neue souveräne Staat demonstrativ an die Tradition des antiken Reichs Makedonien an und betrachtete diese als einen wesentlichen Aspekt seiner nationalen Identität
+Von offizieller mazedonischer Seite wurde behauptet es gebe eine ethnische und kulturelle Kontinuität vom antiken Makedonien zum heutigen Mazedonien Im Rahmen solcher Traditionspflege förderten mazedonische Behörden auch auf kommunaler Ebene die Verehrung Alexanders des Großen was sich unter anderem in der Errichtung von Alexander-Denkmälern und in der Benennung von Straßen äußert
+Im Dezember <num> wurde der Flughafen der mazedonischen Hauptstadt Skopje nach Alexander benannt Aerodrom Skopje Aleksandar Veliki dort wurde eine große Alexander-Büste aufgestellt
+<num> wurde die Errichtung einer zwölf Meter hohen Reiterstatue auf einem zehn Meter hohen Sockel im Zentrum von Skopje beschlossen die Alexander nachempfunden war Im Juni <num> wurde dieser Beschluss der in Griechenland Irritation auslöste umgesetzt
+Von griechischer Seite wird die Behauptung einer kulturellen Kontinuität zwischen den antiken Makedonen und den heutigen Staatsbürgern der Republik Mazedonien nachdrücklich zurückgewiesen
+Daher erscheint auch die mazedonische Alexander-Rezeption aus griechischer Sicht als Provokation da die gesamte Alexander-Tradition ausschließlich ein Teil des griechischen kulturellen Erbes sei
+Im Februar <num> beschloss die neue mazedonische Regierung angesichts von Fortschritten bei den Verhandlungen mit Griechenland zum mazedonischen Namensstreit den Flughafen von Skopje und eine Autobahn die den Namen Alexander von Makedonien trug wieder umzubenennen
+Moderne Belletristik
+In der Moderne hat sich die Belletristik stärker als früher um Nähe zum historischen Alexander bemüht
+Zu den bekannteren historischen Romanen aus der ersten Hälfte des <num> Jahrhunderts gehören
+Alexander in Babylon
+von Jakob Wassermann <num>
+Alexander
+Roman der Utopie
+von Klaus Mann <num> der Alexander als gescheiterten Utopisten darstellt und Iskander von Paul Gurk <num>
+Weitere belletristische Darstellungen von Alexanders Leben stammen von Mary Renault Roger Peyrefitte Gisbert Haefs
+und Valerio Massimo Manfredi Arno Schmidt lässt in seiner Erzählung Alexander oder Was ist Wahrheit <num> den Ich-Erzähler Lampon eine Wandlung vom Verehrer zum Gegner Alexanders durchmachen
+Iron Maiden widmete ihm den in der Metal-Szene sehr populär gewordenen Titel Alexander the Great der <num> im Album Somewhere in Time erstmals veröffentlicht wurde
+Beurteilung in der modernen Forschung
+Den Ausgangspunkt der modernen wissenschaftlichen Auseinandersetzung mit Alexander bildete die <num> erschienene Geschichte Alexanders des Großen von Johann Gustav Droysen
+Droysen betonte die aus seiner Sicht positiven kulturellen Folgen von Alexanders Politik einer Völkervermischung statt einer bloßen makedonischen Herrschaft über unterworfene Barbaren
+Er lobte die Wirtschaftspolitik die Städtegründungen und die Förderung der Infrastruktur und meinte auf religiösem Gebiet habe Alexanders Politik die Entstehung einer Weltreligion vorbereitet
+Dieser Sichtweise war eine starke Nachwirkung beschieden
+Im englischen Sprachraum war ihr Hauptvertreter im <num> Jahrhundert William W Tarn dessen <num> erschienene Alexander-Biografie den Eroberer als Idealisten beschreibt der eine zivilisatorische Mission erfüllen wollte
+Dieser Einschätzung deren Grundidee schon bei Plutarch auftaucht steht eine dezidiert negative Wertung gegenüber welche Kernpunkte der antiken Alexanderkritik aufgreift
+Die Vertreter dieser Richtung siehe bereits die negative Charakterisierung durch Karl Julius Beloch sowie später Ernst Badian und ähnlich Fritz Schachermeyr daran anschließend Albert B Bosworth Ian Worthington Wolfgang Will unterscheiden sich hinsichtlich der Gewichtung verschiedener Einzelaspekte
+Grundsätzlich aber sehen sie in dem Eroberer Alexander primär einen Zerstörer dessen Fähigkeiten sich auf Militärisches beschränkten
+Politisch sei er an seinen Fehlern gescheitert
+Er habe impulsive irrationale Entscheidungen getroffen und sich mit den Säuberungen unter seinen Vertrauten und Offizieren schließlich in die Isolation manövriert da er niemandem mehr vertrauen konnte
+Die militärischen Leistungen Alexanders die früher einhellige Anerkennung fanden werden von den modernen Kritikern relativiert so charakterisiert Badian den Rückmarsch aus Indien als eine von Alexander verschuldete militärische Katastrophe
+Waldemar Heckel hingegen hob in jüngerer Zeit Alexanders strategische Fähigkeiten hervor und wandte sich zugleich gegen ein romantisierendes Alexanderbild Vor einer überzogenen Kritik wodurch sozusagen das Pendel von der Heldenverehrung Alexanders in das andere Extrem umzuschlagen droht warnte etwa Frank L Holt der diesen Trend als new orthodoxy bezeichnete
+Neben diesen stark wertenden Darstellungen stehen Untersuchungen vor allem aus neuerer und neuester Zeit deren Autoren von vornherein darauf verzichten die Persönlichkeit Alexanders zu erfassen ein Werturteil über sie abzugeben und seine verborgenen Motive zu erkunden was aufgrund der Quellenlage sehr schwierig ist worauf u a Gerhard Wirth hingewiesen hat
+Diese Forscher untersuchen vielmehr Alexanders Selbstdarstellung deren Wandel und die sich daraus ergebenden politischen Folgen
+Siehe auch
+Alexandermosaik
+Geschichte des Hellenismus
+Alexander Film
+Quellen
+Waldemar Heckel John C Yardley Alexander the Great
+Historical Sources in Translation
+Blackwell Oxford <num> ISBN <num>-<num>-<num>-<num>thematisch geordnete Sammlung von Quellenauszügen in englischer Übersetzung mit knappen Kommentaren und weiterführenden Hinweisen als erster Überblick zu empfehlen
+Johannes Hahn Alexander in Indien <num>-<num> v Chr Antike Zeugnisse eingeleitet übersetzt und erläutert
+Fremde Kulturen in alten Berichten Bd <num>
+Thorbecke Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Literatur
+Zum historischen Alexander
+Pedro Barceló Alexander der Große Wissenschaftliche Buchgesellschaft Darmstadt <num> ISBN <num>-<num>-<num>-<num>
+Helmut Berve Das Alexanderreich auf prosopographischer Grundlage <num> Bände Beck München <num> weiterhin grundlegend für Institutionen und Personen
+Albert Brian Bosworth Alexander and the East
+The Tragedy of Triumph
+OxfordNew York <num> teilweise sehr negative Bewertung Alexanders durch einen Historiker der ihm zahlreiche Bücher und Aufsätze gewidmet hat
+Albert Brian Bosworth Conquest and Empire
+The Reign of Alexander the Great
+Cambridge University Press Cambridge <num> <num> ISBN <num>-<num>-<num>-X
+Albert Brian Bosworth Alexander the Great
+In
+The Cambridge Ancient History
+<num> Auflage Bd <num> The Fourth Century BC Cambridge University Press Cambridge <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Pierre Briant Darius in the Shadow of Alexander Harvard University Press Cambridge MassachusettsLondon <num>
+Pierre Briant Alexander the Great and His Empire A Short Introduction Princeton University Press Princeton <num>
+Paul Cartledge Alexander the Great
+The Hunt for a New Past
+Overlook Press Woodstock New YorkLondon <num> ISBN <num>-<num>-<num>-<num> gut lesbare Darstellung wenngleich eher thematisch als chronologisch gegliedert
+Alexander Demandt Alexander der Große Leben und Legende
+Beck München <num> ISBN <num>-<num>-<num>-<num>-<num> Rezension bei sehepunkte
+Johann Gustav Droysen Geschichte Alexanders des Großen Herausgegeben von Armin Hohlweg u a ars una Neuried <num> ISBN <num>-<num>-<num>-<num> Nachdruck der Ausgabe Gotha <num> vermehrt um einen Anmerkungsteil mit kritischen Kommentaren der Herausgeber und zahlreiche Abbildungen und Karten
+Johannes Engels Philipp II
+und Alexander der Große
+Wissenschaftliche Buchgesellschaft Darmstadt <num> ISBN <num>-<num>-<num>-<num> sehr gute Einführung
+Robin Lane Fox Alexander der Große
+Eroberer der Welt
+<num> Auflage Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num> nicht unumstrittene aber großartig erzählte Darstellung die Alexander recht positiv sieht
+Peter Green Alexander of Macedon
+A historical Biography
+University of California Press BerkeleyLos AngelesLondon <num> ISBN <num>-<num>-<num>-<num> Nachdruck von Penguin Harmondsworth <num> neben Bosworth Lauffer und Lane Fox eine der besten modernen Alexander-Biografien
+Hans-Joachim Gehrke Alexander der Grosse <num> aktualisierte Auflage
+Beck München <num> ISBN <num>-<num>-<num>-<num>-<num>
+Nicholas G L Hammond Alexander der Große
+Feldherr und Staatsmann
+Ullstein Berlin <num> ISBN <num>-<num>-<num>-X
+Svend Hansen Alfried Wieczorek Michael Tellenbach Hrsg
+Alexander der Große und die Öffnung der Welt
+Asiens Kulturen im Wandel
+Schnell
+Steiner Regensburg <num> ISBN <num>-<num>-<num>-<num>-<num> Begleitband zur gleichnamigen Ausstellung in den Reiss-Engelhorn-Museen in Mannheim mit ca <num> Farbabbildungen und Essays von Wissenschaftlern verschiedener Fachrichtungen
+Waldemar Heckel The Marshals of Alexanders Empire Routledge London <num> ISBN <num>-<num>-<num>-<num> nützliches prosopografisches Handbuch
+Waldemar Heckel Whos Who in the Age of Alexander the Great
+Prosopography of Alexanders Empire
+Blackwell Oxford u a <num> ISBN <num>-<num>-<num>-<num>
+Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great
+A new History
+Blackwell Oxford u a <num> aktuelle und nützliche Sammlung von Beiträgen zu verschiedenen Schlüsselthemen wie Eroberungen Armee Hof Persien Privatleben Rezeption
+Siegfried Lauffer Alexander der Große <num> Auflage dtv München <num> ISBN <num>-<num>-<num>-<num> deutsche Kurzdarstellung sehr quellennah
+Sabine Müller Alexander der Große
+Eroberung - Politik - Rezeption
+Kohlhammer Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Joseph Roisman Hrsg Brills companion to Alexander the Great Brill Leiden <num> ISBN <num>-<num>-<num>-<num> Sammelband mit Beiträgen zu verschiedenen Schlüsselthemen darunter Alexander als Stratege Selbstdarstellung der Hof
+Fritz Schachermeyr Alexander der Grosse
+Das Problem seiner Persönlichkeit und seines Wirkens
+Wien <num> umfassende Darstellung die teilweise mit den vorherigen zumeist positiven Alexanderbildern brach
+Jakob Seibert Alexander der Große
+Erträge der Forschung Bd <num>
+Wissenschaftliche Buchgesellschaft Darmstadt <num> ISBN <num>-<num>-<num>-<num>
+William W Tarn Alexander the Great <num> Bände Cambridge University Press Cambridge <num> deutsch <num> Nachdruck in einem Band <num> teilweise sehr romantisierende Darstellung wobei Alexander ausgesprochen positiv beurteilt wird Bd <num> bietet einen Überblick über die Quellen sowie Einzeluntersuchungen
+Hans-Ulrich Wiemer Alexander der Große Beck München <num> ISBN <num>-<num>-<num>-<num> solide Einführung
+Wolfgang Will Alexander der Große
+Urban Taschenbücher Bd <num>
+Kohlhammer Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Wolfgang Will Hrsg Zu Alexander dem Großen
+Festschrift Gerhard Wirth zum <num> Geburtstag
+<num> Bände Hakkert Amsterdam <num>-<num>
+Gerhard Wirth Alexander der Große mit Selbstzeugnissen und Bilddokumenten
+Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num>
+Ian Worthington By the Spear
+Philip II Alexander the Great and the Rise and Fall of the Macedonian Empire
+Oxford University Press Oxford <num>
+Ian Worthington Hrsg Alexander the Great
+A Reader
+Routledge London <num> ISBN <num>-<num>-<num>-<num> Aufsatzsammlung in der auch Quellen zumeist aus den
+Fragmenten der griechischen Historiker
+in englischer Übersetzung zitiert werden
+Rezeptionsgeschichte
+Antike
+Jean-Michel Croisille Hrsg Neronia IV
+Alejandro Magno modelo de los emperadores romanos
+Latomus Bruxelles <num> ISBN <num>-<num>-<num>-<num>
+Karsten Dahmen The Legend of Alexander the Great on Greek and Roman Coins Routledge London <num> ISBN <num>-<num>-<num>-<num>
+Siegmar Döpp Alexander in spätlateinischer Literatur In Göttinger Forum für Altertumswissenschaft <num> <num> S <num>-<num> PDF
+Hans-Ulrich Wiemer Hero God or Tyrant
+Alexander the Great in the Early Hellenistic Period
+In Henning Börm Hrsg Antimonarchic Discourse in Antiquity
+Steiner Stuttgart <num> S <num>-<num>
+Mittelalter
+Willem J Aerts Hrsg Alexander the Great in the Middle Ages
+Ten Studies on the Last Days of Alexander in Literary and Historical Writing
+Alfa Nijmegen <num>
+George Cary The Medieval Alexander Cambridge University Press Cambridge <num>
+Heribert J Gleixner Das Alexanderbild der Byzantiner Salzer München <num>
+Laurence Harf-Lancner u a Hrsg Alexandre le Grand dans les littératures occidentales et proche-orientales
+Centre des Sciences de la Littérature Nanterre <num>
+Tilman Nagel Alexander der Große in der frühislamischen Volksliteratur
+Beiträge zur Sprach- und Kulturgeschichte des Orients Band <num>
+Verlag für Orientkunde Walldorf <num> ISBN <num>-<num>-<num>-<num>-<num>
+Richard Stoneman Alexander the Great
+A Life in Legend
+Yale University Press New Haven <num> ISBN <num>-<num>-<num>-<num>-<num>
+Zachary David Zuwiyya Hrsg A Companion to Alexander Literature in the Middle Ages Brill Leiden
+Boston <num>
+Neuzeit
+Jan Cölln Alexander der Große in Europa und Asien
+Mythisierung von Geschichte und ihre Präsenz nach dem Ersten Weltkrieg
+In
+Antike und Abendland
+<num> <num> S <num>-<num>
+Georg Veloudis Der neugriechische Alexander
+Tradition in Bewahrung und Wandel
+Miscellanea Byzantina Monacensia Band <num>
+Universität Institut für Byzantinistik und Neugriechisch Philologie München <num> Juli <num>
+Dissertation Universität München <num> <num> Seiten unter dem Titel Giōrgos Athanasiu Beludēs Alexander der Große
+Ein alter Neugrieche
+gekürzte Buchhandelsausgabe <num> Seiten
+Tusculum-Schriften
+Heimeran München <num>
+Weblinks
+Teils sehr kritische Betrachtung von Prof Worthington zuerst erschienen im Ancient History Bulletin <num> <num> Lesenswerter Artikel bei der BBC verfasst von Prof Paul Cartledge Das große Alexanderschlacht-Mosaik aus Pompeji Oliver Stones Filmadaption Alexanderprojekt der TU Braunschweig Ausstellung <num> der Reiss-Engelhorn-Museen in Mannheim
+Anmerkungen
+Plutarch Alexander <num> englische Übersetzung Plutarch Alexander <num> englische Übersetzung Plutarch Alexander <num> Herodot Historien <num> Siehe die Quellenzeugnisse bei Heckel Yardley Alexander S <num> f und Eugene N Borza Greeks and Macedonians in the Age of Alexander The Source Traditions In Transitions to Empire Essays in Greco-Roman History <num>-<num> BC in honor of E Badian Norman <num> S <num>-<num> siehe auch hier Anderer Meinung ist Nicholas G L Hammond Literary evidence for Macedonian speech In Historia <num><num> <num> S <num>-<num> Im Folgenden wird mit Makedonen nur die Herkunft aus dem antiken Makedonien ausgedrückt Peter Green Alexander of Macedon Berkeley <num> S <num> f Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten III<num>-IV<num> httpia<num>usarchiveorg<num>itemsoxyrhynchuspapyr<num>grenuoftoxyrhynchuspapyr<num>grenuoft_bwpdf Die antiken Quellen darunter Plutarch Alexander <num>-<num> und Justin Historiarum Philippicarum libri XLIV <num>-<num> <num><num>-<num> sowie Diodor Bibliothéke historiké <num> <num> - <num> <num> widersprechen sich Die neuere Forschung wird bei Hans-Joachim Gehrke Geschichte des Hellenismus München <num> S <num> diskutiert Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten III<num>-IV<num> httpia<num>usarchiveorg<num>itemsoxyrhynchuspapyr<num>grenuoftoxyrhynchuspapyr<num>grenuoft_bwpdf Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten IV<num>-<num> httpia<num>usarchiveorg<num>itemsoxyrhynchuspapyr<num>grenuoftoxyrhynchuspapyr<num>grenuoft_bwpdf Vgl dazu Jakob Seibert Panhellenischer Kreuzzug Nationalkrieg Rachefeldzug oder makedonischer Eroberungskrieg Überlegungen zu den Ursachen des Krieges gegen Persien In Wolfgang Will Hrsg Alexander der Große Eine Welteroberung und ihr Hintergrund Vorträge des Internationalen Bonner Alexanderkolloquiums <num>-<num> Dezember <num> Bonn <num> S <num> ff Karl Julius Beloch Griechische Geschichte <num> Auflage Bd <num> S <num> vgl Siegfried Lauffer Alexander der Große <num> Auflage München <num> S <num> Curtius Historiae Alexandri Magni Macedonis <num><num>-<num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Robin Lane Fox Alexander der Große Stuttgart <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen hrsg von Armin Hohlweg u a Neuried <num> Nachdruck der Ausgabe Gotha <num> S <num>f und Anm <num> der Herausgeber Robin Lane Fox Alexander der Große Stuttgart <num> S <num> Arrian Anabasis <num> Alexander Demandt Alexander der Große Leben und Legende München <num> S <num> Demandt führt dazu an Diodor Bibliothéke historiké <num> <num> <num> <num> <num> <num> Curtius Rufus Historiae Alexandri Magni Macedonis <num> <num> Justin Historiarum Philippicarum libri XLIV <num> <num> <num> Nicholas Hammond Alexander der Große Berlin <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> und Robin Lane Fox Alexander der Große Stuttgart <num> S <num> William Linn Westermann The Slave Systems of Greek and Roman Antiquity Philadelphia <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Zeitangabe nach Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck über die exakte Datierung gibt es unterschiedliche Angaben Frank Rainer Scheck Die Weihrauchstraße Von Arabien nach Rom - auf den Spuren antiker Weltkulturen Bergisch Gladbach <num> S <num>-<num> Frank Rainer Scheck Die Weihrauchstraße Bergisch Gladbach <num> S <num> Nicolas Hammond Alexander der Große Berlin <num> S <num> Diese Version ist zu verwerfen Historisierende Ausschmückungen sind meist Curtius Rufus der sich auf Kleitarchos bezog zuzuordnen Diese Vulgata genannte einer einzigen Tradition folgende Darstellung hier Kleitarchos
+machte Alexander erst zu der umstrittenen Person deren Beurteilung das antike Publikum und die modernen Historiker spaltete Wolfgang Will Alexander der Große Darmstadt <num> S <num> In der Zeit des Römers Curtius
+konnte die zeitgenössische Kritik an den römischen Kaisern im <num> Jhdt n Chr nur heimlich geäußert werden
+und sich an Alexander - stellvertretend - offen zeigen Wolfgang Will Alexander der Große Darmstadt <num> S <num> Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> Frank Rainer Scheck Die Weihrauchstraße Bergisch Gladbach <num> S <num> Robin Lane Fox Alexander der Große Stuttgart <num> S <num> f Johann Gustav Droysen Geschichte Alexanders des Großen München <num> Nachdruck S <num> f Günther Hölbl Geschichte des Ptolemäerreiches Darmstadt <num> S <num> Robin Lane Fox Alexander der Große S <num> Gerhard Wirth <num> gibt hierzu die Quelle an Pseudo-Kallisthenes <num> <num> <num> S <num> Text und Bild Robin Lane Fox Alexander der Große Rowohlt Taschenbuch Verlag Reinbek bei Hamburg <num> Original <num> S <num> ISBN <num>-<num>-<num>-<num>-<num> Siehe auch die anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten IV<num>-<num> Volltext als PDF-Datei Anonyme Chronik in Bernard P Grenfell Arthur S Hunt Hrsg The Oxyrhynchus Papyri Part I London <num> S <num>-<num> hier S <num> Spalten V<num>-<num> Volltext als PDF-Datei Für die Kämpfe in der Satrapie Baktrien vgl Frank L Holt Into the Land of Bones Alexander the Great in Afghanistan Berkeley <num> Einen knappen Überblick bietet etwa Albert Brian Bosworth The Indian campaigns <num>-<num> BC In J Roisman Hrsg Brills Companion to Alexander the Great S <num>-<num> Vgl Bosworth Alexander Euripides and Dionysos The motivation for apotheosis In Robert W Wallace Edward M Harris Hrsg Transitions to empire Essays in Greco-Roman history <num>-<num> BC Oklahoma <num> S <num>-<num> Johannes Hahn Hrsg Alexander in Indien <num>-<num> v Chr Stuttgart <num> Zur Lokalisierung vgl Siegfried Lauffer Alexander der Große <num> Auflage München <num> S <num> Anm <num> Vgl Ernst Badian Alexander the Great and the Unity of Mankind In Historia Nr <num> <num> S <num>-<num> Allgemeiner Überblick bei Daniel Ogden Alexanders Sex Life In Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great A New History Chichester <num> S <num> ff Fritz Moritz Heichelheim Wirtschaftsgeschichte des Altertums Band <num> Leiden <num> S <num> Diodor Bibliothéke historiké <num><num>-<num> Vgl Albert Brian Bosworth Alexanders last Plans In Albert B Bosworth Hrsg From Arrian to Alexander Studies in Historical Interpretation Oxford <num> S <num> ff Laut Plutarch Alexander <num> starb er am <num> Daisios entsprechend dem <num> Juni <num> v Chr Diodor Bibliothéke historiké <num> <num> <num> Diskussion dazu bei Michael Rathmann Perdikkas zwischen <num> und <num> Nachlassverwalter des Alexanderreiches oder Autokrat Wien <num> S <num>-<num> Rezension Zum Ort dieser Grabstätte siehe Andreas Schmidt-Colinet Das Grab Alexanders des Großen in Memphis In Margaret Bridges Johann Ch Bürgel Hrsg The Problematics of Power Eastern and Western Representations of Alexander the Great Bern <num> S <num>-<num> Zum politischen Hintergrund siehe Claudia Bohm Imitatio Alexandri im Hellenismus München <num> S <num>-<num> Harry E Tzalas The Tomb of Alexander the Great- The history and the legend in the Greco-Roman and Arab times In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Tzalas stellt S <num>-<num> die Quellenzeugnisse über das Grab zusammen Zur Geschichte der Suche siehe Harry E Tzalas The Tomb of Alexander the Great- The history and the legend in the Greco-Roman and Arab times In Graeco-Arabica <num> <num> S <num>-<num> hier <num> f <num>-<num> Zu den Einzelheiten siehe die gründliche Untersuchung von Peter Marshall Fraser Cities of Alexander the Great Oxford <num> Städteliste S <num>-<num> Karten S <num>-<num> Vgl Lionel Pearson The lost histories of Alexander the Great New York <num> Onlineversion Zu den Anfängen der Alexanderlegenden bei den Zeitgenossen des Königs siehe Erwin Mederer Die Alexanderlegenden bei den ältesten Alexanderhistorikern Stuttgart <num> Ben Edwin Perry The Ancient Romances Berkeley <num> S <num> Hartmut Bohmhammel Valerius Übertragung der Alexandergeschichte und ihre gesellschaftlichen Tendenzen Dissertation TU Berlin <num> S <num> Zur Nektanebos-Legende siehe Richard Stoneman Alexander the Great A Life in Legend New Haven <num> S <num> ff Hartmut Bohmhammel Valerius Übertragung der Alexandergeschichte und ihre gesellschaftlichen Tendenzen Dissertation TU Berlin <num> S <num>-<num> Eine eingehende Untersuchung dieses Teils der Alexandersage und seiner Nachwirkung in der Patristik und im Mittelalter bietet Florian Kragl Die Weisheit des Fremden Studien zur mittelalterlichen Alexandertradition Bern <num> Zur Frage des Alexanderkults und der Popularität Alexanders in den Diadochenreichen siehe Robert Malcolm Errington Alexander in the Hellenistic World In Alexandre le Grand Image et réalité Genf <num> S <num>-<num> <num>-<num> Alfred Heuß Alexander der Große und die politische Ideologie des Altertums In Antike und Abendland <num> <num> S <num> f Alexander Meeus Alexanders Image in the Age of the Successors In Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great A New History Chichester <num> S <num>-<num> und die Untersuchung von Claudia Bohm Imitatio Alexandri im Hellenismus München <num> Claudia Bohm Imitatio Alexandri im Hellenismus München <num> S <num> <num> ff <num> Gerhard Wirth Alexander und Rom In Alexandre le Grand Image et réalité Genf <num> S <num>-<num> Otto Weippert Alexander-Imitatio und römische Politik in republikanischer Zeit Augsburg <num> S <num> ff Diana Spencer Roman Alexanders Epistemology and Identity In Waldemar Heckel Lawrence A Tritle Hrsg Alexander the Great A New History Chichester <num> S <num>-<num> hier <num>-<num> Siehe dazu Corinne Jouanno Un épisode embarrassant de lhistoire dAlexandre la prise de Thèbes In Ktèma <num> <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num> Erwin Mederer Die Alexanderlegenden bei den ältesten Alexanderhistorikern Stuttgart <num> S <num>-<num> Zu Senecas Alexander-Rezeption siehe Alfred Heuß Alexander der Große und die politische Ideologie des Altertums In Antike und Abendland <num> <num> S <num>f zur philosophischen Alexanderkritik allgemein Johannes Stroux Die stoische Beurteilung Alexanders des Großen In
+Philologus
+<num> <num> S <num>-<num> und William W Tarn Alexander Cynics and Stoics In American Journal of Philology <num> <num> S <num>-<num> hier <num>-<num> Lucan Bellum civile <num>-<num> Gerhard Wirth Der Weg in die Vergessenheit Wien <num> S <num>-<num> Alfred Heuß Alexander der Große und die politische Ideologie des Altertums In Antike und Abendland <num> <num> S <num> f Ernst Bammel Der Zeuge des Judentums In Wolfgang Will Hrsg Zu Alexander dem Großen Bd <num> Amsterdam <num> S <num> vgl Gerhard Wirth Der Weg in die Vergessenheit Wien <num> S <num>-<num> Johannes Chrysostomos Ad illuminandos catechesis <num> Zum Alexanderbild des Orosius siehe Siegmar Döpp Alexander in spätlateinischer Literatur In Göttinger Forum für Altertumswissenschaft <num> <num> S <num>-<num> hier <num>-<num> online PDF <num> kB Aktueller Überblick bei Zachary David Zuwiyya Hrsg A Companion to Alexander Literature in the Middle Ages LeidenBoston <num> Herwig Buntz Die deutsche Alexanderdichtung des Mittelalters Stuttgart <num> S <num> Das grundlegende Standardwerk für die mittelalterliche Alexander-Rezeption ist George Cary The Medieval Alexander Cambridge <num> Zu den orientalischen Versionen siehe Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num>Dan <num> <num>-<num> sowie Dan <num> und <num> Zur antiken und mittelalterlichen Auslegung siehe Hartmut Wulfram Der Übergang vom persischen zum makedonischen Weltreich bei Curtius Rufus und Walter von Châtillon In Ulrich Mölk Hrsg Herrschaft Ideologie und Geschichtskonzeption in Alexanderdichtungen des Mittelalters Göttingen <num> S <num> ff Victor M Schmidt A Legend and its Image The Aerial Flight of Alexander the Great in Medieval Art Groningen <num> Untersuchung mit zahlreichen Abbildungen Siehe auch Richard Stoneman Alexander the Great A Life in Legend New Haven <num> S <num>-<num> Gottfried von Admont Homilia XVI In Jacques Paul Migne Patrologia Latina Bd <num> Sp <num> f Hugo von St Viktor Allegoriae in Vetus Testamentum <num> In Migne Patrologia Latina Bd <num> Sp <num> f Trude Ehlert Deutschsprachige Alexanderdichtung des Mittelalters Frankfurt am Main <num> S <num> f Siehe auch Ulrich Mölk Alberics Alexanderlied In Jan Cölln u a Hrsg Alexanderdichtungen im Mittelalter Göttingen <num> S <num>-<num> Eine Übersicht über die französische Dichtung bietet David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num> vertiefte Darstellungen bieten Martin Gosman La légende dAlexandre le Grand dans la littérature française du <num>e siècle Amsterdam <num> und Catherine Gaullier-Bougassas Les romans dAlexandre Aux frontières de lépique et du romanesque Paris <num> Die Geschichte der Alexanderrezeption im italienischen Mittelalter beschreibt Joachim Storost Studien zur Alexandersage in der älteren italienischen Literatur Halle Saale <num> Trude Ehlert Deutschsprachige Alexanderdichtung des Mittelalters Frankfurt am Main <num> S <num>-<num> <num> Christoph Mackert Die Alexandergeschichte in der Version des pfaffen Lambrecht München <num> S <num> f <num>-<num> <num>-<num> <num> ff Trude Ehlert Deutschsprachige Alexanderdichtung des Mittelalters Frankfurt am Main <num> S <num>-<num> Zu diesem Werk siehe Gerrit Bunt Alexander the Great in the literature of Medieval Britain Groningen <num> S <num>-<num> Heribert J Gleixner Das Alexanderbild der Byzantiner München <num> S <num>-<num> <num>-<num> Willem J Aerts The Last Days of Alexander the Great according to the Byzantine Alexander Poem in Willem J Aerts Hrsg Alexander the Great in the Middle Ages Ten Studies on the Last Days of Alexander in Literary and Historical Writing Nijmegen <num> S <num>-<num> und S <num> f zur Datierung Hierzu und zu islamischen Auslegungen der Koranstelle siehe Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num>-<num> Alexander Demandt Alexander im Islam In Monika Schuol Udo Hartmann Andreas Luther Hrsg Grenzüberschreitungen Formen des Kontakts zwischen Orient und Okzident im Altertum Stuttgart <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num>-<num> zuletzt Kevin van Bladel The Alexander Legend in the Quran <num>-<num> in Gabriel S Reynolds Hrsg The Quran in Its Historical Context London <num> S <num>-<num> Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Dominique Svenson Darstellungen hellenistischer Könige mit Götterattributen Frankfurt am Main <num> S <num>-<num> Zum antiken Ursprung dieses Sagenmotivs siehe Alexander Demandt Alexander im Islam In Monika Schuol u a Hrsg Grenzüberschreitungen Stuttgart <num> S <num>-<num> hier <num> f Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Die Stelle ist Pseudo-Kallisthenes Vita Alexandri Magni <num><num> Skeptisch äußerte sich allerdings Brannon M Wheeler Moses or Alexander Early Islamic Exegesis of Quran <num>-<num> In
+Journal of Near Eastern Studies
+<num> <num> S <num> ff Zum arabischen Alexanderroman siehe Toufic Fahd La version arabe du Roman dAlexandre In Graeco-Arabica <num> <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num> Michel M Mazzaoui Alexander the Great and the Arab Historians In Graeco-Arabica <num> <num> S <num>-<num> Zu den spanischen Versionen der muslimischen Alexanderlegende siehe Manuela Marín Legends of Alexander the Great in Moslem Spain In Graeco-Arabica <num> <num> S <num>-<num> Richard Stoneman Alexander the Great in the Arabic Tradition In Stelios Panayotakis Hrsg The Ancient Novel and Beyond Leiden <num> S <num>-<num> Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num>-<num> <num> Richard Stoneman Alexander the Great A Life in Legend New Haven <num> S <num>-<num> Noch im <num> Jahrhundert war diese Sichtweise bei den Parsen in Indien verbreitet siehe Friedrich Pfister Kleine Schriften zum Alexanderroman Meisenheim <num> S <num> Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> f Von einem Vordringen Alexanders nach China hatte schon der <num> gestorbene persische Gelehrte al-Bīrūnī geschrieben siehe Alexander Demandt Alexander im Islam In Monika Schuol u a Hrsg Grenzüberschreitungen Stuttgart <num> S <num>-<num> hier <num> Rudolf Macuch Pseudo-Callisthenes Orientalis and the Problem of Ḏu l-qarnain In Graeco-Arabica <num> <num> S <num>-<num> hier <num> Zu Nezāmis Epos siehe auch Johann C Bürgel Krieg und Frieden im Alexanderepos Nizamis In Margaret Bridges Johann Ch Bürgel Hrsg The Problematics of Power Eastern and Western Representations of Alexander the Great Bern <num> S <num>-<num> David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num> <num> <num> <num> f Zur jüdischen Alexanderlegende siehe auch Max Brocker Aristoteles als Alexanders Lehrer in der Legende Bonn <num> S <num>-<num> Friedrich Pfister Kleine Schriften zum Alexanderroman Meisenheim <num> S <num>-<num> David J A Ross Alexander Historiatus A Guide to medieval illustrated Alexander Literature Frankfurt am Main <num> S <num>-<num> Arthur Hübner Alexander der Große in der deutschen Dichtung des Mittelalters In Die Antike <num> <num> S <num> Florens Deuchler Heldenkult im Mittelalter In Margaret Bridges Johann Ch Bürgel Hrsg The Problematics of Power Eastern and Western Representations of Alexander the Great Bern <num> S <num> f Georg Veloudis Alexander der Große Ein alter Neugrieche München <num> S <num> f Eine ausführlichere Darstellung bietet die Dissertation von Georg Veloudis Der neugriechische Alexander München <num>
+Über die Positionen mazedonischer Nationalisten informiert Loring M Danforth The Macedonian Conflict Ethnic Nationalism in a Transnational World Princeton <num> S <num>-<num> speziell zu Alexander dem Großen S <num>-<num> Sinisa-Jakov Marusic
+<num> Mai <num> Hajrudin Somun
+<num> Juni <num>
+Über die Positionen griechischer Nationalisten informiert Loring M Danforth The Macedonian Conflict Ethnic Nationalism in a Transnational World Princeton <num> S <num>-<num> speziell zu Alexander dem Großen S <num> <num>-<num>
+DerStandardat <num> Februar <num> Abgerufen am <num> Februar <num> Gisbert Haefs Alexander Band <num> Hellas Der Roman der Einigung Griechenlands <num> und Band <num> Asien Der Roman der Eroberung eines Weltreichs <num> Valerio Massimo Manfredi Alexander Der makedonische Prinz erster Band einer Trilogie Alexander König von Asien zweiter Band und Alexander Der Herrscher der Welt dritter Band die italienische Originalausgabe aller drei Bände erschien <num> Der von Ernst Badian verfasste Alexander-Artikel im Neuen Pauly einem maßgeblichen Nachschlagewerk Bd <num> Sp <num>-<num> fasst die aus der Sicht dieser Forschungsrichtung wesentlichen Gesichtspunkte zusammen Waldemar Heckel The Conquests of Alexander the Great Cambridge <num> S IXf Frank Holt Alexander the Great today In the Interests of Historical Accuracy In The Ancient History Bulletin <num> <num> S <num>-<num> Vgl dazu Ian Worthingtons Antwort auf Holt
+Antike von
+alt altertümlich altehrwürdig bezeichnet eine Epoche im Mittelmeerraum die etwa von <num> v Chr
+bis ca <num> n Chr
+reicht wobei der Beginn teilweise noch deutlich früher angesetzt wird
+Die Antike unterscheidet sich von vorhergehenden und nachfolgenden Epochen durch gemeinsame und durchgängige kulturelle Traditionen
+Sie umfasst die Geschichte des antiken Griechenlands des Hellenismus und des Römischen Reichs
+Insbesondere das Römische Reich vereinte den Mittelmeerraum seit dem <num> Jahrhundert n Chr
+politisch und kulturell
+In einem erweiterten Sinne umfasst die Antike auch die Geschichte der altorientalischen nahöstlichen Hochkulturen Ägyptens Mesopotamiens Assyriens Persiens und Kleinasiens die etwa mit dem Beginn der Schriftlichkeit um <num> v Chr einsetzt
+Der größere Zeitraum von etwa <num> v Chr
+bis zum Ende der Antike wird bevorzugt als Altertum bezeichnet
+Die darauffolgende Epoche ist das Mittelalter mit einem breiten regional unterschiedlichen Übergangszeitraum siehe Spätantike und Frühmittelalter
+Zeitliche und begriffliche Abgrenzungen
+Im Sinne der klassischen Altertumswissenschaften bezeichnet der historische Begriff Antike meist die Zeit von der allmählichen Herausbildung der griechischen Staatenwelt bis zum Ende des weströmischen Reichs im Jahr <num> bzw bis zum Tod des oströmischen Kaisers Justinian <num>
+Seit den Arbeiten des belgischen Historikers Henri Pirenne wird oft auch das Jahr <num> also der Tod Mohammeds und die darauf folgende islamische Expansion als Datum für das Ende der Antike vorgeschlagen
+Der Anfang der antiken griechisch-römischen Kultur im klassischen Sinne wird im Allgemeinen mit der Entstehungszeit der Homerischen Epen und dem Beginn der griechischen Kolonisation des Mittelmeerraums im <num> Jahrhundert v Chr angesetzt
+Die Griechen verbreiteten ihre Kultur in den folgenden Jahrhunderten im gesamten Mittelmeerraum und an den Küsten seiner Nebenmeere und seit Alexander dem Großen auch im Orient und nach Zentralasien hinein
+Die Römer brachten die antike Zivilisation bis nach Mittel- und Nordwesteuropa wo sie sich seit dem Frühmittelalter zur christlich-abendländischen Kultur wandelte
+Je nach Forschungsrichtung werden aber auch die minoische und mykenische Kultur von etwa <num> bis <num> v Chr sowie die so genannten Dunklen Jahrhunderte <num> bis <num> v Chr zur Antike gerechnet
+Auch zwischen Antike Völkerwanderung und Mittelalter lässt sich - wie bei allen Periodisierungen in der Geschichtswissenschaft - keine für alle Regionen staatlichen und kulturellen Traditionen gültige Trennlinie ziehen
+Je nach Betrachtungsweise sind unter anderem folgende Jahre als Epochengrenzen zwischen der Spätantike und Frühmittelalter vorgeschlagen worden
+<num> Konzil von Nikaia
+<num> Letzte Olympische Spiele der Antike
+<num> Teilung des römischen Reiches nach dem Tod des Theodosius
+<num> Untergang des weströmischen Reichs unter Romulus Augustulus
+<num> Taufe des Frankenkönigs Chlodwig I
+<num> Gründung des ersten abendländischen Benediktinerklosters und Schließung der platonischen Akademie nach dem Tod des letzten antiken Philosophen Boëthius <num>
+<num> Tod Kaiser Justinians
+<num> Ende der so genannten Völkerwanderung mit dem Langobardeneinfall in Italien
+<num> Beginn der islamischen Expansion
+<num> Tod des Kaisers Herakleios
+In der neueren Forschung wird meistens ein später Zeitpunkt favorisiert <num> bzw die Zeit um <num> n Chr Generell erscheint es ohnehin sinnvoll von einem Übergangszeitraum ab ca <num> bis <num> Jahrhundert n Chr auszugehen anstatt feste Daten zu wählen
+Der Begriff Antike wurde lange Zeit räumlich mit der griechischen hellenistischen und später römischen Welt gleichgesetzt
+In diesem Sinne wurde der griechisch-römische Kulturraum von den umgebenden Räumen so abgegrenzt wie schon antike griechische und später römische Gelehrte sich von den Regionen der Barbaren abgrenzten siehe auch Barbaricum
+Griechen wie Römer betrachteten etwa die Kelten Germanen oder Reitervölker nicht als Teil der zivilisierten Welt
+Eine Sonderrolle spielte das Perserreich siehe Achämenidenreich Partherreich und Sassanidenreich das kulturell hoch entwickelt war
+Über die recht enge Definition der römisch-griechischen Welt die durch die Klassische Altertumswissenschaft geprägt wurde geht der universalhistorische Antike-Begriff hinaus der unter anderem von dem Historiker Eduard Meyer im <num> Jahrhundert gefordert wurde
+In jüngerer Zeit wurde er von dem deutschen Althistoriker Josef Wiesehöfer wieder aufgegriffen
+Die Mehrheit der heutigen Forscher ordnet jedoch den Alten Orient und das alte Ägypten zwar dem Altertum nicht aber der Antike zu
+Ursprünge der antiken Kultur
+Die Ursprünge der europäischen Antike liegen im Dunkeln
+Ihre Vorgeschichte ist etwa in der Zeit von ca <num> bis ca <num> v Chr im Mittelhelladikum anzusiedeln
+Zu Beginn dieses Zeitabschnitts - teils auch schon im letzten Abschnitt des Frühhelladikums FH III ca <num>-<num> v Chr - wanderten wahrscheinlich indogermanische Stämme von Norden kommend in Griechenland ein
+Offenbar unter dem Einfluss der minoischen Kultur auf Kreta der ersten Hochkultur Europas die ihre Blüte von ca <num> bis <num> v Chr hatte entwickelte sich auf dem Festland aus der Kultur des Mittelhelladikums die mykenische Kultur ca <num> bis <num><num> v Chr Sie hatte ihren Ausgangspunkt vermutlich in der Argolis und erscheint unvermittelt mit reichen Schachtgräbern ab ca <num> v Chr Unter anderem übernahm die mykenische Kultur von der minoischen die Schrift
+Die auf Kreta unter anderem verwendete sog Linear A-Schrift des <num> bis <num> Jahrhunderts v Chr wurde zur sog Linear B-Schrift <num> bis <num> Jahrhundert v Chr weiterentwickelt
+Dieser begegnet man auf zahlreichen Tontäfelchen unter anderem der Paläste in Pylos Theben Mykene auf dem griechischen Festland und in den zu jener Zeit mittlerweile mykenisch beherrschten Zentren Kydonia und Knossos auf Kreta
+DateiLöwentor Mykenejpg Bekannt sind die prächtigen Zentren der mykenischen Kultur
+Zu den bedeutenden Fundorten gehören Mykene Pylos und Tiryns auf der Halbinsel Peloponnes Orchomenos und Gla letzteres kein Palastzentrum in Boiotien sowie das stark mykenisch geprägte Milet in Westkleinasien
+Die Zentren hatten Oberstädte Akropolen Burgen genannt die im <num> Jahrhundert v Chr in einigen Fällen stark befestigt bzw deren Befestigungen stark ausgebaut wurden Mykene Tiryns Athen
+Reiche Kuppelgräber feine teils reich bemalte Keramik kunstvolle Gold- Silber- und Fayence-Arbeiten usw zeugen vom Reichtum und von der Spezialisierung des Wirtschaftssystems das in Teilen Griechenlands ab ca <num> v Chr von mächtigen Palastzenten die größere Regionen beherrschten zentral gesteuert wurde so in Böotien Attika Messenien und in der Argolis s dazu auch Mykenische Palastzeit
+Intensive Handelskontakte wurden mit dem Nahen Osten Assyrien und Ägypten gepflegt
+Mykenische Keramik war in weiten Teilen des Mittelmeergebiets beliebt möglicherweise ließen sich in manchen Siedlungen Süditaliens Roca Vecchia Punta Meliso Scoglio del Tonno sogar Handwerker nieder
+Etwa für den Zeitraum <num> bis <num> v Chr setzt man traditionell das
+Dunkle Zeitalter
+an aus dem vergleichsweise wenig überliefert ist
+Zu Beginn dieser Phase wurden viele der Zentren des griechischen Festlands zerstört womit die Grundlage der Palastkultur unterging
+Die mykenische Kultur bestand jedoch noch etwa <num> Jahre weiter erlebte in einigen Regionen ab Mitte des <num> Jahrhunderts sogar eine gewisse Nachblüte bevor der Übergang in die sogenannte Protogeometrische Periode ca <num><num>-<num> v Chr erfolgte
+Ungefähr zur gleichen Zeit als sich um <num> v Chr in Griechenland - und auch an anderen Regionen des östlichen Mittelmeerraums s auch Ende des Hethiterreichs Seevölker - Zerstörungen und Umwälzungen ereigneten entstanden auf Zypern und einigen Orten Südkleinasiens z B Tarsus und Mersin mykenisch geprägte Siedlungen
+Westhandel speziell mit Italien und Sardinien wurde auch im <num> Jahrhundert v Chr weiterhin betrieben teilweise auch noch im <num> Jahrhundert v Chr Der Überlieferung nach setzte ca <num> v Chr die sehr umstrittene
+Ionische Wanderung
+ein in deren Verlauf die Einwohner des griechischen Festlandes die Inseln der Ägäis und die Westküste Kleinasiens kolonisierten
+Auf dem griechischen Festland bietet sich ein diffuses Bild Wenige Siedlungen wurden bisher entdeckt und die meisten machen einen - im Vergleich zur mykenischen Zeit - ärmlichen Eindruck
+Ganz anders hingegen Lefkandi auf Euböa dort wurden neben einer Siedlung mit einem großen Gebäude des Fürsten von Lefkandi Gräber gefunden die sehr reich ausgestattet waren
+Das Dunkle Zeitalter hellt sich in den letzten Jahrzehnten - dank vieler neuer Funde vor allem aber nicht nur aus der mykenischen Spätphase des <num><num>
+Jahrhunderts v Chr - immer mehr auf
+Nach Annahme der Homer-Forschung spiegeln unterschiedliche Passagen der Ilias die Verhältnisse dieser Zeit wider
+Sie war offenbar auch für die Entwicklung der griechischen Gesellschaft zur Polis hin wichtig
+Ab dem <num> Jahrhundert waren die Kontakte zum Vorderen Orient wieder sehr intensiv und es entstanden Handelsstationen auf Zypern Kition und in Syrien Al Mina
+Vermutlich bereits im späten <num> Jahrhundert v Chr hat man von den Phöniziern das Alphabet vermittelt bekommen
+Griechenland und die hellenische Welt
+Anfänge des klassischen Griechenlands
+Mit dem so genannten archaischen Zeitalter begann im frühen <num> Jahrhundert v Chr die eigentliche Antike
+Seit dem Jahr <num> v Chr ist die Siegerliste der Olympischen Spiele überliefert
+Von etwa <num> bis <num> v Chr breiteten sich die Griechen während der Großen Kolonisation im westlichen Mittelmeer vor allem Sizilien und Unteritalien siehe auch Magna Graecia und bis Marseille an der nördlichen Ägäis und am Schwarzen Meer aus
+In Kleinasien waren Griechen bereits vorher ansässig
+In dieser Zeit etwa zwischen <num> und <num> v Chr wurden vermutlich auch die Homerischen Epen
+Ilias
+und
+Odyssee
+schriftlich fixiert die ältesten Literaturdenkmäler des Abendlands
+Die ältesten tatsächlich erhaltenen Papyrusfragmente dieser Texte stammen aus dem <num> Jahrhundert v Chr die ältesten Codices mit längeren Textpassagen tauchen im Mittelalter ca <num> Jahrhundert n Chr auf wie generell der Großteil der erhaltenen antiken Literatur vor allem in mittelalterlichen Handschriften überliefert ist
+Hesiod wirkte ebenfalls etwa in der Zeit um <num> v Chr
+Entstehung der Polis
+Die klassische Periode war eine Zeit großer kultureller und wissenschaftlicher Entfaltung
+Zugleich bildete sich das System der griechischen Stadtstaaten der Poleis heraus wobei diese in der Mehrzahl nur eine sehr kleine Bevölkerung umfassten
+Der werdende Militärstaat Sparta im Süden der Peloponnes unterwarf zwischen <num> und <num> v Chr Messenien und kontrollierte damit den gesamten südwestlichen Teil der Halbinsel
+Die Stadt mit ihrer oligarchischen Verfassung kann als das erste Beispiel für die fortan herrschende Polis-Struktur gelten
+Auch in vielen anderen griechischen Stadtstaaten regelten Verfassungen das Zusammenleben der Bürger aber auch die Tyrannis wie sie um <num> v Chr beispielsweise in Korinth und Megara bestand war keine Seltenheit
+In Athen bildete sich unter wechselnden Voraussetzungen schließlich ein demokratisches System heraus
+Nach den Gesetzgebungen Drakons <num> v Chr und Solons <num><num> v Chr gelang es Peisistratos und seinen Söhnen etwa zwischen <num> und <num> v Chr zwar noch einmal eine Tyrannis zu errichten
+Bis <num> v Chr brachten die Reformen des Kleisthenes von Athen aber den Durchbruch für die Attische Demokratie
+Blütezeit Athens
+Mit Athens Unterstützung der kleinasiatischen Griechenstädte im Ionischen Aufstand um <num> v Chr begann ein annähernd zweihundertjähriger Konflikt mit dem Perserreich zunächst in Gestalt der drei Perserkriege die der Historiker Herodot der Vater der Geschichtsschreibung mit ihm lässt man traditionell die griechische Geschichtsschreibung beginnen vgl
+Liste der griechischsprachigen Geschichtsschreiber der Antike
+in seinen Historien geschildert hat wenngleich nicht immer zuverlässig
+Als die Perser zu einer Strafexpedition in Griechenland einfielen wurden sie <num> v Chr von den Athenern in der Schlacht bei Marathon besiegt
+Zehn Jahre später unterlag der persische Großkönig Xerxes I der athenischen Flotte unter Themistokles in der Schlacht von Salamis und <num> v Chr den vereinigten Heeren der griechischen Poleis in der Schlacht von Plataiai
+Die Perser waren vorerst zurückgedrängt die griechischen Stadtstaaten in Kleinasien aus der Abhängigkeit befreit
+DateiAthens Acropolisjpg Nach der erfolgreichen Verteidigung und mit der Gründung des Attischen Seebunds <num> v Chr unter der auf die eigene Seemacht gestützte Vorherrschaft Athens setzte eine etwa <num>-jährige Blütezeit der Stadt die Pentekontaetie ein die bis zum Ausbruch des Peloponnesischen Krieges <num> v Chr bzw bis zum Tod des leitenden Staatsmannes Perikles im Jahr <num> v Chr reichte
+Die Akropolis mit dem Parthenontempel wurde damals unter der Regie des Phidias zum glanzvoll-repräsentativen Zentrum der Seemacht Athen ausgebaut
+Die klassischen Tragödien von Aischylos Sophokles und Euripides kamen - meist im Rahmen festlicher Dichterwettbewerbe - im Theater zur Aufführung
+Kaufleute und Gewerbetreibende Künstler und Gelehrte zog die Metropole an
+Auf der Agora wirkte neben den Sophisten der Philosoph Sokrates auf seine Mitbürger ein dessen Lehren Platon später zu einem Werk von herausragender philosophiegeschichtlicher Bedeutung verarbeitete
+Athen mit seinen zu gleichberechtigter politischer Mitwirkung gelangten männlichen Vollbürgern beanspruchte nunmehr die Schule von Hellas zu sein
+Seine durchaus auch aggressive äußere Machtentfaltung in und mit dem Attischen Seebund führte allerdings schon während der Pentekontaetie zu Spannungen vor allem gegenüber der konkurrierenden griechischen Großmacht Sparta
+Kampf um die Hegemonie
+Die zunehmende Rivalität zwischen der Seemacht Athen und der Landmacht Sparta mündete <num> v Chr in den fast <num> Jahre währenden Peloponnesischen Krieg den die zeitgenössischen Historiker Thukydides und im Anschluss an Thukydides Xenophon eindringlich beschrieben haben
+Der sehr wechselhaft verlaufende und mit einer als beispiellos empfundenen Brutalität geführte Konflikt endete auch auf Grund der Unterstützung Spartas durch das Perserreich <num> v Chr mit der vollständigen Niederlage Athens und mit der Errichtung einer zeitweiligen spartanischen Hegemonie über Griechenland
+In der ersten Hälfte des <num> Jahrhunderts v Chr führten die griechischen Städte einen fast permanenten Krieg gegeneinander und in wechselnden Koalitionen auch unter fortwährender Einmischung der Perserkönige
+Die Sehnsucht nach einem Allgemeinen Frieden wurde auch zu propagandistischen Zwecken eingesetzt Königsfrieden von <num> v Chr <num> v Chr löst Theben unter Epaminondas nach der Schlacht bei Leuktra Sparta als Hegemon ab
+Doch auch Thebens Vorherrschaft bestand nur bis rund <num> v Chr und endete mit dem Tod Epaminondas
+Insgesamt schwächte der Peloponnesische Krieg die griechischen Polis so stark dass Philipp II von Makedonien dem andauernden Machtkampf ein Ende setzen konnte indem er Griechenland gewaltsam mit seinem hervorragend geschulten Heer einigte
+Der von Athenern wie Demosthenes als nicht-griechischer Barbar betrachtete König errang mit seinem geschulten Heer in der Schlacht von Chaironeia <num> v Chr die Hegemonie über Hellas die im Jahr darauf im Korinthischen Bund bekräftigt wurde
+Auf Sizilien behauptete sich derweil das mächtige Syrakus gegenüber der Handelsrepublik Karthago welche mit den griechischen Poleis Westgriechen seit dem frühen <num> Jahrhundert v Chr im Konflikt lag
+Auf Sizilien hielt sich zudem im Gegensatz zum Mutterland in vielen Städten die Tyrannis als Regierungsform Dionysios I von Syrakus Agathokles von Syrakus und andere
+Hellenistische Zeit <num> bis <num> v Chr
+DateiAlexanderTheGreat Bustjpg Nach der Ermordung Philipps <num> v Chr führte sein Sohn Alexander der Große ein griechisch-makedonisches Heer nach Asien und eroberte in wenigen Jahren mit dem Perserreich ein Weltreich
+Der Alexanderzug bahnte der griechischen Kultur im ganzen damals bekannten Orient den Weg von Ägypten über Mesopotamien und Persien bis zu den Grenzen Indiens und Turkestans
+Nach Alexanders Tod <num> v Chr in Babylon teilten seine Nachfolger die Diadochen in lange währenden Kriegen das Reich unter sich auf
+In allen Teilreichen bildete der Hellenismus in den folgenden Jahrhunderten die prägende Kultur
+Das Zeitalter des Hellenismus kennzeichnet ein nahezu ständiger Kampf der drei Großmächte Ptolemäer Seleukiden und Antigoniden um die Vorherrschaft
+Dennoch wuchs die Bevölkerung im gesamten Mittelmeerraum stetig und ermöglichte so das Wachstum größerer Städte und Metropolen mit Einwohnern über <num> Menschen
+Auch breitete sich in dieser Zeit der Fernhandel bis hin nach China und die Güterproduktion für große städtische Märkte aus Verschiedene Wissenschaften blühten auf bspw in Alexandria
+Zu Beginn des <num> Jahrhunderts v Chr tauchte erstmals Rom als bedeutende Macht in Griechenland auf und dehnte nach und nach seinen Einfluss aus
+<num> v Chr unterstellte das Römische Reich die Mitglieder des unterlegenen Achaiischen Bundes der Provinz Macedonia Korinth als führende Polis wurde zerstört
+Doch blieben viele Poleis wie Athen und Sparta zumindest vorerst formell unabhängig
+Bald darauf folgte der Erwerb Pergamons durch Rom und <num><num> v Chr die Beseitigung der Überreste des Seleukidenreiches
+Als letzter Nachfolgestaat des Alexanderreichs wurde im Jahre <num> v Chr das ptolemäische Ägypten dessen letzte Herrscherin Kleopatra VII war ins Römische Reich eingegliedert
+Damit war die hellenistische Staatenwelt als machtpolitischer Faktor ausgelöscht
+Die griechische Kultur lebte jedoch im Römischen Reich sowie später im Byzantinischen Reich fort
+Römisches Reich
+Nach den Griechen wurden die Römer zu den zweiten Trägern und Vermittlern der antiken Kultur und prägten diese für mehrere hundert Jahre
+Je weiter sie als Eroberer in außeritalische Länder vordrangen desto stärker ließen sie sich von deren Kultur inspirieren und beeinflussen
+Sie adaptierten teilweise lokale Gebräuche
+Literatur Philosophie Kunst Architektur und Alltagskultur der Griechen und der Länder der Levante Waffentechniken der Gallier oder Germanen und religiöse Einflüsse aus Ägypten wurden von den Römern aufgenommen
+Nicht zuletzt durch die kulturelle Ausstrahlung und Heterogenität der Stadt Rom die sich in der römischen Kaiserzeit zur Millionenstadt entwickelte wurden solche Einflüsse im Imperium verbreitet
+Ursprünge Roms
+Rom der Legende nach <num> v Chr gegründet entstand neueren Forschungen zufolge erst gegen Ende des <num> Jahrhunderts v Chr aus dem Zusammenschluss mehrerer dörflicher Siedlungen an einer Furt am Unterlauf des Tibers
+Politisch und kulturell stand Rom lange unter etruskischem Einfluss
+Die Etrusker wiederum unterhielten schon früh Kontakt mit griechischen Kolonisten
+Römische Republik ca <num> bis <num> v Chr
+DateiCt-fororomano<num>jpg Um <num> v Chr befreiten sich die Römer vom etruskischen Stadtkönigtum und bildeten wohl um <num> v Chr eine republikanische Regierungsform aus
+In den Zwölftafelgesetzen die um <num> v Chr entstanden wurden die ersten zivil- straf- und prozessrechtlichen Normen des römischen Rechts festgehalten
+Die Verfassung sah von da an ein Zusammenwirken der drei Institutionen Senat Magistratur und Volksversammlung vor die sich in ihrer Macht theoretisch gegenseitig beschränkten
+Die offizielle Bezeichnung der Republik lautete SPQR für Senatus Populusque Romanus dt Senat und Volk von Rom
+Machtpolitisch dominierte der Senat der sich aus Angehörigen der adligen Familien der Patrizier zusammensetzte und später der plebejischen Patrizier
+Aus ihm gingen auch die Konsuln hervor die beiden auf ein Jahr gewählten obersten Magistrate der Republik
+Das zunächst höchste den nichtadeligen Plebejern zugängliche Amt war das des Volkstribunen der ein Vetorecht gegen Senatsbeschlüsse besaß
+DateiGaius Julius Caesar <num>-<num> BCJPG Mit der Legion entwickelten die Römer eine effektive Streitmacht
+Bis zum Jahr <num> v Chr unterwarfen sie ganz Italien südlich der Poebene
+Mit den Punischen Kriegen gegen die Seemacht Karthago im <num> und <num> Jahrhundert v Chr begann der Aufstieg Roms zur antiken Weltmacht die für die folgenden Jahrhunderte die gesamte Mittelmeerwelt beherrschen sollte
+Nach <num> v Chr nahm Rom zunehmend Einfluss auf die Politik der hellenistischen Großmächte und wurde zur Protektoratsmacht im östlichen Mittelmeerraum
+<num> v Chr wurde das Makedonien der Antigoniden <num> v Chr das Reich der Seleukiden und schließlich <num> v Chr das Ägypten der Ptolemäer römische Provinz
+Die Römische Republik ermöglichte durch die Herstellung von innerem Frieden ein weiteres kontinuierliches Bevölkerungswachstum auch durch die ständige Neugründung von Kolonien in eroberten Ländern
+Durch die Ansiedlung von Veteranen aus den Legionen vorheriger Kriege konnte die Republik zudem einen verlässlichen Einfluss in diesen Ländern gewinnen und gleichzeitig mit einem stetigen Bevölkerungszuwachs neue Gebiete kultivieren
+Handel und Verkehr konnten auch dank der Römerstraßen zunehmen welche zunächst häufig aus militärischen Gründen angelegt wurden und die wachsenden Reichsstädte und Kolonien miteinander verbanden
+Entlang der Straßen entwickelten sich Streckenposten und Marktflecken zu Städten
+Mit diesen infrastrukturellen Neuerungen ging im Reich ein Wachstum der wirtschaftlichen Produktion und somit auch der verfügbaren Steuermittel einher
+Mit dem Wachstum der Republik an Größe Macht und Wohlstand kam es jedoch im Inneren zu einer Reihe von Krisen in denen sich der Kampf der an den überkommenen sozioökonomischen Strukturen festhaltenden Optimaten gegen die auf Reformen drängenden Popularen spiegelte
+In der Epoche der Bürgerkriege erreichte die Krise der späten Römischen Republik ihren Höhepunkt und es zeichnete sich ab dass die Republik als inhaltlich gelebte Staatsform die Erfolge nicht mehr meistern konnte die sie gezeitigt hatte So wurde der Prinzipat möglich also die Umwandlung der Republik in eine Monarchie mit republikanischer Fassade
+Bereits Gaius Iulius Caesar hatte als Diktator auf Lebenszeit dictator perpetuus eine quasi-monarchische Stellung erlangt
+Als erster römischer Kaiser gilt jedoch sein Großneffe und Erbe Augustus dem es gelang mit dem Prinzipat eine dauerhafte monarchische Staatsordnung an die Stelle der zerrütteten Republik zu setzen wobei jedoch die entmachteten Staatsorgane der Republik z B
+der Senat formal noch lange fortbestanden
+Prinzipat <num> v Chr bis <num> n Chr
+DateiStatue-Augustusjpg Das von Augustus errichtete Kaisertum Prinzipat wurde von ihm und seinem Nachfolger Tiberius für rund <num> Jahre sicher geführt
+Augustus bewahrte noch bewusst eine republikanische Fassade während unter Tiberius das Kaisertum zur Normalität wurde
+Unter Caligula Claudius und Nero traten jedoch zeitweilig Zerfallserscheinungen auf
+Nach dem Krisenjahr <num><num> Vierkaiserjahr traten die Flavier Vespasian Titus Domitian die Regierung an die sowohl außen- als auch innenpolitisch insgesamt recht erfolgreich herrschten
+Nach der Ermordung Domitians der <num> einer Verschwörung zum Opfer fiel folgte eine weitere kurze Krise des Herrschaftssystems die jedoch unter den so genannten Adoptivkaisern weitgehend behoben werden konnte
+Das Imperium erlebte seine größte Blüte und Ausdehnung dann auch unter ebendiesen Adoptivkaisern das Kaisertum war auch weiterhin formal nicht erblich in der ersten Hälfte des <num> Jahrhunderts Einer Expansion unter Trajan vor allem im Balkanraum und im Osten gegen das Partherreich folgte eine Rücknahme und Sicherung der Grenzen unter Hadrian
+Bald nach der Mitte des <num> Jahrhunderts n Chr wuchs jedoch der Druck auf die ausgedehnten Reichsgrenzen
+Im Norden und Nordosten bedrängten die Germanen im Osten die Parther die sich trotz mancher Niederlage behaupten konnten das Reich
+Mark Aurel der Philosophenkaiser im Geiste der Stoa sah sich bald nach Übernahme der Herrschaft nahezu ständig zur kriegerischen Verteidigung der Reichsgrenzen genötigt
+Mit seinem Tod endete <num> n Chr ein als Blütezeit betrachtetes Zeitalter des Imperiums
+Nach dem schwachen Commodus der <num> ermordet wurde stabilisierten die Kaiser aus dem Hause der Severer hervorzuheben ist besonders Septimius Severus die Grenzen wenigstens teilweise
+Kaiser Caracalla gewährte <num> mit der Constitutio Antoniniana allen freien Reichsbürgern das Bürgerrecht
+Nach der Ermordung des Severus Alexander <num> kam es jedoch unter den so genannten Soldatenkaisern zur Reichskrise des <num> Jahrhunderts die aber erst um <num> ihren Höhepunkt erreichte
+Dieser Zeitraum war geprägt von raschen Regierungswechseln zeitweiligen und regional unterschiedlichen ökonomischen Problemen zentrifugalen Tendenzen im Inneren zeitweilige Abspaltung des
+Imperium Galliarum
+Verlust mehrerer Provinzen an Palmyra und dem stetig wachsenden Druck auf die Grenzen
+Neben den verschiedenen Germanenstämmen wie den Alamannen und Goten übte nun vor allem das Sassanidenreich im Osten einen enormen Druck aus Nach dem Sturz des letzten Partherkönigs im Jahr <num> bzw <num> erneuerten die Sassaniden das Perserreich und erwiesen sich in der Regel als den Römern gleichwertige Gegner wenngleich auch sie mit einer gefährdeten Grenze konfrontiert waren im spätantiken Zentralasien siehe Iranische Hunnen
+Die Zeit der Soldatenkaiser wird allerdings in der neueren Forschung keineswegs mehr als eine reine Krisenzeit begriffen sondern vielmehr als eine wenngleich teils von Krisensymptomen begleiteten Transformationsphase
+Spätantike <num> bis <num><num> n Chr
+Mit der Einführung der Tetrarchie <num> und zahlreichen inneren Reformen gelang es Kaiser Diokletian seit <num> Kaiser gegen Ende des <num> Jahrhunderts noch einmal das Reich zu stabilisieren
+Diese Zeit der beginnenden Spätantike ist gekennzeichnet von Umbrüchen die zum Teil eine Abkehr von bis dahin wesentlichen Bestandteilen der antiken Kultur darstellten
+Dazu gehört vor allem die von Kaiser Konstantin I initiierte Anerkennung und Privilegierung des Christentums das unter Diokletian noch verfolgt worden war
+Die Hinwendung zu dem neuen Glauben ging schließlich mit der Ablehnung des religiösen Pluralismus der Antike einher
+Ein letzter Versuch die alten Kulte durch die Verbindung mit neuplatonischem Gedankengut wieder zu beleben scheiterte mit dem Tod Kaiser Julians im Jahr <num> alle nachfolgenden Kaiser waren Christen
+Teilweise stießen auch bestimmte Formen der Philosophie auf Ablehnung wenngleich das Christentum nun selbst stark von der griechischen Philosophie geprägt wurde und zwischen <num> und <num> eine massive Transformation durchlief bspw mit dem Ersten Konzil von Nicäa
+Die Platonische Akademie in Athen oft als Hort des Heidentums bezeichnet wurde <num> geschlossen während die bereits christianisierte Schule von Alexandria noch bis zum Beginn des <num> Jahrhunderts bestehen blieb
+Kaiser Valentinian I festigte den Westen des Reiches doch kam es <num> unter seinem Bruder Valens zur Niederlage von Adrianopel und zu einer neuen Krise
+In diesem Zusammenhang gehört das Auftauchen der Hunnen nur eines von zahlreichen Reitervölkern aus der eurasischen Steppenzone die teils eine wichtige Rolle spielten und der Beginn der sogenannten Völkerwanderung
+Kaiser Theodosius I wiederum konnte den Osten des Reiches stabilisieren und war zugleich der letzte Kaiser der de facto über das gesamte Imperium Romanum herrschte
+Er erklärte das Christentum schließlich <num> zur Staatsreligion und verbot alle heidnischen Kulte wie die Olympischen Spiele
+Allerdings lassen sich noch bis mindestens in das <num> Jahrhundert hinein bedeutende heidnische Minderheiten auf dem Boden des Imperiums nachweisen
+DateiJustinian mosaik ravennajpg Nach der faktisch endgültigen Teilung des Reiches unter den beiden Söhnen des Theodosius <num> erwies sich letztlich nur das von Konstantinopel dem früheren Byzantion aus regierte Oströmische Reich auf die Dauer eines weiteren Jahrtausends als lebensfähig
+Es bewahrte viele antike Traditionen unter anderem blieb das Lateinische in dem überwiegend griechischsprachigen Reich noch bis ins <num> Jahrhundert Amtssprache
+Das so genannte Weströmische Reich hingegen zerbrach aufgrund endloser innerer Kriege gepaart mit äußerem Druck siehe Völkerwanderung
+Germanische Kriegerverbände traten an die Stelle der kollabierenden Reichsregierung und ergriffen zunächst als
+foederati
+seit dem <num> Jahrhundert direkt Besitz von weströmischen Provinzen
+Ihre Anführer traten hier oft an die Stelle der römischen Autoritäten
+Rom selbst wurde <num> von den Westgoten und <num> von den Vandalen geplündert von der Millionenstadt der hohen Kaiserzeit schrumpfte sie auf schätzungsweise <num> Einwohner zum Ende des <num> Jahrhunderts
+Die Spätantike sah auch das langsame Verschwinden der klassisch-antiken Stadt
+polis
+bzw
+civitas
+In der Forschung ist umstritten ob es sich hierbei um einen Niedergang oder eher um einen Wandel handelt - diese Frage stellt sich auch für viele andere Aspekte der Epoche z B
+im wirtschaftlichen Bereich wobei viele Provinzen weiterhin aufblühten
+Im Westen das Ostreich war davon nicht betroffen und durchlief erst im <num> Jahrhundert eine Krisenzeit siehe unten lösten sich im <num> Jahrhundert zunehmend die politischen Strukturen auf während das reguläre Heer zumindest nach Ansicht der älteren Forschung immer stärker barbarisiert wurde und die Bedeutung der nichtrömischen
+foederati
+besonders im Westen immer mehr zunahm
+Die geringer werdenden Steuereinnahmen durch den Verlust von Provinzen und Steuermitteln führten dazu dass die Regierung in Ravenna immer hilfloser wurde die kaiserliche Autorität schwand dahin während die eigentliche Macht nun meist bei hohen Militärs wie Aetius oder Ricimer lag die gegeneinander oft blutige Bürgerkriege führten und das Westreich so weiter schwächten
+<num> setzte der General Odoaker der Kommandeur der föderierten Truppen in Italien dann den letzten Westkaiser Romulus Augustulus ab da dieser überflüssig geworden sei und unterstellte sich der nominellen Oberherrschaft des oströmischen Kaisers
+Die Geschichtswissenschaft sah in diesem von den Zeitgenossen nur wenig beachteten Akt früher oft das Ende der Antike
+Heute wird dagegen auch das <num> Jahrhundert noch zur Antike gezählt da vor allem im Osten römisch-antike Strukturen fortbestanden und dem oströmischen Kaiser Justinian <num>-<num> für kurze Zeit noch einmal eine Rückeroberung großer Teile des Westreiches gelang
+Dass diese letztlich dennoch scheiterte hatte auch mit dem Druck zu tun den die Sassaniden seit <num> erneut auf die Ostgrenze des Reiches ausübten siehe auch Römisch-Persische Kriege und Herakleios
+Im Oströmischen Reich lebten antike Kultur und Geisteswelt zwar noch bis weit ins Mittelalter fort
+Die islamische Expansion des <num> Jahrhunderts führte allerdings auch hier zu erheblichen Veränderungen und gilt als der entscheidende Einschnitt der das Ostrom der Spätantike vom Byzantinischen Reich des Mittelalters trennt
+Bedeutung und Nachwirken der Antike
+Antike Traditionen hatten starke und prägende Auswirkungen auf den weiteren Verlauf der Weltgeschichte insbesondere auf die Entwicklung der westlichen Welt die in der Antike ihre Wurzeln hat
+Neuzeitliche Aufklärer Philosophen Staatstheoretiker Wissenschaftler Künstler und andere knüpften immer wieder an die Ionische Naturphilosophie die attische Demokratie das römische Recht den religiösen Pluralismus das antike Schönheitsideal und andere Hinterlassenschaften der Antike an
+Antike Traditionen gerieten auch im Mittelalter nie völlig in Vergessenheit
+In den Klöstern des Abendlandes wurde umfangreiches antikes Schriftgut bewahrt
+Auch die Romidee blieb im Heiligen Römischen Reich lebendig
+Im <num> Jahrhundert kam es zur ersten sogenannten Karolingischen Renaissance
+Auch byzantinische und arabische Gelehrte stützten sich auf antikes Wissen und gaben es indirekt an das mittelalterliche Europa weiter
+Als man im Italien des <num> Jahrhunderts die - meist römischen - Überreste der Antike neu zu schätzen lernte und in der Kunst nachahmte bezeichnete man dies als
+Renaissance
+Die Wiedergeburt der Antike und des antiken Geistes setzte der jahrhundertelangen Dominanz religiösen Denkens in Europa ein Ende und mündete schließlich in das Zeitalter der europäischen Aufklärung und in die Moderne
+Fast alle Ideen der neuzeitlichen Aufklärung haben antike Vorläufer
+Ohne griechische Wissenschaft und Philosophie ohne die damals entstandenen politischen Ideen ohne das römische Recht ohne Architektur und Kunst der Griechen und Römer ist die westliche Kultur der Neuzeit nicht denkbar
+So trat infolge der Arbeiten von Johann Joachim Winckelmann seit dem <num> Jahrhundert die klassische griechische Kunst - oder vielmehr das was man idealisierend für diese hielt - zunehmend ins Zentrum des Interesses
+Im <num> Jahrhundert sprach man im Zusammenhang mit den Arbeiten von Architekten und Künstlern wie Karl Friedrich Schinkel Leo von Klenze und Bertel Thorvaldsen von einer Renaissance der griechischen Antike heute vom Neuhumanismus
+Erst nach dem Zweiten Weltkrieg verlor die griechisch-römische Zivilisation zunehmend die Vorbildfunktion die man ihr in Europa und Nordamerika jahrhundertelang zugesprochen hatte
+Ein entscheidender Einschnitt war hier das Verschwinden des griechischen und stark auch des lateinischen Unterrichtsfaches von den Sekundarschulen
+Ein weiterer Aspekt war dass in der ersten Hälfte des <num> Jahrhunderts Elemente der antiken Tradition von Anhängern totalitärer Ideologien willkürlich aufgegriffen und so zweckentfremdet wurden
+Der Führerkult des faschistischen Regimes in Italien griff direkt auf das antike Rom zurück und knüpfte nach dem Verständnis des Regimes an den Caesarenkult an wobei bereits der Terminus fascismo vom lateinischen Begriff
+fasces
+abgeleitet ist
+Benito Mussolini wurde als Nachfolger des Augustus in eine Reihe mit den römischen Caesaren gestellt und es wurde eine Wiedererrichtung des antiken Römischen Reiches angestrebt
+Auch das NS-Regime in Deutschland orientierte sich teils an antiken Vorbildern so etwa im Zusammenhang mit der ideologisch begründeten Lobpreisung Spartas
+Der Bedeutungsverlust nach dem Ende des Zweiten Weltkrieges hat für die Altertumswissenschaften allerdings immerhin den Vorteil dass nun ein unverstellterer neutraler Blick auf die Antike leichter möglich ist
+Bis heute erhaltene Zeugnisse der Antike sind - neben überlieferten Texten philosophischer literarischer oder historischer Natur - zahlreiche Objekte der griechischen und römischen Kunst von großen Skulpturen bis zur Kleinkunst Töpferei Münzen etc Wichtige Antikensammlungen befinden sich in Rom Athen Neapel Paris London München Sankt Petersburg Wien und Berlin
+Für die Kenntnis des antiken Alltags sind vor allem archäologische Ausgrabungen wie die in Pompeji Olympia Delphi oder Pergamon von Bedeutung
+Quellenlage
+Der Großteil der antiken Literatur und damit auch der Geschichtsschreibung ist nicht erhalten sodass unser Wissen über die Antike durch die Überlieferungslage beeinflusst wird siehe auch Antike Geschichtsschreibung und hinsichtlich der griechischen Geschichtsschreibung die Liste der griechischsprachigen Geschichtsschreiber der Antike
+Es wurde geschätzt dass uns kaum <num>
+der griechischen Literatur überliefert ist Andere Forscher sind noch weit pessimistischer und gehen eher von einer Verlustrate um <num>
+aus
+In Teilen sieht es besonders trostlos aus Archaik Hellenismus in anderen Bereichen etwas besser klassische Zeit Griechenlands sowie Spätantike
+Insgesamt ist die Quellenlage jedoch problematisch man muss in allen Bereichen davon ausgehen dass vieles spurlos verloren ist und sich auch viele Ereignisse und Zusammenhänge unserer Kenntnis entziehen
+Neben den erzählenden Quellen müssen daher natürlich auch Inschriften und Papyri sowie archäologische und numismatische Quellen etc herangezogen werden
+Eine Zusammenfassung mit ausführlichen Angaben bieten die jeweiligen Artikel Geschichtsschreibung u ä in den entsprechenden Lexika siehe unten
+Im Folgenden seien einige der wichtigsten antiken Geschichtsschreiber und ihre oft nur teilweise erhaltenen Texte genannt
+Herodot
+Historien
+Thukydides Der Peloponnesische Krieg
+Xenophon
+Hellenika
+Der Zug der Zehntausend Anabasis
+Polybios Historien
+Diodor Bibliothek
+Sallust Die Verschwörung des Catilina Der Krieg gegen Jugurtha
+Caesar
+Der Gallische Krieg
+Der Bürgerkrieg
+Livius
+Römische Geschichte
+Flavius Josephus Der jüdische Krieg
+Tacitus
+Annalen
+Historien Germania
+Arrian Alexanders des Großen Zug durch Asien
+Sueton Leben der Caesaren
+Cassius Dio Römische Geschichte
+Ammianus Marcellinus Res Gestae
+Anonymus
+Historia Augusta
+Zosimos Neue Geschichte
+Prokop Kriege Bauten und Geheimgeschichte
+Siehe auch die online verfügbaren Quellensammlungen wie LacusCurtius oder das Perseus Project
+Siehe auch
+Portal Altertum
+Verschiedenes
+Persische Architektur
+Geschichte der Geschichtsschreibung
+Rhetorik der Antike
+Bücherverluste in der Spätantike
+Rom
+Römische Religion
+Lateinische Literatur
+Untergang des Römischen Reiches
+Listen
+Liste antiker Stätten
+Liste antiker Ortsnamen und geographischer Bezeichnungen
+Liste der Abkürzungen antiker Autoren und Werktitel
+Quellenausgaben
+Quellenausgaben mit Übersetzungen bieten neben anderen Reihen die Sammlung Tusculum und die Loeb Classical Library
+Eine äußerst wichtige Sammlung der erhaltenen Reste ansonsten verlorener griechischer Geschichtsschreiber stellt der Jacoby dar
+Felix Jacoby
+Die Fragmente der griechischen Historiker FGrHist Weidmann Berlin <num> ff Nachdr Brill Leiden <num>ff ISBN <num>-<num>-<num>-<num> CD-ROM ISBN <num>-<num>-<num>-<num>
+Siehe nun vor allem auch die Neubearbeitung mit englischer Übersetzung und neuem Kommentar
+Brills New Jacoby
+Die Fragmente römischer Historiker sind gesammelt in
+Die frühen römischen Historiker
+und in allerdings nur bis zur Mitte des <num> Jahrhunderts n Chr
+The Fragments of the Roman Historians
+Für die Spätantike sind die Sammlungen
+Kleine und fragmentarische Historiker der Spätantike
+und
+Translated Texts for Historians
+von Bedeutung
+Literatur
+Allgemein Aufgrund der Masse an Fachpublikationen kann an dieser Stelle nur eine sehr beschränkte Auswahl genannt werden
+Das zentrale bibliographische Nachschlagewerk der Altertumswissenschaft stellt immer noch die
+LAnnée philologique
+dar LAnnée Philologique
+Bibliographie critique et analytique de lAntiquité greco-latine hrsg von J Marouzeau und J Ernst Paris <num>ff Kostenlos nutzbar ist zudem die umfangreiche Gnomon-Datenbank
+Ausführliche Angaben sind außerdem entweder den Bibliographien der unten genannten Werke besonders sei dabei auf The Cambridge Ancient History und Oldenbourg Grundriss der Geschichte hingewiesen zu entnehmen oder den Bibliographien die in der ausführlichen HU-Linkliste aufgeführt sind siehe beispielsweise KU Eichstätt kommentiert
+Es sei außerdem auf die hier verlinkten Artikel verwiesen wo sich zahlreiche weiterführende Literaturangaben finden
+Lexika
+Paulys Realencyclopädie der classischen Altertumswissenschaft Pauly-Wissowa RE
+Herausgegeben von Georg Wissowa und anderen in <num> Reihen Stuttgart <num>-<num> ISBN <num>-<num>-<num>-<num> Neudruck ab <num>ff trotz des Alters in seiner Gesamtheit nicht überholtes Grundlagenwerk
+Konrat Ziegler Walther Sontheimer Hans Gärtner Hrsg
+Der Kleine Pauly
+Lexikon der Antike
+KlP <num> Bände
+Druckenmüller Artemis Stuttgart München <num>-<num> ISBN <num>-<num>-<num>-X Nachdruck dtv München <num> hervorragendes Lexikon auf Grundlage der RE jedoch mit verkürzten und neugeschriebenen Artikeln
+Hubert Cancik Helmuth Schneider Hrsg
+Der Neue Pauly
+Enzyklopädie der Antike
+DNP Metzler Weimar Stuttgart <num>-<num> ISBN <num>-<num>-<num>-<num> <num> Bände mit schwankender Qualität der Beiträge
+S Hornblower A Spawforth Hrsg
+The Oxford Classical Dictionary
+OCD
+<num> Auflage
+Oxford University Press Oxford <num> wohl das beste einbändige Lexikon über die Antike mit teils herausragenden Artikeln
+Graham Shipley u a Hrsg The Cambridge Dictionary of Classical Civilization Cambridge <num> aktuelles und gut bebildertes Nachschlagewerk zur klassischen Antike Rezension in
+Carl Andresen und andere Hrsg
+Lexikon der Alten Welt LAW Albatros Düsseldorf <num> ISBN <num>-<num>-<num>-<num> in viele Bereichen veralteter Forschungsstand
+Oliver Nicholson Hrsg
+The Oxford Dictionary of Late Antiquity Oxford University Press Oxford <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelles Fachlexikon zur Spätantike
+Heinrich Beck Herbert Jankuhn Hans Kuhn Kurt Ranke Reinhard Wenskus Hrsg Johannes Hoops Begründer
+Reallexikon der Germanischen Altertumskunde RGA <num> völlig neu bearbeitete und stark erweiterte Auflage
+De Gruyter BerlinNew York <num>-<num> Neubearbeitung des wichtigen Lexikons von Hoops
+Theodor Klauser und andere Hrsg
+Reallexikon für Antike und Christentum RAC Stuttgart <num>ff ISBN <num>-<num>-<num>-<num> noch nicht abgeschlossen besonderes Augenmerk gilt der Spätantike
+Kai Brodersen Bernhard Zimmermann Hrsg Metzler Lexikon Antike <num> überarbeitete und erweiterte Auflage
+J B Mezler Verlag Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Dietrich Klose Hrsg Reclams Lexikon der Antike RLA aufgrund der englischen Ausgabe von Paul Harvey bzw Margaret C Howatson übersetzt von Marie-Luise Gutbrodt Dietrich Klose und Wolfgang Kiehne
+Stuttgart <num>
+Heinz Mikisch Basiswissen Antike
+Ein Lexikon
+Verlag Philipp Reclam jun Stuttgart <num> ISBN <num>-<num>-<num>-<num> sehr knapp
+Einführungen
+Hans-Joachim Gehrke Helmuth Schneider Hrsg Geschichte der Antike <num> erweiterte und aktualisierte Auflage
+Metzler StuttgartWeimar <num> ISBN <num>-<num>-<num>-<num>-<num> grundlegende Einführung
+Hans-Joachim Gehrke Hrsg Die Welt vor <num>
+Frühe Zivilisationen
+Geschichte der Welt Band <num>
+C H Beck München <num> ISBN <num>-<num>
+Rosemarie Günther Einführung in das Studium der Alten Geschichte Paderborn <num> ISBN <num>-<num>-<num>-<num>
+Hartmut Leppin Einführung in die Alte Geschichte München <num> ISBN <num>-<num>-<num>-<num>
+Allgemeine Darstellungen
+Beck Geschichte der Antike <num> Bände
+CH Beck München <num>-<num> sortiert nach Epochendarstellung die jeweiligen Bände sind gut lesbare aktuelle Einführungen in die jeweilige Epoche Elke Stein-Hölkeskamp Das archaische Griechenland
+Die Stadt und das Meer
+München <num>
+Sebastian Schmidt-Hofner Das klassische Griechenland
+Der Krieg und die Freiheit
+München <num>
+Peter Scholz Der Hellenismus
+Der Hof und die Welt
+München <num>
+Wolfgang Blösel Die römische Republik
+Forum und Expansion
+München <num>
+Armin Eich Die römische Kaiserzeit
+Die Legionen und das Imperium
+München <num>
+Rene Pfeilschifter Die Spätantike
+Der eine Gott und die vielen Herrscher
+München <num>
+Blackwell History of the Ancient World Blackwell Oxford u a ebenfalls empfehlenswerte aktuelle Epocheneinführungen Marc Van de Mieroop A History of the Ancient Near East ca <num>-<num> BC <num> Auflage
+<num>
+Jonathan Hall A History of the Archaic Greek World <num> Auflage
+<num>
+P J Rhodes A History of the Classical Greek World <num>
+Robert Malcolm Errington A History of the Hellenistic World <num>
+Stephen Mitchell A History of the Later Roman Empire AD <num>-<num> <num> Auflage
+<num>
+Timothy E Gregory A History of Byzantium <num> Alle Bände bieten einen gut lesbaren und fundierten knappen Überblick mit aktueller Literatur
+Blackwell Companion to the Ancient World Verschiedene Herausgeber
+Blackwell Oxford <num>ff
+Inzwischen sind zahlreiche Bände erschienen bzw in Vorbereitung sie bieten in Form von mehreren relativ knappe Fachaufsätzen einen Einstieg auf Grundlage der aktuellen Forschungslage
+The Cambridge Ancient History Div Hrsg <num> Bände teils in Teilbänden
+<num> Auflage
+Cambridge <num>ff
+Umfassende und sehr wichtige Gesamtdarstellung der Antike
+Die zweite Auflage ist vollständig neubearbeitet worden
+Aloys Winterling Kai Brodersen Martin Jehne Winfried Schmitz Hrsg Enzyklopädie der griechisch-römischen Antike <num> Bände
+Oldenbourg München <num>ff
+Noch nicht abgeschlossene Handbuchreihe der Aufbau ist an der Enzyklopädie deutscher Geschichte orientiert
+Geschichte kompakt Antike Wissenschaftlichen Buchgesellschaft Darmstadt mehrere Bände gute knappe Einführungen mit einem in die Darstellung integrierten Forschungsüberblick
+Werner Dahlheim Die Antike
+Griechenland und Rom von den Anfängen bis zur Expansion des Islam
+Schöningh Verlag Paderborn <num> ISBN <num>-<num>-<num>-<num>
+Robin Lane Fox Die klassische Welt
+Eine Weltgeschichte von Homer bis Hadrian
+Klett-Cotta Stuttgart <num> gut lesbare und verlässliche Überblicksdarstellung bis ins <num> Jahrhundert n Chr
+Wolfgang Schuller Das Erste Europa <num> v Chr-<num> n Chr Handbuch der Geschichte Europas Band <num>
+Ullmer Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Jochen Bleicken u a Hrsg
+Oldenbourg Grundriss der Geschichte Band <num>-<num> München <num> ff versch
+Auflagen
+Dreiteilung jedes Bandes <num> sehr knappe Darstellung <num> Forschungsüberblick und <num> umfassende Bibliographie
+Eckhard Wirbelauer Hrsg Oldenbourg Geschichte Lehrbuch Antike Oldenbourg München <num> ISBN <num>-<num>-<num>-<num> Umfassender und zugleich origineller Einstieg in die antike Geschichte der alle wichtigen Themen abdeckt die Ereignisgeschichte wird aber nur sehr sehr knapp behandelt
+Profile History of the Ancient World Profile London sortiert nach Epochendarstellung aktuelle und gut lesbare Überblickswerke
+Angelos Chaniotis Age of Conquests The Greek World from Alexander to Hadrian <num>
+Kathryn Lomas The Rise of Rome
+From the Iron Age to the Punic Wars
+<num>
+David Potter The Origin of Empire
+Rome from the Republic to Hadrian
+<num>
+Michael Kulikowski The Triumph of Empire
+The Roman World from Hadrian to Constantine
+<num>
+Michael Kulikowski The Tragedy of Empire
+From Constantine to the Destruction of Roman Italy
+geplant für <num>
+Routledge History of the Ancient World Routledge Verlag London
+New York
+Amélie Kuhrt The ancient Near East <num> Bände
+<num> ISBN <num>-<num>-<num>-<num> Band <num> ISBN <num>-<num>-<num>-<num> Band <num> recht umfassende Darstellung der altorientalischen Geschichte bis zu den Achaimeniden
+Robin Osborne Greece in the making <num>-<num> B C <num> ISBN <num>-<num>-<num>-X
+Simon Hornblower The Greek world <num>-<num> B C <num> Auflage
+<num> ISBN <num>-<num>-<num>-<num>-<num> hervorragende Gesamtdarstellung der klassischen Zeit
+Graham Shipley The Greek world after Alexander <num>-<num> B C <num> ISBN <num>-<num>-<num>-<num> mit die beste Gesamtdarstellung des Hellenismus
+Timothy J Cornell The beginnings of Rome
+Italy and Rome from the Bronze Age to the Punic Wars c <num>-<num> B C
+<num> ISBN <num>-<num>-<num>-<num>
+Martin Goodman The Roman world <num> B C-A D <num> <num> ISBN <num>-<num>-<num>-<num>
+David S Potter The Roman empire at Bay AD <num>-<num> <num> ISBN <num>-<num>-<num>-<num> <num> Aufl <num> hervorragende Darstellung die auch soziokulturelle Aspekte mit einbezieht
+Averil Cameron The Mediterranean world in Late Antiquity A D <num>-<num> <num> ISBN <num>-<num>-<num>-<num> <num> Auflage <num> eine ausgezeichnete englische Einführung in die Spätantike
+Klassiker
+Zum Teil veraltet
+Älteren Datums aber bis heute noch grundlegend sind die Darstellungen zur griechischen Geschichte von Karl Julius Beloch Georg Busolt und Eduard Meyer
+Karl Julius Beloch Griechische Geschichte <num> Bände in <num> Teilbände
+Straßburg <num>ff
+<num> überarb
+Auflage
+<num>ff
+Bedeutende aber teilweise umstrittene Darstellung
+Georg Busolt Griechische Geschichte bis zur Schlacht bei Chaeroneia <num> Bände in <num> Perthes Gotha <num>-<num>
+Johann Gustav Droysen Geschichte des Hellenismus Perthes Gotha <num> auf CD-ROM Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+Matthias Gelzer Julius Caesar
+Der Politiker und Staatsmann
+Callwey München <num> <num> Auflage
+Nachdr Steiner Wiesbaden <num> ISBN <num>-<num>-<num>-<num>
+Edward Gibbon Verfall und Untergang des römischen Imperiums <num> Bände dtv München <num> ISBN <num>-<num>-<num>-<num> - Original
+The History of the Decline and Fall of the Roman Empire <num> Bände im Quartoformat
+London <num>-<num> Zum ersten Mal komplette und ungekürzte dt Übersetzung bis zum Ende Westroms die Geschichte von Byzanz ist immer noch ausgespart
+Lesenswert aber inhaltlich bzw hinsichtlich der Wertung veraltet
+Eduard Meyer Geschichte des Altertums <num> Bände <num> Auflage
+Darmstadt <num> orig <num>-<num> online
+Theodor Mommsen Römische Geschichte Weidmann Berlin <num> Nachdr dtv München <num> ISBN <num>-<num>-<num>-<num>
+Klassiker inhaltlich veraltet
+Einzeldarstellungen
+Griechenland - Hellas
+Karl-Wilhelm Welwei Griechische Geschichte
+Von den Anfängen bis zum Beginn des Hellenismus
+Schöningh Paderborn u a <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelle und recht umfassende Darstellung bis ins späte <num> Jahrhundert v Chr
+Detlef Lotze Griechische Geschichte
+Von den Anfängen bis zum Hellenismus
+München <num> ISBN <num>-<num>-<num>-<num>-<num> Siehe auch weitere Bände aus dieser Reihe von Ernst Baltrusch Klaus Bringmann Hartwin Brandt Peter Funke Mischa Meier Karl-Wilhelm Welwei Josef Wiesehöfer etc Jedoch nur für den ersten Überblick geeignet
+Oswyn Murray Das frühe Griechenland München <num> <num> Auflage
+<num> ISBN <num>-<num>-<num>-<num> ausgezeichnete Darstellung der griechischen Frühzeit bis hin zu den Perserkriegen
+John K Davies Das klassische Griechenland und die Demokratie München <num> <num> Auflage
+<num> ISBN <num>-<num>-<num>-<num>
+Christian Meier Athen
+Ein Neubeginn der Weltgeschichte
+Berlin <num> ISBN <num>-<num>-<num>-<num> Gesamtdarstellung Athens im <num> Jahrhundert aber ohne Anmerkungen
+Frank W Walbank Die hellenistische Welt München <num> <num> Auflage
+<num> ISBN <num>-<num>-<num>-<num>
+Hermann Bengtson Griechische Geschichte
+Von den Anfängen bis in die römische Kaiserzeit
+Handbuch der Altertumswissenschaft III
+<num> Reprint der <num> durchgesehen und erg Auflage von <num> München <num> ISBN <num>-<num>-<num>-<num> Als Ausgabe ohne wissenschaftlichen Apparat Griechische Geschichte <num> Auflage
+München <num> ISBN <num>-<num>-<num>-X inhaltlich weitgehend veraltet
+Rom
+Klaus Bringmann Geschichte der römischen Republik München <num> ISBN <num>-<num>-<num>-<num> solide Darstellung
+Karl Christ Geschichte der römischen Kaiserzeit <num> aktual
+Auflage
+München <num> ISBN <num>-<num>-<num>-<num> beste deutsche Darstellung der Kaiserzeit bis Konstantin dem Großen
+Michael Sommer Römische Geschichte I Rom und die antike Welt bis zum Ende der Republik
+Kröners Taschenausgabe Band <num>
+Kröner Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelle und gut lesbare Darstellung der republikanischen Zeit
+Michael Sommer Römische Geschichte II
+Rom und sein Imperium in der Kaiserzeit
+Kröners Taschenausgabe Band <num>
+Kröner Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> aktuelle und gut lesbare Darstellung der Kaiserzeit
+Hermann Bengtson Grundriss der Römischen Geschichte mit Quellenkunde
+Republik und Kaiserzeit bis <num> n Chr
+Handbuch der Altertumswissenschaft III
+<num> München <num> ISBN <num>-<num>-<num>-<num> Inhaltlich inzwischen weitgehend veraltet
+Alexander Demandt Die Spätantike Handbuch der Altertumswissenschaft III
+<num> München <num> <num> überarbeitete Auflage
+München <num> Als inhaltlich gekürzte Ausgabe ohne wissenschaftlichen Apparat Geschichte der Spätantike München <num> ISBN <num>-<num>-<num>-<num>
+Arnold Hugh Martin Jones The Later Roman Empire <num>-<num>
+A Social Economic and Administrative Survey
+<num> Bände Oxford <num> Neudruck in <num> Bände Baltimore <num>
+Umfassendste moderne von einem Autor verfasste Darstellung der Spätantike jedoch durch die Faktendichte teils schwer lesbar und inzwischen vor allem in den Wertungen teilweise überholt
+Scott Fitzgerald Johnson Hrsg The Oxford Handbook of Late Antiquity Oxford u a <num>
+Spezielle Literatur
+Nur in Auswahl
+Es sei auch auf die oben genannten Fachlexika verwiesen
+Allgemein
+Kulturgeschichte der Antiken Welt Verschiedene Verfasser Band <num>ff Mainz <num>ff
+Griechenland - Hellas
+Jochen Bleicken Die athenische Demokratie <num> Auflage
+Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Donald Kagan The Peloponnesian War London <num> ISBN <num>-<num>-<num>-<num> Siehe auch Kagans vierbändige Darstellung des Pelop
+Krieges hier eine intelligente und zusammenfassende Darstellung für ein breiteres Publikum
+Michael Rostovtzeff A Social and Economic History of the Hellenistic World <num> Bände
+<num>
+Michael Stahl Gesellschaft und Staat bei den Griechen <num> Bände Schöningh Paderborn <num> Band <num> ISBN <num>-<num>-<num>-<num> Band <num> ISBN <num>-<num>-<num>-<num> sehr gutes Überblickswerk
+Karl-Wilhelm Welwei Das klassische Athen
+Demokratie und Machtpolitik im <num> und <num> Jahrhundert
+Darmstadt <num> ISBN <num>-<num>-<num>-<num> Detaillierte Darstellung der Politik Athens und dessen Aufstieg zur Hegemonialmacht
+Karl-Wilhelm Welwei Sparta
+Aufstieg und Niedergang einer antiken Großmacht
+Stuttgart <num> ISBN <num>-<num>-<num>-<num> Wohl die beste deutschsprachige Darstellung der Geschichte Spartas
+Karl-Wilhelm Welwei Die griechische Polis
+Verfassung und Gesellschaft in archaischer und klassischer Zeit
+<num> Auflage
+Stuttgart <num> ISBN <num>-<num>-<num>-<num>
+Rom
+Aufstieg und Niedergang der römischen Welt Berlin und New York <num>ff
+Jochen Bleicken Verfassungs- und Sozialgeschichte des Römischen Kaiserreiches <num> Bände
+Paderborn München Wien Zürich <num> Band <num> ISBN <num>-<num>-<num>-<num> Band <num> ISBN <num>-<num>-<num>-<num>
+PersienIran
+Encyclopædia Iranica
+London <num> ff Onlineportal
+Touraj Daryee Hrsg King of the Seven Climes
+A History of the Ancient Iranian World <num> BCE-<num> CE
+UCI Jordan Center for Persian Studies Irvine CA <num>
+Josef Wiesehöfer Das antike Persien
+Von <num> v Chr bis <num> n Chr
+Aktual
+Neuauflage Patmos Düsseldorf <num> ISBN <num>-<num>-<num>-<num> gutes Überblickswerk dort auch weitere Hinweise
+Germanen
+Reallexikon der Germanischen Altertumskunde
+<num> Auflage
+Bruno Bleckmann Die Germanen
+Von Ariovist zu den Wikingern
+CH Beck Verlag München <num>
+Walter Pohl Die Germanen <num> Auflage
+Oldenbourg München <num>
+Walter Pohl Die Völkerwanderung
+Eroberung und Integration
+<num> Auflage
+Kohlhammer Stuttgart u a <num>
+Kelten
+Bernhard Maier Die Kelten
+Ihre Geschichte von den Anfängen bis zur Gegenwart
+<num> vollständig überarbeitete und erweiterte Auflage
+CH Beck München <num>
+Wolfgang Meid Die Kelten <num> verbesserte Auflage
+Reclam Stuttgart <num>
+Skythen Hunnen und andere Steppenvölker
+Christoph Baumer The History of Central Asia Band <num> und <num> IB
+Tauris London <num>ff
+Valerie Hansen The Silk Road
+A History with Documents
+Oxford University Press Oxford <num>
+Hyun Jin Kim The Huns Routledge New York <num>
+St John Simpson Svetlana Pankova Hrsg Scythians
+Warriors of ancient Siberia
+Thames
+Hudson London <num>
+Timo Stickler Die Hunnen CH Beck München <num>
+Indien und China
+Raoul McLaughlin Rome and the Distant East
+Trade Routes to the Ancient Lands of Arabia India and China
+Continnuum LondonNew York <num>
+Walter Scheidel Hrsg Rome and China
+Comparative Perspectives on Ancient World Empires
+Oxford University Press Oxford u a <num>
+Richard Stoneman The Greek Experience of India
+From Alexander to the Indo-Greeks
+Princeton University Press Princeton <num>
+Geschichtsschreibung
+Dieter Flach Römische Geschichtsschreibung <num> Aufl WBG Darmstadt <num>
+Gabriele Marasco Hrsg Greek and Roman Historiography in Late Antiquity
+Fourth to Sixth Century AD
+Leiden u a <num>
+John Marincola Hrsg A Companion to Greek and Roman Historiography <num> Bde Blackwell Oxford <num>
+Klaus Meister Die griechische Geschichtsschreibung Kohlhammer Stuttgart <num>
+Militärgeschichte
+Leonhard Burckhardt Militärgeschichte der Antike C H Beck München <num> ISBN <num>-<num>-<num>-<num>-<num>
+Brian Campbell Lawrence A Tritle Hrsg The Oxford Handbook of Warfare in the Classical World Oxford University Press Oxford <num> ISBN <num>-<num>-<num>-<num>-<num>
+Christian Mann Militär und Kriegführung in der Antike
+Enzyklopädie der griechisch-römischen Antike Band <num>
+Oldenbourg München <num> ISBN <num>-<num>-<num>-<num>-<num>
+Raimund Schulz
+Feldherren Krieger und Strategen
+Krieg in der Antike von Achill bis Attila
+Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Harry Sidebottom Michael Whitby Hrsg The Encyclopedia of Ancient Battles <num> Bände
+Wiley-Blackwell Malden u a <num>
+Religionsgeschichte
+siehe auch
+Reallexikon für Antike und Christentum
+Klaus Bringmann Geschichte der Juden im Altertum
+Vom babylonischen Exil bis zur arabischen Eroberung
+Klett-Cotta Stuttgart <num>
+Werner Dahlheim Die Welt zur Zeit Jesu CH Beck München <num>
+Jörg Rüpke Pantheon
+Geschichte der antiken Religionen
+CH Beck München <num>
+Entdeckungsfahrten
+Raimund Schulz Abenteurer der Ferne
+Die großen Entdeckungsfahrten und das Weltwissen der Antike
+Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Wirtschaftsgeschichte
+Géza Alföldy Römische Sozialgeschichte <num> völlig überarbeitete und aktualisierte Auflage
+Steiner Stuttgart <num>
+Sitta von Reden Antike Wirtschaft
+Enzyklopädie der griechisch-römischen Antike Band <num>
+de Gruyter Oldenbourg Berlin u a <num> ISBN <num>-<num>-<num>-<num>-<num>
+Nachwirkungen
+Peter von Möllendorff Annette Simonis Linda Simonis Hrsg Historische Gestalten der Antike
+Rezeption in Literatur Kunst und Musik
+Der Neue Pauly
+Supplemente
+Band <num>
+Metzler StuttgartWeimar <num> ISBN <num>-<num>-<num>-<num>-<num>
+Ulrich Niggemann Kai Ruffing
+In
+Europäische Geschichte Online hrsg vom Institut für Europäische Geschichte Mainz <num> Zugriff am <num> August <num>
+Weblinks
+Sehr umfangreiche Linkliste der HU Berlin KIRKE - Linkportal Antike wohl das umfassendste dt Angebot LacusCurtius - zahlreiche antike Texte in engl Übersetzung undoder Originaltexte Perseus Project - Quellensammlung zur Antike englisch
+Navicula Bacchi - Materialsammlung Alte Sprachen und Antike Geschichte Umfangreiche und teils sehr empfehlenswerte Materialsammlung bei Liviusorg
+Anmerkungen
+Michael Rostovtzeff hat sogar die Vermutung ausgesprochen die hellenistische Welt habe vor der Dominanz Roms geradezu an der Schwelle einer Industrialisierung gestanden - vgl A Social and Economic History of the Hellenistic World <num> Vgl dazu ausführlich Klaus-Peter Johne Hrsg Die Zeit der Soldatenkaiser <num> Bände Berlin <num> Siehe Hermann Strasburger Umblick im Trümmerfeld der griechischen Geschichtsschreibung In Historiographia antiqua Festschrift für Willy Peremans Leuven <num> S <num>-<num> Trotz all dieser Werke neueren Datums aber haben die klassischen Werke zur griechischen Geschichte von BELOCH BUSOLT und MEYER
+nichts von ihrer Bedeutung verloren und sind für ernsthafte Arbeit immer heranzuziehen Wolfgang Schuller Griechische Geschichte München <num> S <num> Vgl auch Mortimer Chambers Georg Busolt his career in his letters Leiden <num> S VII Donald Kagan The outbreak of the Peloponnesian War IthacaNY <num> S VII Überblick zur neueren Forschung zur Spätantike etwa bei Philip Rousseau Hrsg A Companion to Late Antiquity Malden Massachusetts u a <num>
+DateiAnthony Hope Hawkins by Alfred Ellis amp Waleryjpg Anthony Hope war das Pseudonym von Sir Anthony Hope Hawkins
+<num> Februar <num> in London
+<num> Juli <num> einem britischen Rechtsanwalt und Schriftsteller
+Anthony Hope war ein Sohn von Reverend Edward Connerford Hawkins einem anglikanischen Geistlichen und Jane Isabella Grahame
+Er verließ die Universität Oxford <num> mit einem first-class degree und wurde Anwalt in London
+Er heiratete <num> hatte zwei Söhne und eine Tochter
+Während des Ersten Weltkrieges arbeitete er im Ministry of Information
+<num> wurde er für seine Verdienste während des Krieges zum Ritter geschlagen
+Sein erstes Buch war A Man of Mark <num> später schrieb er The Dolly Dialogues <num>
+Den größten Erfolg hatte er mit The Prisoner of Zenda dt Der Gefangene von Zenda Anschließend verfasste er Rupert of Henzau <num> und viele weitere Bücher
+Literatur
+Weblinks
+Das Ångström
+nach dem schwedischen Physiker Anders Jonas Ångström ist eine Maßeinheit der Länge
+Das Einheitenzeichen ist Å A mit Ring Ein Ångström entspricht dem zehnmillionsten Teil eines Millimeters
+Das Ångström ist keine SI-Einheit
+<num> Å
+<num> fm
+<num> pm
+<num> nm
+<num>-<num> μm
+<num>-<num> mm
+<num>-<num> cm
+<num>-<num> m
+Das Ångström wird insbesondere in der Kristallographie und der Chemie benutzt um mit einfachen Zahlenwerten arbeiten zu können
+So ist <num> Å die typische Größenordnung für Atomradien Abstände von Atomen in Kristallstrukturen und Bindungslängen in Molekülen
+Der Radius isolierter neutraler Atome beträgt zwischen <num> und <num> Å
+Daher wird das Ångström oft als Einheit für Abstände in atomaren Größenordnungen verwendet z B
+für die Dicke sehr dünner Schichten für die Angabe der verwendeten Wellenlänge der Röntgenstrahlung bei ihrer Ermittlung in Röntgenbeugungs experimenten wie der Kristallstrukturanalyse sowie für die Porengröße von stationären Phasen in flüssigchromatographischen Säulen für die Hochleistungsflüssigkeitschromatographie HPLC
+In der Thermodynamik wird die mittlere freie Weglänge der sich bewegenden Moleküle häufig in Ångström angegeben
+Auch in der Optik und der Astronomie wird es zur Angabe einer Wellenlänge genutzt allerdings weniger in deutschsprachigen sondern eher in englischsprachigen Fachpublikationen
+Einen ähnlichen Versuch zu einfach handhabbaren Zahlenwerten zu kommen unternahm <num> Manne Siegbahn mit der Definition der X-Einheit die etwa <num>-<num> m entsprach
+Das Ångström setzte sich aber durch
+Da das Ångström nicht in der Einheitenrichtlinie aufgeführt wird ist es in der EU keine gesetzliche Einheit nach der schweizerischen Einheitenverordnung auch nicht in der Schweiz
+In DIN <num>-<num> ist sie ausdrücklich als nicht mehr zugelassene Einheit aufgelistet
+Darstellung in Computersystemen
+Laut Unicode-Standard soll die Längeneinheit Ångström durch den Großbuchstaben Å U<num>C<num> dargestellt werden
+Unicode enthält zwar auch ein Zeichen namens ANGSTROM SIGN Ångströmzeichen U<num>B Å dieses wurde jedoch lediglich zur Kompatibilität mit älteren Zeichenkodierungsstandards aufgenommen und soll in neu erstellten Texten nicht verwendet werden
+Quellen
+Weblinks
+Duden Großes Fremdwörterbuch ISBN <num>-<num>-<num>-<num>-<num> Eintrag Ångström S <num>
+Das Ampere
+mit Einheitenzeichen A benannt nach dem französischen Mathematiker und Physiker André-Marie Ampère ist die SI-Basiseinheit der elektrischen Stromstärke und zugleich SI-Einheit der abgeleiteten Größe magnetische Durchflutung
+Obwohl man den Nachnamen des Namensgebers mit
+accent grave
+schreibt Ampère wird die SI-Einheit im deutschen und englischen Sprachraum üblicherweise ohne Akzent geschrieben also Ampere
+Definition
+DateiAmpere coulombsvg
+Ein Ampere entspricht einem Fluss von <num> Coulomb C pro Sekunde durch den Leiterquerschnitt
+Das Coulomb ist im Internationales Einheitensystem über die festgelegte Elementarladung
+definiert
+Ein Ampere entspricht dann genau einem Strom von
+Elementarladungen pro Sekunde
+Bei einem Fluss von Elektronen sind dies ca <num> Trillionen Elektronen pro Sekunde
+Ein Fluss von <num> A über eine Spannung von <num> Volt V bedeutet eine Leistung von <num> Watt W
+Historisches
+Bevor das Ampere als internationale Einheit der Stromstärke festgelegt wurde gab es eine Reihe von unterschiedlichen Einheiten und Definitionen
+In Deutschland und einigen anderen Ländern war die Webersche Einheit der Stromstärke in Gebrauch dabei war <num> Weber-Einheit
+<num> Ampere
+In Großbritannien schlug man zunächst vor die Einheit der Stromstärke mit Galvat nach dem italienischen Biophysiker Luigi Galvani zu benennen die in etwa dem heutigen Ampere entsprochen hätte Später wurde ebenfalls eine Weber-Einheit für die Stromstärke eingeführt die aber einen zehnmal so hohen Wert hatte wie die in Deutschland gebräuchliche
+Noch verwickelter wurde es dadurch dass der Name Weber auch für die Einheit der elektrischen Ladung benutzt wurde so dass dann die Stromstärke gleich Weber-EinheitSekunde war
+Zeitweise gab man der Weber-Einheit auch den Namen Farad womit später die Einheit der elektrischen Kapazität benannt wurde
+Stromstärke als Basiseinheit
+Würde man die Stromstärke mit einer abgeleiteten Einheit messen wie das etwa beim CGS-Einheitensystem geschieht so ließen sich die elektrischen Größen durch die Basiseinheiten nur mit nicht ganzzahligen Exponenten ausdrücken
+Um das zu vermeiden wurde schon <num> die Einheit der Stromstärke als weitere Basiseinheit vorgeschlagen
+Definition <num>
+<num> wurde <num> Ampere im Gesetz betreffend die elektrischen Maßeinheiten des Deutschen Kaiserreichs als die Stärke desjenigen Stromes definiert der aus einer wässrigen Silbernitrat-Lösung mittels Elektrolyse in einer Sekunde <num> mg Silber abscheidet
+Das so definierte Ampere ist später als internationales Ampere bezeichnet worden das mit den restlichen Basiseinheiten kompatible dagegen als absolutes Ampere
+Definition <num>
+DateiAmpere-defsvg <num> wurde das Ampere wie folgt über die Lorentzkraft zweier Leiter aufeinander definiert
+<num> A ist die Stärke des zeitlich konstanten elektrischen Stromes der im Vakuum zwischen zwei parallelen unendlich langen geraden Leitern mit vernachlässigbar kleinem kreisförmigem Querschnitt und dem Abstand von <num> m zwischen diesen Leitern eine Kraft von <num><num>-<num> Newton pro Meter Leiterlänge hervorrufen würde
+Mit dieser Definition wurde zugleich der Wert der magnetischen Feldkonstante μ<num> festgelegt
+Neudefinition des Ampere <num>
+Am <num> November <num> wurde auf der <num> Generalkonferenz für Maß und Gewicht beschlossen das Ampere und andere SI-Basiseinheiten mit Wirkung zum <num> Mai <num> neu zu definieren
+Mit dieser Neudefinition des Internationalen Einheitensystems basiert das Ampere auf einer Definition der Elementarladung Seitdem hängt die Definition des Amperes nur mehr von der Definition der Sekunde ab nicht mehr jedoch vom Meter und vom Kilogramm
+Die Neudefinition wurde vorgenommen da diese leichter zu realisieren ist
+Die magnetische Feldkonstante μ<num> ist seitdem eine mit einer Messunsicherheit behaftete Messgröße die experimentell bestimmt werden muss
+Einzelnachweise
+Weblinks
+Ampere-Definition LEIFI
+Ampere Einzelelektronentunneln SET Physikalisch-Technische Bundesanstalt Forschung zum neuen SI
+J G Crowther British Scientists of the Nineteenth Century Routledge
+Kegan Paul London <num> S <num> Wilhelm Jaeger Die Entstehung der internationalen Maße der Elektrotechnik Julius Springer Verlag Berlin <num> S <num>-<num> Gesetz auf WikiSource
+Acre Plural deutsch Acre oder Acres
+Plural acres ist eine von den Britischen Inseln stammende angloamerikanische Maßeinheit zur Flächenbestimmung von Grundstücken und entspricht grob <num> m beziehungsweise <num> Ar
+Neben dem Acre wird im heutigen angloamerikanischen Flächenmaßsystem zur Land- und Grundvermessung praktisch nur noch die Flächeneinheit Square Foot verwendet in den Vereinigten Staaten wird die Größe von Grundstücken allein mit diesen beiden Flächeneinheiten angegeben
+Weit verbreitet sind diese Einheiten auch in Großbritannien Kanada Indien Australien und anderen Commonwealth-Staaten obwohl dort heute ein metrisches Hauptmaßsystem besteht
+Begriff
+Definition
+Heutzutage wird der Acre direkt mit <num> Square Feet definiert weil die zur ursprünglichen Definition verwendeten Längenmaße Furlong
+<num> Fuß und Chain
+<num> Fuß mittlerweile ungebräuchlich sind
+Unter Einbezug der Meile sowie den heutzutage nicht mehr gebräuchlichen Flächenmaßen Rood und Square Rod auch als Square Perch Perch Square Pole Pole bezeichnet ergibt sich die folgende Umrechnung
+Praktische Verwendung
+Der Acre ist das Hauptmaß für Grundstücksflächen
+In der Regel werden nicht mehr als zwei Nachkommastellen angegeben womit eine Genauigkeit von <num> m vorliegt
+Sobald genauere Angaben erforderlich sind beispielsweise bei Bauland wird die Flächeneinheit Square Foot verwendet
+Bei landwirtschaftlich genutzten Grundstücken werden die Flächen in Workable Acre und Non Workable Acre unterteilt
+Damit gemeint sind die tatsächlich nutzbare Fläche und die für landwirtschaftliche Zwecke nicht nutzbare Fläche wie beispielsweise Ödland
+Auch sehr große Grundflächen werden in Acre angegeben beispielsweise <num> ac
+<num> km
+Eine Umrechnung in Quadratmeilen erfolgt in der Regel nicht
+Acre als Grundlage für abgeleitete Einheiten
+Im Bereich der Landwirtschaft bezieht sich der Flächenertrag auf den Acre
+Bei Getreide wird der Ertrag in bushelacre angegeben
+Siehe Hauptartikel Bushel Getreidemaß
+Der Preis für Land aller Arten wird in den Vereinigten Staaten und Kanada in acre angegeben
+Der
+acre-foot
+sowie der acre-inch sind in den Vereinigten Staaten Volumeneinheiten für große Wassermengen beispielsweise beim kommunalen Wasserverbrauch oder bei landwirtschaftlicher Bewässerung
+Geschichte
+Ursprüngliche Definition
+Die Einheit acre von altenglisch æcer Acker Feld bezeichnete ursprünglich den Landstreifen der mit einem Ochsengespann in einem Tag gepflügt werden konnte
+Unter König Eduard I sowie erneut unter Eduard III und Heinrich VIII wurde der Acre gesetzlich als ein Stück Land mit der Länge von <num> Rods oder Perches
+<num> Furlong oder <num> Feet und der Breite von <num> Rods oder Perches
+<num> Feet oder seit <num> <num> Chain beziehungsweise <num> Square Rods Quadratruten bei welcher Grundstücksform auch immer definiert
+Mit seiner Größe von grob <num> Ar ist der Acre typologisch vergleichbar mit dem Morgen dem Tagewerk oder Tagwan dem Joch oder Juchart und dem Mannwerk
+Angloamerikanische Maßreform <num>
+Die weltweit unterschiedlichen angloamerikanischen Längeneinheiten wurden <num> vereinheitlicht
+In den Vereinigten Staaten ergab dies für die bis dahin verwendeten Längenmaße gegenüber den neuen internationalen Längenmaßen eine Vergrößerung um den Faktor <num>
+Bei der Landvermessung hätte dies bei großen Entfernungen zu spürbaren Differenzen geführt
+Bei einer Streckenlänge von beispielsweise <num> km wäre der Unterschied <num> m
+Um die bestehenden Werte nicht ändern zu müssen wurde deshalb in den Vereinigten Staaten das alte Maßsystem - nur für den Zweck der Landvermessung - beibehalten und das bisher verwendete Längenmaß
+Foot
+erhielt die Bezeichnung
+Survey Foot
+In den Vereinigten Staaten basiert die Flächeneinheit Acre auf dem Survey Foot der Zusatz Survey wird in der Regel weggelassen sonst ist der International Foot die Grundlage
+Der auf den US
+Survey Foot
+basierende Acre ist um etwa <num> cm geringfügig größer
+Historische Einheiten
+Obgleich auf den Britischen Inseln die Größe des Acres seit dem Hochmittelalter mit <num> Square Rods definiert war war dessen Fläche je nach Ort und Zeit uneinheitlich da die Längeneinheit Rod oder Perch verschiedenen Fuß-Äquivalenten entsprach
+Erst mit der Neudefinition der Imperial Units durch den Weights and Measures Act von <num> wurde ein für das gesamte Britische Weltreich einheitlicher Acre geschaffen
+Vor der Einführung des Imperial Standard Acre Statute Acre gab es unter anderem den alten schottischen Acre den neuen schottischen Acre auch als Cunningham Acre bezeichnet oder den irischen bzw Plantation Acre
+Beispielsweise hat der Cunningham Acre etwa die <num>-fache Größe der Plantation Acre grob die <num>-fache Größe des heutigen Acres
+Einige dieser veralteten Maße waren teilweise bis ins <num> Jahrhundert gebräuchlich so in abgelegenen Gebieten Irlands
+Literatur
+Herbert Arthur Klein The Science of Measurement
+A Historical Survey
+Dover Publications Mineola NY <num>
+Johann Friedrich Krüger Vollständiges Handbuch der Münzen Maße und Gewichte aller Länder der Erde Verlag Gottfried Basse QuedlinburgLeipzig <num>
+Weblinks
+Einzelnachweise
+Flexion von Acre canoonet abgerufen am <num> Dezember <num> und Rechtschreibung Acre dudende abgerufen am <num> Dezember <num> Oxford English Dictionary Band I Seite <num> f - Vgl ferner Herbert Arthur Klein The Science of Measurement A Historical Survey Dover Publications Mineola NY <num> S <num> Zu Irland vgl
+Apostilb Einheitenzeichen asb ist eine veraltete Einheit der Leuchtdichte selbstleuchtender Körper
+<num> wurde Blondel Einheitenzeichen blondel als weiterer Name vorgeschlagen der Name wurde zum Andenken an den französischen Physiker André-Eugène Blondel gewählt
+Eine Benutzung oder offizielle Festlegung dieses Namens ist derzeit nicht nachweisbar
+Seit <num> ist das Apostilb keine offizielle Einheit mehr
+Es ist eine Untereinheit des Stilb Einheitenzeichen
+und darüber verknüpft mit dem Lambert Einheitenzeichen
+Die entsprechende SI-Einheit ist cdm bzw das Nit
+Weblink
+Luminance Unit Measurement Converter
+Einzelnachweise
+sizescom
+nach Journal of the Optical Society of America volume <num> pages <num>-<num>
+Das oder der Ar in der Schweiz die Are ist eine Flächenmaßeinheit im metrischen System von <num>nbspm<sup><num><sup> mit dem Einheitenzeichen a oft jedoch nicht oder falsch abgekürzt Ar bzw ar
+<num>nbspa ergeben <num>nbspha
+Ein Quadrat mit dem Flächeninhalt von <num> a hat eine Kantenlänge von zehn Metern man spricht daher auch von einem Quadratdekameternbspdam<sup><num><sup>
+Das Ar ist keine SI-Einheit im Gegensatz zum Hektar ist sie nicht einmal zum Gebrauch mit dem SI zugelassen
+In der EU und der Schweiz ist der Ar bzw die Are gesetzliche Einheit für die Angabe der Fläche von Grund- und Flurstücken
+Geschichte
+Im Jahr <num> wurde in Frankreich das Meter als der <num>-millionste Teil des Erdquadranten auf dem Meridian von Paris festgelegt
+Zugleich wurde die Einheit are in Anlehnung an das lateinische Wort ārea Fläche freier Platz für die Fläche von <num> m<num> neu geschaffen
+Sie war anfangs die einzige gebräuchliche metrische Flächeneinheit samt ihren Teilen und Vielfachen Zentiar <num> ca
+<num> m<num> und Hektar <num> ha
+<num> a
+Im Jahr <num> wurde die Maßeinheit unter der Bezeichnung Ar auch in Deutschland amtlich eingeführt
+Vielfache und Teile
+<num> Hektar von Hekto-Ar
+<num> ha
+<num> a
+<num> m<num>
+<num> hm<num>
+<num> m
+<num> m
+<num> Dekar von Deka-Ar
+<num> daa
+<num> a
+<num> m<num>
+<num> Ar
+<num> a
+<num> m<num>
+<num> dam<num>
+<num> m
+<num> m
+<num> Zentiar
+<num> a
+<num> m<num>
+<num> m<num>
+<num> m
+<num> m
+Außer Ar und Hektar sind diese Vielfachen und Teile im deutschen Sprachraum ungebräuchlich und nur noch von historischem Interesse
+Das Dekar wird als Flächenmaß in der bulgarischen Landwirtschaft in Griechenland Stremma in der Türkei und einigen Staaten des Nahen Ostens metrisches Dunam verwendet
+Siehe auch
+Acre Morgen
+Weblinks
+Einzelnachweise In Tabelle <num> der SI-Broschüre <num> Auflage ist das Ar nicht genannt In der <num> Auflage von <num> sind noch beide enthalten Im
+urlhttpwwwbipmorgutilscommonpdfCCU<num>pdf
+wayback<num>
+text<num> Meeting des CCU <num> Seite <num> PDF <num> MB heißt es noch dass beide in Tabelle <num> erscheinen sollen Das Ar wurde dann offenbar als minor change in einem editorial meeting eliminiert auf das im nachfolgenden
+urlhttpwwwbipmorgutilscommonpdfCCU<num>pdf
+wayback<num>
+text<num> Meeting Seite <num> PDF <num> kB Bezug genommen wird C Bopp Die internationale Maß- Gewichts- und Münz-Einigung durch das metrische System Julius Maier Stuttgart <num>
+Arbeit ist eine zielbewusste und sozial durch Institutionen Bräuche abgestützte besondere Form der Tätigkeit mit der Menschen seit ihrer Menschwerdung in ihrer Umwelt zu überleben versuchen
+Zur Anthropologie der Arbeit
+Es ist bereits strittig ob man zielgerichtete körperliche Anstrengung von Tieren zum Beispiel den instinktiven Nestbau oder das andressierte Ziehen eines Pfluges als Arbeit bezeichnen kann
+Die philosophische Anthropologie geht zumeist davon aus dass Arbeit erst im Tier-Mensch-Übergangsfeld erscheint vgl zum Beispiel Friedrich Engels Anteil der Arbeit an der Menschwerdung des Affen MEW <num>
+Dabei wird meist angenommen dass die Resultate menschlicher Arbeit als Gegenstände wie in einem Spiegel dem Menschen sich selbst zeigen so dass er angesichts ihrer des Selbstbewusstseins mächtig wird
+Das könnten aber auch andere menschliche Tätigkeiten bewirken so dass Arbeit gerade in ihren ursprünglichen Formen schwer von anderen menschlichen Überlebensstrategien wie Spiel oder Kunst zu trennen ist
+Seit der Urgeschichte ist so Karl Bücher ein Basiszusammenhang von Arbeit und Rhythmus anzunehmen vgl das Arbeitslied
+Im Vergleich zu modernen Erwerbstätigen hatten Jäger und Sammler laut zahlreichen Studien mehr Zeit zur freien Verfügung
+Siehe hierzu Abschnitt Alltag und Lebenserwartung im Artikel Jäger und Sammler
+Einstellung zur Arbeit Kulturelle Unterschiede
+Die Auffassung welche Tätigkeiten als Arbeit betrachtet werden und welche Einstellung die Menschen dazu haben sind kulturell sehr unterschiedlich und unterliegen einem ständigen sozialen Wandel
+In den industrialisierten Kulturen haben Arbeit und Beruf einen hohen Stellenwert da das marktwirtschaftlich organisierte Wirtschaftssystem und der erwünschte Fortschritt auf leistungswillige Arbeitnehmer angewiesen ist
+Das war nicht immer so Vor der industriellen Revolution lebte ein Großteil der Menschen von autonomer Subsistenzwirtschaft
+Dies wandelte sich dann in kurzer Zeit zu einer stark reglementierten und hierarchisch organisierten Arbeitswelt der von den Arbeitern einen erheblich höheren Zeitaufwand erforderte als die Selbstversorgung
+In dieser Zeit entstand die Bewertung der Arbeit als Leid und Mühsal
+Seitdem haben sich die zeitliche und körperliche Belastung die Entlohnung sowie die rechtliche Stellung der Arbeitnehmer kontinuierlich verbessert
+Andererseits wird heute jedoch viel mehr Flexibilität bezüglich der Fortbildung bis hin zur Umschulung der Arbeitsplätze und -zeiten erwartet
+Im Westen wird Arbeit heute vielfach als notwendiges Übel gesehen welches allerdings Rang und Ansehen garantiert und unter Umständen ein Weg zur Selbstverwirklichung werden kann
+Der fortschreitende Wandel führt dabei zu einer stetig neuen Auseinandersetzung mit dem Stellenwert der Arbeit
+Demgegenüber gibt es Gesellschaften in denen Menschen die von unselbstständiger Lohnarbeit leben ähnlich wie während der Industriellen Revolution im Westen nur geringes Ansehen genießen und ihre Leistung nur widerwillig erbringen weil der Lohn gering ist und die Arbeitszeit einen Großteil des Tagesablaufes bestimmt
+In Ländern wo die Bevölkerung noch vorwiegend autonom von traditionellen Subsistenzformen lebt wird Lohnarbeit nur geschätzt da ihre Bedingungen dem Einzelnen weitaus weniger Möglichkeiten bisweilen auch mehr Freizeit eröffnen als dem eigenständigen Bauern oder Jäger
+Dies gilt auch dort wo die Reziprozität gegenseitige unentgeltliche Hilfe innerhalb einer lokalen Gemeinschaft noch eine größere Rolle spielt als die Geldwirtschaft
+Die selbstbestimmte Arbeit wird hier ungleich höher geschätzt sie wird oftmals begrifflich nicht von der Freizeit unterschieden und gilt nicht als mühevoller Überlebenskampf sondern als sinngebende Lebensaufgabe
+Bei einigen naturverbundenen Ethnien ist die traditionelle Arbeit eine religiöse Handlung die das Bündnis zwischen Menschen Ahnen und Umwelt aufrecht erhält
+Da diese tiefe Bedeutung bei der Lohnarbeit fehlt mangelt es häufig auch an ausreichender Motivation zur Arbeit
+Westliche Arbeitgeber empfinden das als Faulheit oder mangelnde Bereitschaft zur Entwicklung bis hin zur Rückständigkeit
+Dies gilt besonders für streng egalitäre Gesellschaften bei denen jegliche Arbeit negativ gesehen wird weil sie etwa mit Habgier egoistischem Streben oder Reichtum auf Kosten Anderer gleichgesetzt wird
+Wortgeschichte
+Das Wort Arbeit ist gemeingermanischen Ursprungs arbējiðiz got arbaiþs die Etymologie ist unsicher evtl verwandt mit indoeurop
+orbh- verwaist Waise ein zu schwerer körperlicher Tätigkeit verdungenes Kind vgl Erbe evtl auch verwandt mit aslaw
+robota Knechtschaft Sklaverei vgl Roboter
+Im Alt- und Mittelhochdeutschen überwiegt die Wortbedeutung Mühsal Strapaze Not redensartlich noch heute Mühe und Arbeit vgl Psalm <num> lateinisch labor et dolor
+Das französische Wort travail hat eine ähnliche sogar noch extremere Wortgeschichte hinter sich es leitet sich von einem frühmittelalterlichen Folterinstrument ab
+Das italienische lavoro und englische labour amerikanisch labor gehen auf das lateinische labor zurück das ebenfalls primär Mühe bedeutet
+Viele Redensarten sind mit ihr verbunden
+So wurde harte körperliche Arbeit früher als
+Kärrnerarbeit
+bezeichnet und eine Schweinearbeit bedeutet unangenehm viel Arbeit Wer die Arbeit kennt und sich nicht drückt
+der ist verrückt
+Geschichtsschreibung
+Die Geschichtsschreibung der Arbeit begann erst im <num> Jahrhundert zuerst in Frankreich England und den USA zu entstehen
+Eine frühe Ausnahme innerhalb der deutschen Historiker war Karl Lamprecht <num>-<num>
+Ein neueres Buch stammt von Arne Eggebrecht und anderen
+Theoriegeschichte
+Antike
+Aristokratische Autoren wie Xenophon Platon Aristoteles
+und Cicero
+würdigten den Großteil der täglichen Arbeit Handwerker Bauern Kaufleute herab
+Sie galt ihnen insbesondere körperliche Arbeit als Zeichen der Unfreiheit
+Sklaven dúloi und Handwerker bánausoi waren der Notwendigkeit untertan und konnten nur durch diese als unfrei verstandene Arbeit ihre Lebensbedürfnisse befriedigen
+Geistige Arbeit blieb der scholé gespr scholé vorbehalten was etwa schöpferische Muße beschrieb wovon das deutsche Wort Schule herrührt
+DateiIlia Efimovich Repin <num>-<num> - Volga Boatmen <num>-<num>jpg
+Mittelalter
+In Europa blieben - vor allem in der Landwirtschaft - Formen unfreier Arbeit von Männern und Frauen auch Kindern und Alten lange erhalten Fron Lasswirtschaft am stärksten im Russischen Reich im Deutschen Reich wurden deren letztes Überbleibsel die Schollengebundenheit in den beiden Mecklenburgs erst durch die Novemberrevolution <num> beseitigt
+Noch heute existieren in großen Teilen der Welt unterschiedliche Erscheinungsformen unfreier Arbeit von der Arbeitspflicht bis hin zur Arbeitsversklavung und Zwangsarbeit
+Eine positive Bewertung von Arbeit als produktiver Betätigung zur Befriedigung eigener oder fremder Bedürfnisse war im Rittertum und in der Mystik angelegt
+Durch Reformation und Aufklärung rückte sie in den Vordergrund Eine neue Sicht der Arbeit als sittlicher Wert und Beruf als Berufung verstanden des Menschen in der Welt wurde von Martin Luther mit seiner Lehre vom allgemeinen Priestertum ausgeprägt
+Schärfer noch wurde im Calvinismus die Nicht-Arbeit überhaupt verworfen siehe auch Protestantische Ethik
+Neuzeit
+In der Frühphase der Aufklärung wurde Arbeit zum Naturrecht des Menschen erklärt Jean-Jacques Rousseau
+Damit wurde das feudalistische Prinzip der Legitimation kritisiert
+Eigentum entsteht einzig durch Arbeit niemand hat ein von Gott gegebenes Anrecht auf Eigentum
+Güter die nicht durch menschliche Arbeit entstanden sind sind Gemeinbesitz
+Adam Smith unterscheidet produktive und unproduktive Arbeit
+Produktive Arbeit nennt er die Arbeit deren Resultat ein verkäufliches Produkt ist
+Dazu wird nicht nur der eigentliche Wertschöpfungsprozess beim Schmied der Vorgang des Schmiedens selbst gerechnet sondern auch alle Arbeiten die indirekt zur Vervollkommnung des Gutes beitragen beim Schmied das Erhalten der Glut das Pflegen von Hammer und Amboss
+Unproduktiv ist hingegen die Arbeit die nicht in einem verkäuflichen Produkt resultiert zum Beispiel die mütterliche Hausarbeit
+Andere Arbeiten sind von diesem Standpunkt aus nicht unnütz da sie notwendig sind um produktive Arbeit leisten zu können und werden heute zum Beispiel als reproduktiv bezeichnet beispielsweise Beamte Verwalter Soldaten
+Der Frühsozialist Charles Fourier proklamierte <num> ein
+Recht auf Arbeit
+In der deutschen Philosophie Immanuel Kant Johann Gottfried Herder Georg Wilhelm Friedrich Hegel Johann Gottlieb Fichte wird die Arbeit zur Existenzbedingung und sittlichen Pflicht erklärt
+Kant räumte in seiner Anthropologie in pragmatischer Hinsicht <num> <num> jedoch ein dass Faulheit eine Schutzfunktion habe Denn die Natur hat auch den Abscheu für anhaltende Arbeit manchem Subjekt weislich in seinen für ihn sowohl als andere heilsamen Instinkt gelegt weil dieses etwa keinen langen oder oft wiederholenden Kräfteaufwand ohne Erschöpfung vertrug sondern gewisser Pausen der Erholung bedurfte
+Nach Karl Marx Werttheorie ist die menschliche Arbeitskraft als alleinige Kraft fähig das Kapital als eine Ansammlung geronnener Arbeit zu vergrößern Mehrwert zu akkumulieren
+Sie tut dies im Kapitalismus unausweichlich
+Praktisch spiegelt dies wider dass in der Phase der Industrialisierung freie Arbeit augenfällig zur Ware wurde und vorwiegend die düsteren Züge der damaligen Lohnarbeit annahm
+So zum Beispiel in Gestalt der Kinderarbeit des Arbeiterelends der Verelendung der Arbeitsunfälle und -krankheiten der drückenden Akkordarbeit - alles dies sind Merkmale der allgemein so empfundenen Sozialen Frage
+Deren Folgen wurden schon seit Hegel als Entfremdung charakterisiert Der Arbeiter hat zu seinem eigenen Arbeitsprodukt aber auch zu dem Unternehmen für das er arbeitet nur noch das bare Lohnverhältnis und kann dem gemäß nicht mehr stolz auf sie sein - in diesem Spiegel erkennt er sich selbst jedenfalls nicht mehr wieder
+Für Ernst Jünger war Arbeit nicht Tätigkeit schlechthin sondern der Ausdruck eines besonderen Seins das seinen Raum seine Zeit seine Gesetzmäßigkeit zu erfüllen sucht Der Arbeiter Daher kenne Arbeit auch keinen Gegensatz außer sich selbst
+Das Gegenteil von Arbeit sei nicht Ruhe oder Muße da es keinen Zustand gebe der nicht als Arbeit begriffen werden könne
+Neben der produktiven Eigenschaft der Arbeit wird neuerdings Lars Clausen ihre destruktive Seite hervorgehoben am auffälligsten als harte lebensgefährliche Arbeit der Soldaten aber auch bei selbst- mitmenschen- oder umweltzerstörerischer Arbeit ist Destruktives seit je Wesensbestandteil aller Arbeit
+Anders die vernichtende Tätigkeit die alltags als Vandalismus auftreten kann und einen organisatorischen Höhepunkt im KZ hatte
+Arbeit und Fortschritt der Technik
+Der Soziologe Rudi Dutschke und der Politologe Bernd Rabehl meinten <num> in einem Gespräch mit Hans Magnus Enzensberger der technische Fortschritt könne die Erwerbsarbeit in Zukunft erheblich reduzieren Dabei muß man bedenken dass wir fähig sein werden den Arbeitstag auf fünf Stunden zu reduzieren durch moderne Produktionsanlagen dadurch dass die überflüssige Bürokratie wegfällt
+Der Betrieb wird zum Zentrum der politischen Selbstbestimmung der Selbstbestimmung über das eigene Leben
+Man wird also im Betrieb täglich debattieren es wird langsam ein Kollektiv entstehen ein Kollektiv ohne Anonymität begrenzt auf zwei- bis dreitausend Leute die also immer noch eine direkte Beziehung zueinander haben
+In der Zeit der <num>er und <num>er Jahre gab der technische Fortschritt sogar in der calvinistisch geprägten nordamerikanischen Gesellschaft tatsächlich wieder dem Gedanken Raum dass Fortschritt zu mehr Freizeit führen könne
+Zeugnisse für die Hoffnungen gaben die Schöpfungen einer bunten Pop-Kultur mit ihren Science-Fiction-Träumen wie beispielsweise der Zeichentrickserie Die Jetsons in der technikgestütztes Faulenzen ohne moralische Bedenken als Ideal dargestellt werden konnte
+Angesichts global unterschiedlicher Entwicklungen zeigte sich jedoch dass ein Ausruhen auf erreichtem Wohlstand in einer Region als Gelegenheit zum wirtschaftlichen Aufholen in anderen Regionen verstanden wurde
+In jenem Zeitraum wurde besonders in Japan technischer Fortschritt in erster Linie als Weg begriffen große wirtschaftliche Fortschritte zu erzielen
+Bis heute begrenzt somit ein Wettbewerb in dem der verliert der zuerst bremst die Möglichkeit aus technischem und technologischem Fortschritt mehr selbstbestimmte freie Zeit zu gewinnen
+Zudem prägte Robert Solow in der Wirtschaft bereits <num> mit seinem Wachstumsmodell die Auffassung dass technologische Innovation in erster Linie als ein Multiplikator des Faktors Arbeit aufträte womit er in der Dogmengeschichte der Wirtschaft einen Ankerpunkt schuf der bis heute den Raum des Denkbaren gegenüber möglichen Alternativen wirkungsvoll abgrenzt
+So schafft in der heutigen Arbeitswelt technischer Fortschritt dort wo er Freiräume erweitert vorwiegend und sogar mit zunehmender Geschwindigkeit immer neue Arbeit
+Dort wo Technik schon vor Beginn des Industriezeitalters die Menschen von Arbeit befreite wurden sie oft nicht freier sondern arbeitslose Geächtete
+In Deutschland nahm zwischen <num> und <num> das Arbeitsvolumen pro Kopf kontinuierlich um <num> Prozent ab
+Arbeit heute
+Nach wie vor wird Erwerbsarbeit nicht mit Arbeit überhaupt gleichgesetzt
+Wo Arbeit auch heute noch nicht Ware ist sind zwei wesentliche Aspekte hervorzuheben
+Die nach wie vor in sehr vielen Gesellschaften dominante Subsistenzarbeit ist weiterhin die Arbeit die der Mensch verrichtet um seinen Lebensunterhalt zu produzieren und so sein Überleben zu sichern englische Entsprechung Labour
+als Selbstproduktion gibt schöpferische Arbeit - auffällig in den Künsten - in allen Gesellschaften Menschen die Möglichkeit sich selbst zu entfalten sich in ihr wiederzuerkennen englische Entsprechung Work
+In den wohlhabenden Staaten der Welt zu denen auch Deutschland zählt wird die Erwerbsarbeit knapp
+Es findet eine zunehmende Flexibilisierung Virtualisierung Automatisierung und Subjektivierung der Arbeit statt prekäre Arbeitsverhältnisse nehmen zu
+Inhaltlich verschiebt sich die Arbeit immer mehr in den tertiären Sektor Dienstleistungen und in Niedriglohnländer Offshoring zumal da die Jugend- und Langzeit-Arbeitslosigkeit die Arbeit trotz ihres zentral wichtigen Charakters als Überlebenstätigkeit aus dem Feld der Erfahrung Vieler rücken
+In ärmeren Ländern herrschen zugleich - zum Teil - Verhältnisse die mit denen in der Industrialisierungsphase Europas vergleichbar sind Kinderarbeit Billiglohnarbeit und fehlende soziale Absicherung sind dort häufig anzutreffende Bestandteile der Arbeitswelt
+Systematik der Arbeitsverhältnisse
+Dort wo Arbeit für andere verrichtet wird ist nach wie vor der Unterschied bedeutsam
+zwischen den sehr vielfältigen Formen so genannter unentgeltlicher Arbeit d h
+durch viele - in etwa fünf Millionen Jahren aufgetretene - Formen geldlosen sozialen Tauschs der soziale Akteure miteinander verknüpft
+und der historisch erst seit gut drei Jahrtausenden aufgetretenen durch Waren oder Geld entgoltenen entgeltlichen Erwerbsarbeit
+Ein Wandel einer Tätigkeit von der unentgeltlichen zur entgeltlichen Form wird auch als Kommerzialisierung bezeichnet
+Unentgeltliche Arbeit
+Die unentgeltliche Arbeit umfasst also historisch sehr viele Formen die auch heute vorkommen aber nicht immer als Arbeit betrachtet werden
+Beispiele sind
+Tätigkeiten zum Erhalt der Lebensgrundlage und der Fürsorge Subsistenzwirtschaft Haus- und Familienarbeit Care-Arbeit
+der Selbstentfaltung dienende Tätigkeit heute z B
+Anfertigung von Modellbauten als Hobby Wir arbeiten an der Wikipedia
+freiwillige helfende schenkende Arbeit Gefälligkeitsarbeit Ehrenamt siehe auch Bürgerarbeit New Work
+unfreiwillige Arbeit Sklaverei Zwangsarbeit andere Formen sozial erzwungener fremdbestimmter Tätigkeiten Beispiel Zurückschneiden einer Hecke im Interesse der Verkehrssicherheit
+freiwillige allgemein nützliche Ersatzarbeit anstelle von Erwerbsarbeit
+Erwerbsarbeit
+Unter Erwerbsarbeit versteht man eine Arbeitsleistung gegen Entgelt Arbeitslohn im Gegensatz zu unentgeltlicher Arbeit wie Subsistenzarbeit Sklavenarbeit weiblicher Hausarbeit oder ehrenamtlicher Arbeit
+Erwerbsarbeit wird in einem Beschäftigungsverhältnis Lohnarbeit oder in selbständiger und neuerdings auch in scheinselbständiger Form geleistet
+Beispiele sind
+Zu selbständiger bezahlter Arbeit siehe Selbständigkeit Unternehmer Kaufmann Handwerker Freiberuf freie Mitarbeit Werkvertrag
+Siehe auch Ich-AG Scheinselbstständigkeit
+Bei abhängiger Beschäftigung als Arbeitnehmer ist zwischen privatrechtlichen und öffentlich-rechtlichen Beschäftigungsverhältnissen zu unterscheiden
+Wer in der Privatwirtschaft abhängig beschäftigt ist ist Arbeiter oder Angestellter
+Zu privatwirtschaftlichen Beschäftigungsverhältnissen siehe auch Arbeitsrecht Arbeitsvertrag Arbeitsmarkt Arbeitslosigkeit
+Zu irregulären privatwirtschaftlichen Beschäftigungsverhältnissen siehe Minijob Niedriglohn-Job und atypisch Beschäftigte
+Der deutsche Staat beschäftigt in seinem öffentlichen Dienst sowohl Arbeiter und Angestellte privatrechtliches Arbeitsverhältnis mit Arbeitsvertrag als auch Beamte Richter Professoren und Soldaten öffentlich-rechtliches Dienstverhältnis mit Ernennungsurkunde
+Das deutsche Privatrecht unterscheidet hier analog zwischen Werkvertrag der Erfolg wird geschuldet und Dienstvertrag der Dienst wird geschuldet
+Mischformen
+Zu den Mischformen auch als Atypische Arbeit
+bzw Atypische Beschäftigung
+bezeichnet gehören zahlreiche freiwillige oder gesetzlich vorgesehene Arbeiten die gering entgolten werden
+Teils sind die Arbeitenden zur Verrichtung der betreffenden Tätigkeiten rechtlich verpflichtet teils fühlen sie sich ethisch hierzu verpflichtet
+Zu den Mischformen gehören auch solche ehrenamtlichen Tätigkeiten für die eine Aufwandsentschädigung gezahlt wird die über den tatsächlichen Aufwand hinausgeht
+Kritik der Arbeit
+Was die zentrale Stellung der Arbeit in kollektiven Wertsystemen angeht sagen Kritiker der Arbeit unterscheiden sich Staatsformen und Herrschaftsmodelle erstaunlich wenig
+Als Kritiker der Arbeit war Paul Lafargue Autor des Pamphlets Le droit à la paresse Das Recht auf Faulheit <num> in der alten Arbeiterbewegung ein Außenseiter
+Lafargue verstand sich als revolutionärer Sozialist und dementsprechend schätzte er die kapitalistische Arbeitsethik ein
+Die kapitalistische Moral eine jämmerliche Kopie der christlichen Moral belegt das Fleisch des Arbeiters mit einem Bannfluch Ihr Ideal besteht darin die Bedürfnisse des Produzenten auf das geringste Minimum zu reduzieren seine Genüsse und Leidenschaften zu ersticken und ihn zur Rolle einer Maschine zu verurteilen aus der man ohne Rast und ohne Dank Arbeit nach Belieben herausschindet Lafargues Manifest erschien <num> auf Deutsch
+Lafargue zitierte Lessing
+Laß uns faul in allen SachenNur nicht faul zu Lieb und WeinNur nicht faul zur Faulheit sein
+Die radikalen Kritiker der Arbeit lehnen den Arbeitszwang ab - für Reiche wie für Arme
+Damit unterscheiden sie sich von Sozialisten die sich über den Müßiggang der Reichen empören und fordern dass alle arbeiten müssen
+Hintergrund der Ablehnung des Arbeitszwangs ist die reale Möglichkeit der Aufhebung der Arbeit
+Schon Lafargue meinte dass <num> Stunden Arbeit ausreichen müssten
+Aufhebung der Arbeit bedeutet jedoch nicht nur Verringerung der Arbeitszeit durch Automation und Abschaffung der Produktion von Gütern die nur um des Profits willen hergestellt werden
+Unter kapitalistischen Bedingungen sind Arbeitslose wie abhängig Beschäftigte und auch diejenigen die auf das sogenannte Berufsleben vorbereitet werden gleichermaßen dem System der Lohnarbeit unterworfen
+Auch wer freie Zeit hat kann diese nicht frei nutzen sei es weil andere mit denen man etwas zusammen tun möchte arbeiten müssen sei es weil die gesamte Umwelt von kommerziellen Zwängen geprägt ist
+Aufhebung der Arbeit bedeutet dass auch weiterhin notwendige Tätigkeiten wie zum Beispiel die Pflege gebrechlicher Menschen einen anderen Charakter annehmen wenn sie in einem anderen nicht-hierarchischen Kontext ausgeübt werden
+Dass die Menschen ohne den Zwang zu Arbeit einfach nichts tun und verhungern würden ist nach Ansicht der Kritiker der Arbeit nicht zu erwarten da sie ja bereits unter kapitalistischen Bedingungen freiwillig konstruktiv zusammenarbeiten
+Die Tradition der Ablehnung der Arbeit wurde nach dem Zweiten Weltkrieg von einer Gruppe junger Menschen in Paris wiederbelebt
+Unter ihnen war Guy Debord
+Der Slogan Ne travaillez jamais Arbeitet niemals kehrte dann im Pariser Mai <num> wieder
+Die Ablehnung der Arbeit spielte auch in Italien in den Kämpfen der <num>er und <num>er Jahre eine zentrale Rolle
+Der Postanarchist Bob Black rief <num> die Proletarier dieser Welt auf sich zu entspannen da niemand jemals arbeiten solle
+Bob Black versteht sich als Antimarxist und postleftistischer Individual-Anarchist
+Er ruft dazu auf alle Arbeitsplätze so umzugestalten dass sie wie ein Spiel sind
+Er findet es merkwürdig dass die einen sich auf dem Feld abrackern während andere in ihrer Freizeit welche nur das ebenfalls fremdbestimmte und durchorganisierte Gegenstück zur Arbeit sei bei der Gärtnerei entspannen
+Zentral in seiner Kritik ist neben diesem Punkten auch der Charakter der Fremdbestimmtheit der Arbeit ob nun im Staatssozialismus oder im Kapitalismus
+Im Anschluss an Michel Foucault kritisiert er Disziplinierung und die Disziplinargesellschaft und betont die zentrale Rolle der Arbeit bei der Disziplinierung Gefängnisse und Fabriken seien zur selben Zeit entstanden die Schulen seien dafür da Leistungsgedanken und -bereitschaft und Gehorsam einzuüben und es gebe mehr Freiheit in jeder einigermaßen entstalinisierten Diktatur als an einem gewöhnlichen amerikanischen Arbeitsplatz Eine ähnliche Kritik hatte allerdings auch schon Gustav Landauer vorgetragen
+Auch er wollte den Arbeitstag ähnlich neu gestalten
+Von einer deutschen Tradition der Arbeitskritik kann man dennoch kaum reden
+Seit den <num>er Jahren bemüht sich allerdings die wertkritische Gruppe
+Krisis
+um eine Erneuerung der Kritik der Arbeit
+Sie veröffentlichte ein
+Manifest gegen die Arbeit
+Die Krisis versteht sich als postmarxistisch bzw grenzt sie sich ab vom traditionellen Marxismus
+Aktuell in der Kritik der Arbeit ist die Kritik der Identifikation mit der Arbeit als zentralem Element männlicher Identität
+Reportagen Feldforschung und Darstellung der Arbeit in der Literatur
+Im Bereich der Feldforschung wurde eine Studie der Österreichischen Wirtschaftspsychologischen Forschungsstelle berühmt
+Sie hieß
+Die Arbeitslosen von Marienthal
+<num> und beschäftigt sich mit den Folgen plötzlich eintretender Arbeitslosigkeit für eine Dorfgemeinschaft
+Darstellungen und Schilderungen der täglichen Arbeit am unteren Rand der Gesellschaft finden sich innerhalb der Belletristik etwa bei den österreichischen Autoren Franz Innerhofer und Gernot Wolfgruber dem Deutschen Hans Dieter Baroth und bei George Orwell
+Erledigt in Paris und London
+Siehe auch
+Arbeitssoziologie
+Arbeitsmigration
+Arbeit Philosophie
+Arbeiterliteratur
+Literatur
+Bücher
+Sven Rahner Architekten der Arbeit Positionen Entwürfe Kontroversen edition Körber-Stiftung Hamburg <num> ISBN <num>-<num>-<num>-<num>-<num>
+Andrea Komlosy Arbeit
+Eine globalhistorische Perspektive
+<num> bis <num> Jahrhundert
+Promedia Wien <num> ISBN <num>-<num>-<num>-<num>-<num>
+Bob Black Die Abschaffung der Arbeit Löhrbach <num> ISBN <num>-<num>-<num>-<num>
+Harry Braverman Die Arbeit im modernen Produktionsprozeß Campus Verlag Frankfurt am Main u a <num> ISBN <num>-<num>-<num>-<num>
+Karl Bücher Arbeit und Rhythmus Hirzel Leipzig <num>
+Robert Castel Les métamorphoses de la question sociale une chronique du salariat <num>
+deutsch Die Metamorphosen der sozialen Frage eine Chronik der Lohnarbeit Univ-Verlag Konstanz Konstanz <num>
+Lars Clausen Produktive Arbeit destruktive Arbeit Verlag Walter de Gruyter Berlin New York <num> ISBN <num>-<num>-<num>-<num>
+Angelika Ebbinghaus Arbeiter und Arbeitswissenschaft
+Zur Entstehung der Wissenschaftlichen Betriebsführung
+Westdeutscher Verlag Opladen <num> ISBN <num>-<num>-<num>-<num>
+Peter Fleissner Technologie und Arbeitswelt in Österreich ÖGB-Verlag <num> ISBN <num>-<num>-<num>-<num>
+Reimer Gronemeyer Hrsg Der faule Neger
+Vom weißen Kreuzzug gegen den schwarzen Müßiggang
+Rowohlt Reinbek bei Hamburg <num> ISBN <num>-<num>-<num>-<num>
+Reinhard P Gruber Nie wieder Arbeit
+Schivkovs Botschaften vom anderen Leben
+ISBN <num>-<num>-<num>-<num>
+Simon Head The New Ruthless Economy
+Work and Power in the Digital Age
+Oxford UP <num> ISBN <num>-<num>-<num>-<num>
+IG Metall Handbuch Gute Arbeit <num> ISBN <num>-<num>-<num>-<num>-<num>
+Wulf D Hund Stichwort Arbeit Vom Banausentum zum travail attractif
+Distel Verlag Heilbronn <num> ISBN <num>-<num>-<num>-<num>
+Ernst Jünger Der Arbeiter
+Herrschaft und Gestalt
+<num>
+Paul Lafargue
+Das Recht auf Faulheit
+Widerlegung des Rechts auf Arbeit von <num>
+<num> Auflage
+Trotzdem Verlag Grafenau <num> ISBN <num>-<num>-<num>-X
+Severin Müller Phänomenologie und philosophische Theorie der Arbeit
+Band I Lebenswelt - Natur - Sinnlichkeit Karl Alber Freiburg München <num> ISBN <num>-<num>-<num>-<num> Band II Rationalität - Welt - Vernunft Karl Alber FreiburgMünchen <num> ISBN <num>-<num>-<num>-<num>
+David F Noble Maschinenstürmer oder die komplizierten Beziehungen der Menschen zu ihren Maschinen Wechselwirkung-Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>
+Erich Ribolits Die Arbeit hoch
+Berufspädagogische Streitschrift wider die Totalverzweckung des Menschen im Post-Fordismus
+Profil München Wien <num> ISBN <num>-<num>-<num>-<num>
+Holger Schatz Arbeit als Herrschaft
+Die Krise des Leistungsprinzips und seine neoliberale Rekonstruktion
+<num> ISBN <num>-<num>-<num>-<num>
+Helmuth Schneider u a Geschichte der Arbeit
+Vom Alten Ägypten bis zur Gegenwart
+Kiepenheuer
+Witsch Köln <num> ISBN <num>-<num>-<num>-<num>
+Eberhard Straub Vom Nichtstun
+Leben in einer Welt ohne Arbeit
+wjs-Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>
+Wieland Jäger und Kurt Röttgers Hrsg Sinn von Arbeit
+Soziologische und wirtschaftsphilosophische Betrachtungen
+VS Verlag Wiesbaden <num>
+Susanne Hartard Axel Schaffer Carsten Stahmer Hrsg Die Halbtagsgesellschaft
+Konkrete Utopie für eine zukunftsfähige Gesellschaft
+Nomos Verlag Baden-Baden <num> ISBN <num>-<num>-<num>-<num>
+Manfred Füllsack Arbeit UTB Reihe NR<num>
+<num> ISBN <num>-<num>-<num>-<num>-<num>
+S Kinkel M Friedewald B Hüsing u a Arbeiten in der Zukunft Strukturen und Trends der Industriearbeit Studien des Büros für Technikfolgen-Abschätzung beim Deutschen Bundestag <num>
+Edition Sigma Berlin <num>
+Heinz-J
+Bontrup Arbeit und Kapital
+Wirtschaftspolitische Bestandsaufnahme und Alternativen
+In Johannes Rehm Hans G Ulrich Hrsg Menschenrecht auf Arbeit
+Sozialethische Perspektiven
+Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Zeitschriften und Jahrbücher
+Archiv für die Geschichte des Widerstandes und der Arbeit
+Labor History Routledge
+Weblinks
+Themen Neue Arbeitswelt und Geschichte der Arbeit
+Online-Version von Aus Politik und Zeitgeschichte der Bundeszentrale für politische Bildung
+Oliver Kloss
+In Bernd Gehrke Wolfgang Rueddenklau Hrsg Das war doch nicht unsere Alternative Verlag Westfälisches Dampfboot Münster <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Peter-Paul Bänziger
+in
+Zeithistorische ForschungenStudies in Contemporary History <num> <num> S <num>-<num>
+Archiv Bilder der Arbeit Archiv zur Darstellung der Arbeit in der bildenden Kunst
+Museen
+Museum der Arbeit in Hamburg Museum Arbeitswelt in Steyr
+Anmerkungen
+Einzelnachweise
+Sabine Eylert Ursula Bertels Ursula Tewes Hrsg Von Arbeit und Menschen Überraschende Einblicke in das Arbeitsleben fremder Kulturen Waxmann Münster New York <num> Einleitung von Christiana Lütges S <num>-<num> insb <num>-<num> Tripaliare bedeutete ursprünglich jemanden auf dem trepalium zu foltern dieses wurde erstmals im <num> Jahrhundert erwähnt als aus drei hölzernen Stöcken bestehendes Pfählungsinstrument Im zwölften Jahrhundert war mit dem Wort sowohl im Französischen als auch im Spanischen eine schmerzhafte Erfahrung gemeint die ein Mensch ertragen muss erst im <num> Jahrhundert wurde es möglich das Verb trabajar bei der Arbeit als gleichbedeutend mit laborar und sudar zu verwenden - Ivan Illich Selbstbegrenzung Eine politische Kritik der Technik Übersetzung Ylva Eriksson-Kuchenbuch Becksche Verlagsbuchhandlung München <num> ISBN <num>-<num>-<num>-<num> S <num> Originaltitel Tools for Conviviality Harper and Row New York <num> Arne Eggebrecht Jens Flemming Gert Meyer Achatz von Müller Alfred Oppolzer Akoš Paulinyi Helmuth Schneider Geschichte der Arbeit Vom Alten Ägypten bis zur Gegenwart Kiepenheuer
+Witsch Köln <num>Xenophon Oikonomikós <num>Aristoteles Politik <num> b <num> ffDe officiis <num>grundeinkommensblogblogspotcom
+Der aktuelle Beschäftigungsoptimismus in historischer Perspektive <num> November <num>
+Website des Theoriemagazins
+wwwanarchismusat
+krisisorg
+Die atomare Masseneinheit Einheitenzeichen u für
+unified atomic mass unit veraltet amu für
+atomic mass unit ist eine Maßeinheit der Masse
+Ihr Wert ist auf
+der Masse eines Atoms des Kohlenstoff-Isotops <num>C festgelegt
+Die atomare Masseneinheit ist zum Gebrauch mit dem Internationalen Einheitensystem SI zugelassen und eine gesetzliche Maßeinheit
+Sie wird bei der Angabe nicht nur von Atom- sondern auch von Molekülmassen verwendet
+In der Biochemie in den USA auch in der organischen Chemie wird die atomare Masseneinheit auch als Dalton bezeichnet Einheitenzeichen Da benannt nach dem englischen Naturforscher John Dalton
+Die so gewählte atomare Masseneinheit hat die praktisch nützliche Eigenschaft dass alle bekannten Kern- und Atommassen nahe bei ganzzahligen Vielfachen von u liegen die Abweichungen betragen in allen Fällen weniger als <num> u Die betreffende ganze Zahl heißt Massenzahl des Kerns oder Atoms und ist gleich der Anzahl der Nukleonen im Kern
+Definition
+<num> u ist definiert als ein Zwölftel der Masse eines isolierten Atoms des Kohlenstoff-Isotops <num>C im Grundzustand
+Der aktuell empfohlene Wert ist<ref nameuinkg> Wert für u in der Einheit kg
+Die eingeklammerten Ziffern bezeichnen die Unsicherheit in den letzten Stellen des Wertes diese Unsicherheit ist als geschätzte Standardabweichung des angegebenen Zahlenwertes vom tatsächlichen Wert angegeben<ref><ref> Wert für u in der Einheit MeVc<sup><num><sup>
+Die eingeklammerten Ziffern bezeichnen die Unsicherheit in den letzten Stellen des Wertes diese Unsicherheit ist als geschätzte Standardabweichung des angegebenen Zahlenwertes vom tatsächlichen Wert angegeben
+bzw wegen der Masse-Energie-Äquivalenz
+Die Umrechnung in die SI-Einheit Kilogramm ergibt
+bzw
+Da der Kern des <num>C-Atoms <num> Nukleonen enthält ist die Einheit u annähernd gleich der Masse eines Nukleons also eines Protons oder Neutrons
+Deshalb entspricht der Zahlenwert der Atommasse in u annähernd der Massenzahl oder Nukleonenzahl also der Zahl der schweren Kernbausteine des Atoms
+Frühere Definitionen
+Bis <num> war die atomare Masseneinheit definiert als
+der Masse eines Sauerstoff-Atoms
+Dabei bezogen sich die Chemiker auf die durchschnittliche Masse eines Atoms im natürlich vorkommenden Isotopengemisch des Elements O die Physiker aber auf die Masse des Atoms des Hauptisotops <num>O
+Die Differenz zwischen der chemischen Definition und der physikalischen Definition war Anlass eine vereinheitlichte Definition einzuführen
+Über die Verhandlungen in den zuständigen Gremien wird berichtet dass die Chemiker zunächst nicht bereit waren auf die Definition der Physiker mit <num>O einzuschwenken da dies erhebliche Verluste beim Verkauf von chemischen Substanzen zur Folge gehabt hätte
+Schließlich überzeugten die Physiker die Chemiker mit dem Vorschlag <num>C als Basis zu nehmen wodurch der Unterschied zur chemischen Definition nicht nur viel geringer war sondern auch in die richtige Richtung ging und sich positiv auf die Verkaufserlöse auswirken würde
+Zwischen dem neuen und den beiden veralteten Werten der Einheit gilt die Beziehung
+Die Differenz zwischen der alten physikalischen und der heutigen Definition ist auf den Massendefekt zurückzuführen der bei <num>O höher ist als bei <num>C
+Verwendung
+In der deutschen Übersetzung der Broschüre des Internationalen Büros für Maß und Gewicht werden die vereinheitlichte atomare Masseneinheit und das Dalton synonym genannt In den gesetzlichen Regelungen der EU-Richtlinie <num><num>EWG für die Staaten der EU und im Bundesgesetz über das Messwesen in der Schweiz kommt der Ausdruck Dalton nicht vor
+Das Dalton kann als besonderer Name für die atomare Masseneinheit betrachtet werden aber die Bezeichnung Dalton ist weder gesetzlich noch DIN-normgerecht
+Begrifflich gibt es Überlappungen zur molaren Masse sowie zur Molekülmasse die sich in der Praxis deutlich zeigen So wird etwa die Masse großer Moleküle wie Proteine DNA und anderer Biomoleküle mit der atomaren Masseneinheit - meist in Kilodalton - charakterisiert da es zahlenmäßig keine Unterschiede zur Angabe in kgmol gibt
+Sowohl für die atomare Masseneinheit als auch für das Dalton ist die Verwendung von Vorsätzen für dezimale Vielfache und Teile zulässig
+Gebräuchlich sind das Kilodalton <num> kDa
+<num> Da sowie das Megadalton <num> MDa
+<num><num> Da
+Beziehung zur molaren Masse
+Bis zur Neudefinition der SI-Basiseinheiten im Jahr <num> war das Mol als die Stoffmenge definiert die aus ebenso vielen Einzelteilchen besteht wie Atome in <num> Gramm <num>C enthalten sind
+Durch diese Definition der atomaren Masseneinheit und des Mols über dasselbe Atom ein Atom <num>C hatte eine Masse von <num> u ein Mol <num>C hatte eine Masse von <num> g ergab sich für die Masse eines Teilchens in u und dessen molare Masse in gmol exakt der gleiche Zahlenwert
+Beispiel Acetylsalicylsäure Masse eines Moleküls <num> u molare Masse <num> gmol
+Die Avogadro-Konstante NA also die Anzahl Teilchen pro Mol musste nach dieser Definition experimentell bestimmt werden und war mit einer Messunsicherheit behaftet
+Da seit <num> nunmehr der Wert für NA exakt festgelegt ist und somit die Zahl der Teilchen in einem Mol nicht mehr über die Masse des <num>C-Atoms bestimmt wird hat ein Mol <num>C nicht mehr exakt die Masse <num> g allgemein haben nun die Masse eines Teilchens in u und die molare Masse in g nicht mehr exakt denselben Zahlenwert
+Beispiele
+Ein Kohlenstoffatom des Isotops <num>C hat definitionsgemäß die Masse <num> u
+Ein Wasserstoffatom des Isotops <num>H hat die Masse <num> <num> <num> u
+Ein Molekül des bekannten Wirkstoffes Acetylsalicylsäure Aspirin hat eine Masse von <num> u
+Ein Molekül des kleinen Peptidhormons Insulin hat eine Masse von <num> u
+Ein Molekül des Proteins Aktin eines der häufigsten Proteine in Eukaryoten hat eine Masse von ungefähr <num> ku
+Einzelnachweise
+aufgrund der EU-Richtlinie <num><num>EWG in den Staaten der EU bzw dem Bundesgesetz über das Messwesen in der Schweiz Aaldert Wapstra zitiert nach G Audi The History of Nuclidic Masses and of their Evaluation IntJMass SpectrIon Process <num> <num> <num>-<num> arxiv
+Als Anglizismus bezeichnet man einen sprachlichen Ausdruck der aus dem Englischen in eine andere Sprache eingeflossen ist
+Betroffen davon sind alle Bereiche eines Sprachsystems von der Lautung über die Formenlehre Syntax Semantik bis zum Wortschatz sowie die Bereiche Sprachgebrauch und Sprachebene Fachsprache Alltagssprache Slang und anderes
+Findet die Übernahme Akzeptanz von Seiten der Sprachgemeinschaft werden die Ausdrücke als Fremd- und Lehnwort bzw als neue Bedeutung eines deutschen Wortes oder als neue Satzkonstruktion übernommen
+Werden die englischen Einflüsse nicht allgemein akzeptiert etwa weil sie auf einen Jargon oder die Jugendsprache beschränkt sind spricht man von Neudeutsch oder abwertend von Denglisch
+Im Laufe des Generationenwechsels kann sich sowohl diese Wertung als auch der Gebrauch von Anglizismen ändern
+Insbesondere in der Jugendsprache verschwinden viele Ausdrücke mit der nächsten Generation wieder da sie nicht mehr als neu und der Jugend vorbehalten empfunden werden
+Der Begriff Anglizismus umfasst alle englischen Sprachvarietäten Einflüsse speziell aus dem britischen Englisch werden auch Britizismen und solche aus dem amerikanischen Englisch Amerikanismen genannt
+Anglizismen in der deutschen Sprache
+Erscheinungsformen
+Im Deutschen treten Anglizismen am häufigsten auf der lexikalischen Ebene in Erscheinung
+Man kann folgende Phänomene unterscheiden
+Wortentlehnungen Übernahme englischer Lexeme die unterschiedlich stark an das Laut- Schrift- und Grammatiksystem der aufnehmenden Sprache angepasst werden
+So gilt etwa die Mehrzahl die Killer und der Genitiv des Internets als an das deutsche Flexionssystem angepasst
+Auch weitergehende Veränderungen wie Kürzungen kommen vor etwa bei fesch aus engl fashionable
+Lehnübersetzungen Eins-zu-eins-Übersetzungen der Bestandteile des fremden Wortes wie zum Beispiel brainwashing
+Gehirnwäsche
+Lehnübertragungen Übersetzung der Idee hinter der Bildung des fremden Wortes zum Beispiel skyscraper
+Wolkenkratzer nicht Himmelskratzer wie es bei einer Lehnübersetzung zu erwarten wäre
+Lehnbedeutungen Übernahme des Bedeutungsspektrums des fremden Wortes von dem Teilbedeutungen bereits bei einem deutschen Wort zu finden sind zum Beispiel deutsch realisieren im Sinne von etwas bemerken sich einer Tatsache bewusst sein nach englisch realizerealise etwas verwirklichen etwas bemerken sich einer Tatsache bewusst sein keine sinnliche Wahrnehmung im Gegensatz zu to notice
+Ein weiteres Beispiel ist der Held im Sinne des Theaterhelden die Übernahme aus dem Bedeutungsspektrum von hero
+Scheinanglizismen Wortschöpfungen innerhalb einer anderen als englischen Sprachgemeinschaft mit englischen Sprachelementen darunter im Deutschen Handy Basecap oder Service Point Oft existieren solche Wörter oder Wortgruppen auch im Englischen jedoch mit einer anderen Bedeutung falscher Freund
+Das Wort Oldtimer etwa benennt im Deutschen als Scheinanglizismus ein altes Auto engl vintage car veteran car oder classic car während es im Englischen generell einen alten Menschen vergleichbar unserem scherzhaft verwendeten Oldie bezeichnet
+Weitere Übernahmeerscheinungen sind auf anderen Sprachebenen zu verzeichnen
+Lehnsyntax Verwendung von englischer Syntax die im Deutschen nicht üblich ist
+Formenbildung Ebenfalls eine Form des Anglizismus ist die Übernahme englischer Konjugationsformen bei Verwendung ursprünglich englischer Verben in deutschen Sätzen
+Das Partizip Perfekt von Verben wird manchmal mit der Endung -ed gebildet geprinted Dieselbe Endung dringt dann - wohl wegen der Ähnlichkeit zur deutschen Endung -et - vereinzelt auch in die Präsensbildung ein er printed
+Orthografie und Interpunktion Benutzung der englischen statt der deutschen Schreibung zum Beispiel Verwendung der englischen Transkription aus nichtlateinischen Schriften wie der kyrillischen oder der arabischen
+Schreibung mit c in zahlreichen aus dem oder über das Lateinische oder Griechische entlehnten Wörtern wo dieses im neueren Deutsch meist durch k oder z wiedergegeben wird so etwa
+Holocaust
+statt Holokaust
+Die Verwendung der englischen Kommasetzung zu den Anglizismen
+So gibt es im Englischen beispielsweise keine Kommas vor that-dass- und anderen Nebensätzen wohl aber innerhalb von Hauptsätzen z B
+am Satzanfang nach Adverbialen
+Die eindeutige Klassifizierung als Anglizismus ist dabei schwierig
+Leerzeichen in Komposita Industrie Museum vielleicht auch wieder zunehmende Verwendung von Bindestrichen Industrie-Museum
+Aussprache nicht-englischer Wörter oder Namen auf Englisch durch Deutsche zum Beispiel der französischen Wörter
+Pointe Relais
+und
+Revirement der ersten Silbe der Wörter Journalist und Journalismus mit d vorweg wegen Häufigkeit vom Duden anerkannt oder des flämischen Ortsnamens
+Waterloo Hierher gehört auch die englische Aussprache der Abkürzung IT für
+Informationstechnik sogar im deutschen Hörfunk und Fernsehen
+Missverstehen eines gesprochenen französischen Wortes als eines englischen Sie hat ein Fabel statt Faible für die Nation Ebenso Ein Fabel für Regenwürmer soll Charles Darwin gehabt haben
+Anzahl und Häufigkeit
+Sprachwissenschaftliche Untersuchungen der Universität Bamberg stellen anhand von Material aus der Zeitung Die Welt eine Zunahme von Anglizismen in der deutschen Sprache fest So hat sich von <num> bis <num> die Verwendung von Anglizismen
+bei Substantiven verdoppelt
+die Anzahl der Verben ebenfalls zugenommen
+auch Adjektive sind häufiger geworden sterben jedoch auch schnell wieder aus
+Entgegen der allgemeinen Annahme dass es beim Sprachkontakt vorwiegend zur Übernahme von Substantiven komme wurden im untersuchten Zeitraum insgesamt etwa gleich viele Wörter aus jeder dieser drei Wortarten vom Englischen ins Deutsche entlehnt allerdings bleiben die Substantive durchschnittlich länger im Gebrauch erhalten
+Die Anzahl der Anglizismen hat zugenommen ebenso die Häufigkeit mit der diese verwendet werden
+Klassifiziert man die Anglizismen nach Bereichen lässt sich feststellen dass der Bereich Wirtschaft am stärksten gewachsen ist vor allem im Marketing und Vertrieb siehe GemlLauer <num>
+Einzige Ausnahme bildet der Bereich Wissenschaft und Technik in welchem eine Abnahme um den Faktor <num> zu verzeichnen ist
+Insgesamt lässt sich festhalten dass der Gebrauch von Anglizismen in zehn Jahren um den Faktor <num> zugenommen hat
+Hingegen hat die Entlehnungshäufigkeit im Vergleich zum Zeitraum <num>-<num> abgenommen
+Das heißt es werden mehr Anglizismen verwendet die Geschwindigkeit der Übernahme hat aber abgenommen
+Der Grund hierfür könnte ein Sättigungsprozess sein
+In einer weiteren Untersuchung wurde ein großes Textkorpus der Gegenwart <num>-<num> mit insgesamt <num> Lemmata ausgewertet darunter wurden <num>
+<num>
+Anglizismen festgestellt
+Das Textkorpus hat einen Umfang von rund <num> Millionen Token
+einzelne Wortformen darunter <num>
+<num>
+Anglizismen Von den <num> Anglizismen sind <num> <num>
+<num> Token
+<num>
+Substantive <num> <num>
+<num> Token
+<num>
+Adjektive <num> <num>
+<num> Token
+<num>
+Verben und <num> <num>
+<num> Token
+<num>
+Adverbien
+Entwicklung der Anglizismen im Deutschen
+Angaben dazu wann welcher Anglizismus ins Deutsche gelangt ist kann man vor allem aus Herkunftswörterbüchern
+etymologischen Wörterbüchern gewinnen
+Sie haben den Nachteil dass sie nur einen Kernbestand des Wortschatzes enthalten und zwar vor allem den Teil der etymologisch besonders interessant ist
+Es stellt sich also die Frage ob der Trend der Entlehnungen der in einem solchen Wörterbuch nachweisbar ist auch für die Gesamtsprache repräsentativ ist
+Dies muss man sich bewusst machen mangels anderer Möglichkeiten bleibt aber nichts anderes übrig wenn man sich eine Vorstellung von dem Verlauf der Entlehnungen machen will
+Eine solche Untersuchung hat Körner am Beispiel von Duden
+Das Herkunftswörterbuch <num>
+durchgeführt indem sie alle Entlehnungen erfasste für die nach Auskunft dieses Wörterbuchs festgestellt werden kann in welchem Jahrhundert sie aus welcher Sprache ins Deutsche gelangt sind
+Speziell für die aus dem Englischen stammenden Entlehnungen kam Körner zu folgendem Ergebnis
+Das Wörterbuch enthält <num> datierbare Stichwörter darunter <num> Entlehnungen Lehnwörter und Fremdwörter
+Unter den Entlehnungen sind <num> datierbare Anglizismen
+Man sieht dass diese Entlehnungen aus dem Englischen erst recht spät einsetzen und dann aber eine erhebliche Dynamik entwickeln
+Im <num> Jahrhundert erreichen die Anglizismen <num>
+des gesamten erhobenen Wortschatzes beziehungsweise <num>
+der Entlehnungen
+Anpassung an deutsche Sprachgewohnheiten
+Besonders schon vor längerer Zeit entlehnte Wörter haben eine Anpassung der Schreibweise erfahren etwa
+Keks
+gegenüber älterem Cakes
+Bei vor allem über den schriftlichen Verkehr übernommenen Anglizismen kann sich die Aussprache bei gleichbleibendem Schriftbild nach deutschen Aussprachegewohnheiten richten so wird
+Jute
+heute im Deutschen gewöhnlich
+ausgesprochen während ältere Wörterbücher noch die Aussprache
+verzeichnen
+Kritik und Kontroversen
+Eine repräsentative Umfrage
+über die Verständlichkeit von zwölf gebräuchlichen englischen Werbeslogans für deutsche Kunden ergab im Jahr <num> dass einige der Slogans von weniger als <num>
+der Befragten verstanden wurden
+Acht der zwölf untersuchten Unternehmen hätten ihre Werbeslogans seitdem geändert
+<num> störten sich in einer Umfrage der Gesellschaft für deutsche Sprache <num>
+der Befragten an Lehnwörtern aus dem Englischen
+Die Ablehnung war in den Bevölkerungsgruppen am größten die Englisch weder sprechen noch verstehen konnten <num>
+Ablehnung bei der Gruppe der über <num>-Jährigen <num>
+Ablehnung bei ostdeutschen Umfrageteilnehmern
+Die Entwicklung des Englischen zur lingua franca im <num> Jahrhundert beeinflusst die meisten Sprachen der Welt
+Mitunter werden Worte ersetzt oder bei Neuerscheinungen ohne eigene Übersetzung übernommen
+Diese Entwicklung wird vor allem dann skeptisch betrachtet wenn es genügend Synonyme in der Landessprache gibt
+Kritiker merken auch an es handle sich häufig beispielsweise bei Handy im Deutschen um Scheinanglizismen
+Mitunter wird auch eine unzureichende Kenntnis der englischen Sprache für die Vermischung und den Ersatz bestehender Worte durch Scheinanglizismen verantwortlich gemacht
+So sprechen einer Studie der GfK zufolge nur <num> Prozent der deutschen Arbeitnehmer verhandlungssicher Englisch
+In der Gruppe der unter <num>-Jährigen bewerten jedoch über <num> Prozent ihre Englischkenntnisse als gut bis exzellent Für bessere Sprachkenntnisse könne demzufolge effizienterer Englischunterricht beitragen und statt der Ton-Synchronisation von Filmen und Serien solle eine Untertitelung der englischsprachigen Originale mit deutschem Text erfolgen
+Dies würde zugleich zu einer besseren Abgrenzung zwischen den Sprachen und einer Wahrung deutscher Sprachqualität beitragen
+Im Dezember <num> forderte der Europapolitiker Alexander Graf Lambsdorff neben Deutsch die englische Sprache als Verwaltungs- und später als Amtssprache in Deutschland zuzulassen um die Bedingungen für qualifizierte Zuwanderer zu verbessern den Fachkräftemangel abzuwenden und Investitionen zu erleichtern Einer repräsentativen YouGov-Umfrage zufolge würden es <num> Prozent der Deutschen begrüßen wenn die englische Sprache in der gesamten Europäischen Union den Status einer Amtssprache erlangen würde
+Ähnliche Kritik wie gegenüber den Anglizismen traf bereits ab Ende des <num> Jahrhunderts die aus dem Französischen Lateinischen oder Griechischen stammenden Begriffe
+Vereine wie der Allgemeine Deutsche Sprachverein versuchten im Rahmen des deutschen Sprachpurismus diese Begriffe durch deutsche zu ersetzen
+So sind französische lateinische oder griechische Fremdwörter durch deutsche Wortschöpfungen ersetzt worden z B
+Fahrkarte für Billet Abteil für Coupé und Bahnsteig für Perron
+Im Postwesen wurden auf Geheiß Bismarcks vom Generalpostmeister Heinrich von Stephan über <num> französischsprachige Begriffe durch deutsche Neuschöpfungen ersetzt
+Zwar war die damalige Öffentlichkeit empört und man verhöhnte ihn als Generalsprachmeister trotzdem sind Begriffe wie eingeschrieben postlagernd und Empfangsschein heute in den allgemeinen Sprachgebrauch übergegangen und ersetzen die Fremdwörter rekommandiert poste restante und Rezepisse
+Viele Unternehmen setzen Anglizismen in Stellenangeboten bzw -beschreibungen ein
+Kritiker vermuten dass weniger attraktive Stellen dadurch aufgewertet werden sollen Häufig verwendete Begriffe sind Area-Manager weniger als der klassische Abteilungsleiter Facility-Manager Hausmeister
+Key Account Manager
+Betreuer wichtiger Kunden oder
+Case Manager
+ein Fallbearbeiter siehe Fallmanagement
+Um diese Entwicklung zu karikieren wird gelegentlich der Euphemismus WC-Manager Klomann-frau genannt In Frankreich stoßen Lehnwörter und Anglizismen noch stärker auf Kritik und sollen auch durch gesetzgeberische Maßnahmen wie die Loi Toubon eingedämmt werden
+Eine aktive Sprachpolitik wie sie unter anderem in Frankreich und Island betrieben wird um eine Anreicherung der Sprache mit Anglizismen zu unterbinden findet in Deutschland seit Mitte des <num> Jahrhunderts nicht mehr statt
+Der Sprachwissenschaftler Rudolf Hoberg sah <num> keine Bedrohung durch Anglizismen
+Die deutsche Sprache habe schon immer englische Ausdrücke aufgenommen Nach der letzten Duden-Ausgabe haben wir etwa <num> Prozent Anglizismen aber <num> Prozent andere Fremdwörter über die sich die Leute meistens gar nicht aufregen Ebenso lehnt er gesetzliche Regelungen wie Sprachquoten in Frankreich oder Verfassungsänderungen wie in Österreich ab die keine Erfolge zeigten Der Germanist Karl-Heinz Göttert nannte die Aufregung über Anglizismen komisch Sie machen weniger als zwei Prozent des deutschen Wörterschatzes aus
+Da gab und gibt es ganz andere Fremdwortschwemmen
+Das Englische selbst hat im Mittelalter ein Drittel aus dem Französischen entlehnt
+Und die japanische Sprache hat aus dem Chinesischen <num> Prozent übernommen Sie seien ein Beweis dafür dass Nehmersprachen kreativ und nicht knechtisch mit dem Einfluss der Gebersprachen umgehen Er wandte sich gegen eine Leitkultur und kritisierte den Sprachpurismus mit den Worten Schon Jakob Grimm hat sich deshalb gegen den ärgerlichen Purismus gewendet
+Es wäre besser der Verein Deutsche Sprache würde sich auf die Grimmsche Tradition besinnen statt einen Grimm-Preis für Verdienste beim Anglizismen-Kampf zu vergeben
+Auch rechtsextreme Organisationen wie die NPD stören sich oft an Anglizismen und versuchen beispielsweise das nicht allgemein anerkannte Wort Weltnetz statt Internet zu etablieren
+Anglizismen in der französischen Sprache
+Siehe dazu Loi Toubon
+Siehe auch
+Internationalismus Sprache
+Literatur
+Broder Carstensen Ulrich Busse Anglizismen-Wörterbuch der Einfluss des Englischen auf den deutschen Wortschatz nach <num> De Gruyter Berlin
+New York NY <num> ISBN <num>-<num>-<num>-<num>
+Peter Eisenberg Anglizismen im Deutschen
+In Deutsche Akademie für Sprache und Dichtung Union der deutschen Akademien der Wissenschaften Hrsg Reichtum und Armut der deutschen Sprache
+Erster Bericht zur Lage der deutschen Sprache
+De Gruyter Berlin
+Boston MA <num> Seiten <num>-<num>
+ISBN <num>-<num>-<num>-<num>-<num>
+Cristiano Furiassi und Henrik Gottlieb Hrsg Pseudo-English - Studies on False Anglicisms in Europe De Gruyter Berlin
+Boston
+München <num> ISBN <num>-<num>-<num>-<num>-<num>
+Richard Glahn Der Einfluss des Englischen auf gesprochene deutsche Gegenwartssprache
+Eine Analyse öffentlich gesprochener Sprache am Beispiel von Fernsehdeutsch
+<num> durchgesehene Aufl Peter Lang Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num>
+Manfred Görlach Dictionary of European Anglicisms Oxford <num> ISBN <num>-<num>-<num>-<num>
+Wolfgang Müller-Hasemann Das Eindringen englischer Wörter ins Deutsche ab <num> In Karl-Heinz Best Jörg Kohlhase Hrsg Exakte Sprachwandelforschung edition herodot Göttingen <num> ISBN <num>-<num>-<num>-<num> S <num>-<num>
+Rudolf Muhr Anglizismus In Gert Ueding Hrsg Historisches Wörterbuch der Rhetorik
+WBG Darmstadt <num>ff Band <num> <num> Sp <num>-<num>
+Nicole Plümer Anglizismus - Purismus - Sprachliche Identität
+Eine Untersuchung zu den Anglizismen in der deutschen und französischen Mediensprache
+Peter Lang Frankfurt am Main <num> ISBN <num>-<num>-<num>-<num> Dissertation Uni Münster Westfalen philosophische Fakultät <num>
+Peter Schlobinski Anglizismen im Internet in Networx Nr <num> <num> Online PDF kostenlos <num> Seiten <num> KB
+Jan Georg Schneider Von free-floatendem Kapital Hardlinern und Instructions
+Linguistische Anmerkungen zur populären Anglizismenkritik
+In Verein Lingua et opinio e V
+LeO Hrsg Studentische Zeitschrift für Sprache und Kommunikation <num> Dezember <num> online
+Wolfgang Schweickard Glanz und Elend der Sprachpflege der Umgang mit Anglizismen in Frankreich Italien und Deutschland in Wolfgang Dahmen u a Hrsg Englisch und Romanisch
+Romanistisches Kolloquium XVIII
+Tübinger Beiträge zur Linguistik Band <num> Narr Tübingen <num> S <num>-<num> ISBN <num>-<num>-<num>-<num>-<num>
+Stefan Zenklusen Leitsprache Anglotumbdeutsch
+In ders Im Archipel Coolag
+wvb Berlin <num> ISBN <num>-<num>-<num>-<num> gekürzt in Zeitschrift für kritische Theorie Nr <num><num> Jahrgang <num> S <num>f ISBN <num>-<num>-<num>-<num>-<num>
+Weblinks
+Fehlende Sprachloyalität
+Tatsachen und Anmerkungen zur jüngsten Entwicklung des öffentlichen Sprachbewusstseins in Deutschland
+Linguistische Anmerkungen zu einer populären Anglizismen-Kritik PDF <num> kB Thomas Niehr Heinrich-Heine-Universität Düsseldorf <num>
+Anglizismen sind das neue Imponier-Deutsch zeitde <num> Infoportal zu Gebrauch Einfluss und Kritik private Seite
+Einzelnachweise
+Wolfgang Pfeifer et al Etymologisches Wörterbuch des Deutschen <num> Aufl Berlin <num> p <num> Dieter HerbergMichael KinneDoris Steffens Neuer Wortschatz Neologismen der <num>er Jahre im Deutschen BerlinNew York <num> Broder CarstensenUlrich Busse Anglizismen-Wörterbuch der Einfluss des Englischen auf den deutschen Wortschatz nach <num> Band <num> A-E BerlinNew York <num> p <num> Stephanie Bohmann Englische Elemente im Gegenwartsdeutsch der Werbebranche Tectum Verlag <num> ISBN <num>-<num>-<num>-<num>-<num> Frank Puscher Oberflächliche Fehler In ct <num><num> S <num> zweiter Absatz Sie wollen nicht gewertet sondern gevoted werden Sie möchten dass man sie diggt ihnen followed Britta Baas und Bettina Röder in Publik-Forum <num><num> Seite <num> Annett Stein im General-Anzeiger Bonn vom <num> Dezember <num> Journal Seite <num> Svetlana Burmasova
+PDF <num> MB in Beiträge zur Linguistik Band <num> University of Bamberg Press Bamberg <num> a S <num>ff b S <num> c S <num> Peter Eisenberg Anglizismen im Deutschen In Deutsche Akademie für Sprache und Dichtung Union der deutschen Akademien der Wissenschaften Hrsg Reichtum und Armut der deutschen Sprache Erster Bericht zur Lage der deutschen Sprache De Gruyter BerlinBoston <num> Seiten <num>-<num> Bezug Seite <num> ISBN <num>-<num>-<num>-<num>-<num> Peter Eisenberg Anglizismen im Deutschen In Deutsche Akademie für Sprache und Dichtung Union der deutschen Akademien der Wissenschaften Hrsg Reichtum und Armut der deutschen Sprache Erster Bericht zur Lage der deutschen Sprache De Gruyter BerlinBoston <num> Seiten <num>-<num> Bezug Seite <num> ISBN <num>-<num>-<num>-<num>-<num> Duden Das Herkunftswörterbuch Bibliographisches Institut MannheimLeipzigWienZürich <num> ISBN <num>-<num>-<num>-<num> Helle Körner Zur Entwicklung des deutschen Lehn-Wortschatzes In Glottometrics <num> <num> Seite <num>-<num> Tabelle für die Anglizismen Seite <num> weitere Angaben <num>f Der Prozess verläuft wie bei den Entlehnungen aus anderen Sprachen auch gesetzmäßig nach den Piotrowski-Gesetz Körners Beitrag enthält ähnliche Tabellen zur Entwicklung des Gesamtwortschatzes und der Entlehnungen aus dem Lateinischen Französischen Niederdeutschen Italienischen Griechischen Niederländischen Slawischen Spanischen und Rotwelschen Weitere Auswertungen ganzer etymologischer Wörterbücher Karl-Heinz Best Gabriel Altmann Untersuchungen zur Gesetzmäßigkeit von Entlehnungsprozessen im Deutschen In Folia Linguistica Historica <num> <num> Seite <num>-<num> zu Duden Etymologie <num> und Katharina Ternes Entwicklungen im deutschen Wortschatz In Glottometrics <num> <num> Seite <num>-<num> zu Kluge Etymologisches Wörterbuch der deutschen Sprache <num> Auflage <num> Zusammenfassung der Endmark-Studie Studie der Gesellschaft für deutsche Sprache
+Deutsche sprechen schlecht Englisch Studie der GfK Die Zeit <num> Juni <num> Sprachen lernen Fernsehen auf Englisch Die Zeit <num> April <num> Berliner Behörden machen es internationalen Start-ups nicht leicht Tagesspiegel <num> April <num> Englisch muss unsere Verwaltungssprache werden Die Welt Kommentar von Alexander Graf Lambsdorff <num> Dezember <num> Umfrage Mehrheit der Deutschen für Englisch als zweite Amtssprache YouGov Meinungsforschungsinstitut <num> August <num> Ludwig Reiners Stilkunst Ein Lehrbuch deutscher Prosa <num> Auflage CHBeck München <num> S <num> ISBN <num>-<num>-<num>-<num>
+RP online vom <num> Oktober <num>
+Spiegel Online vom <num> November <num>
+NPD-Blog <num> März <num>
+Die Welt <num> August <num> booksgooglede
+DateiAstronomermoonjpg DateiJohannesVermeer-TheAstronomer<num>jpg DateiGalileoarp<num>pixjpg Ein Astronom von
+ástron Stern Gestirn und νόμος nómos Gesetz ist eine meist akademisch gebildete Person die sich wissenschaftlich mit der Astronomie beschäftigt
+Haupttätigkeit der Astronomen
+Beschränkt man den Begriff Astronom auf jene Wissenschaftler die sich hauptberuflich der Astronomie widmen dann sind meist zwei der folgenden Tätigkeiten Gegenstand des Berufs
+wissenschaftliche Forschung auf dem Gebiet Astronomie insbesondere in der Astrophysik Astrometrie Kosmologie oder im Bereich des Planetensystems beziehungsweise der Raumfahrt
+Die Arbeit kann im Beobachten bestehen in deren Analyse
+Lehrtätigkeit an einer Universität als Hochschulprofessor oder -assistent
+Entwicklung von Messinstrumenten oder Computerprogrammen
+Leitung undoder Verwaltung von Einrichtungen für Forschung und Entwicklung bzw von großen Projekten - etwa bei der ESA oder NASA
+Der Beruf des Fachastronomen setzt im Regelfall ein Hochschulstudium der Astronomie oder verwandter Naturwissenschaften voraus etwa ein Diplom der Physik oder Astronomie nur in Österreich manchmal auch Studienabschlüsse aus Mathematik Geodäsie Aeronautik und anderen
+Das Verfassen einer Dissertation schließt sich in den meisten Fällen an denn die abgeschlossene Promotion gilt oft als Einstellungsvoraussetzung
+Gewandeltes Berufsbild
+Das Berufsbild des Astronomen hat sich in den letzten Jahrzehnten stark gewandelt
+In der Vergangenheit beobachteten Astronomen überwiegend den Himmel mittels optischer Teleskope an Sternwarten
+Heute arbeiten die meisten Astronomen an sehr spezialisierten Fragestellungen und überwiegend am Computer
+Sie verwenden elektromagnetische Signale aus allen Wellenlängenbereichen von der kurzwelligen Gammastrahlung bis zu den längsten Radiowellen
+Viele Messdaten werden auch über das Internet verbreitet - insbesondere bei regelmäßigen internationalen Messkampagnen wie im IVS - beziehungsweise vom Netz übernommen
+Daher arbeiten Astronomen heute kaum mehr am Fernrohr selbst sondern nur einen vergleichsweise kurzen Teil ihrer Arbeitszeit in den Kontrollräumen der Sternwarten
+Die dort gewonnenen Daten werden meist außerhalb der Nachtdienste ausgewertet und aufbereitet
+Immer mehr gewinnt das so genannte service mode observing Beobachtung auf Abruf an Bedeutung es werden nur Beobachtungsziel und -art angegeben werden während die Beobachtungen unabhängig oder automatisiert an den Teleskopen beziehungsweise von Erdsatelliten durchgeführt werden
+Fach- und Amateurastronomen
+Da viele Studenten des Faches später auf anderen Gebieten arbeiten hängt es von ihrem Selbstverständnis ab ob sie sich auch weiterhin als Astronom bezeichnen
+Inwieweit wissenschaftlich tätige Amateurastronomen als Astronomen im eigentlichen Sinn zu nennen sind ist ebenfalls offen
+Besonders in früheren Jahrhunderten ist eine Trennung zwischen Fachastronom und Amateur wenig zweckmäßig wie etwa das Beispiel von Wilhelm Olbers zeigt
+Da die Astronomie nach wie vor eine Wissenschaft ist die auch im professionellen Bereich von einzelnen und kleinen Forschungsgruppen geprägt ist haben auch Amateure mit der entsprechenden Begabung und Ausrüstung die Möglichkeit mitzuwirken
+Amateure sind oft dort erfolgreich wo eine kontinuierliche Beobachtung notwendig ist aber wegen der Kosten durch Großteleskope kaum professionell machbar ist etwa die Asteroiden- und Kometenüberwachung oder auf dem Gebiet veränderlicher Sterne sowie der Astrometrie
+Dienstzeit
+Da Astronomen naturgemäß - wenn auch durch die moderne Beobachtungs- und Informationstechnik nicht mehr so ausgeprägt wie früher - ihre Tätigkeit in der Nacht ausüben erfordert die Arbeit eines Berufsastronomen klare Regelungen zur Dienstzeit
+Die Zeiten des astronomischen Schlafmangels über die auch berühmte Astronomen manchmal in ihren Briefen oder Berichten geklagt haben sind allerdings größtenteils vorüber
+Moderne Sternwarten sind meistens mit Technologien ausgerüstet die ein gewisses Maß an Fernbedienung erlauben oder sogar international anbieten wie z B
+einige Observatorien auf Hawaii oder ESO-Sternwarten wie in Chile
+Da visuelle Messungen oder Kontrollen nur mehr selten erforderlich sind und elektro-optische Sensoren grundsätzlich auch eine Funktionskontrolle über EDV oder über das Internet erlauben werden durchgehend nächtliche Arbeitszeiten zunehmend seltener
+Siehe auch
+Liste von Astronomen Liste von Astronominnen Physiker Mathematiker Geschichte der Astronomie Priesterastronom
+Weblinks
+Zeittafel der bedeutendsten Astronomen und ihrer Erkenntnisse
+DateiAlan Turing az <num>-as évekbenjpg DateiAlan Turing signaturesvg Alan Mathison Turing OBE FRS
+<num> Juni <num> in London
+<num> Juni <num> in Wilmslow Cheshire war ein britischer Logiker Mathematiker Kryptoanalytiker und Informatiker
+Er gilt heute als einer der einflussreichsten Theoretiker der frühen Computerentwicklung und Informatik
+Turing schuf einen großen Teil der theoretischen Grundlagen für die moderne Informations- und Computertechnologie
+Als richtungsweisend erwiesen sich auch seine Beiträge zur theoretischen Biologie
+Das von ihm entwickelte Berechenbarkeitsmodell der Turingmaschine bildet eines der Fundamente der Theoretischen Informatik
+Während des Zweiten Weltkrieges war er maßgeblich an der Entzifferung der mit der Enigma verschlüsselten deutschen Funksprüche beteiligt
+Der Großteil seiner Arbeiten blieb auch nach Kriegsende unter Verschluss
+Turing entwickelte <num> eines der ersten Schachprogramme dessen Berechnungen er mangels Hardware selbst vornahm
+Nach ihm benannt sind der Turing Award die bedeutendste Auszeichnung in der Informatik sowie der Turing-Test zum Überprüfen des Vorhandenseins von künstlicher Intelligenz
+Im März <num> wurde Turing wegen seiner Homosexualität die damals noch als Straftat verfolgt wurde zur chemischen Kastration verurteilt Turing erkrankte in Folge der Hormonbehandlung an einer Depression und starb etwa zwei Jahre später durch Suizid
+Im Jahr <num> sprach der damalige britische Premierminister Gordon Brown eine offizielle Entschuldigung im Namen der Regierung für die entsetzliche Behandlung Turings aus und würdigte dessen außerordentliche Verdienste während des Krieges eine Begnadigung wurde aber noch <num> trotz einer Petition abgelehnt
+Am Weihnachtsabend dem <num> Dezember <num> sprach Königin Elisabeth II posthum ein Royal Pardon Königliche Begnadigung aus
+Leben und Wirken
+Kindheit und Jugend
+DateiAlan Turing Aged <num>jpg Alan Turings Vater Julius Mathison Turing war britischer Beamter beim Indian Civil Service
+Er und seine Frau Ethel Sara geborene Stoney wünschten dass ihre Kinder in Großbritannien aufwachsen
+Deshalb kehrte die Familie vor Alans Geburt aus Chatrapur damals Britisch-Indien nach London-Paddington zurück wo Alan Turing am <num> Juni <num> zur Welt kam
+Da der Staatsdienst seines Vaters noch nicht beendet war reiste dieser im Frühjahr <num> erneut nach Indien wohin ihm seine Frau im Herbst folgte
+Turing und sein älterer Bruder John wurden nach St Leonards-on-the-Sea Hastings in die Familie eines pensionierten Obersts und dessen Frau in Pflege gegeben
+In der Folgezeit pendelten die Eltern zwischen England und Indien bis sich Turings Mutter <num> entschied längere Zeit in England zu bleiben und die Söhne wieder zu sich nahm
+Schon in frühester Kindheit zeigte sich die hohe Begabung und Intelligenz Turings
+Es wird berichtet dass er sich innerhalb von drei Wochen selbst das Lesen beibrachte und sich schon früh zu Zahlen und Rätseln hingezogen fühlte
+Im Alter von sechs Jahren wurde Turing auf die private Tagesschule St Michaels in St Leonards-on-the-Sea geschickt wo die Schulleiterin frühzeitig seine Begabung bemerkte
+<num> im Alter von <num> Jahren wechselte er auf die Sherborne School in Dorset
+Sein erster Schultag dort fiel auf einen Generalstreik in England
+Turing war jedoch so motiviert dass er die <num> Kilometer von Southampton zur Schule allein auf dem Fahrrad zurücklegte und dabei nur einmal in der Nacht an einer Gaststätte Halt machte so berichtete jedenfalls die Lokalpresse
+Turings Drang zur Naturwissenschaft traf bei seinen Lehrern in Sherborne auf wenig Gegenliebe sie setzten eher auf Geistes- als auf Naturwissenschaften
+Trotzdem zeigte Turing auch weiterhin bemerkenswerte Fähigkeiten in den von ihm geliebten Bereichen
+So löste er für sein Alter fortgeschrittene Aufgabenstellungen ohne zuvor irgendwelche Kenntnisse der elementaren Infinitesimalrechnung erworben zu haben
+Im Jahr <num> stieß Turing auf die Arbeiten Albert Einsteins
+Er verstand sie nicht nur sondern entnahm einem Text selbständig Einsteins Bewegungsgesetz obwohl dieses nicht explizit erwähnt wurde
+Collegezeit und theoretische Arbeiten
+Turings Widerstreben für Geisteswissenschaften genauso hart wie für Naturwissenschaften zu arbeiten hatte zur Folge dass er einige Male durch die Prüfungen fiel
+Weil dies seinen Notendurchschnitt verschlechterte musste er <num> auf ein College zweiter Wahl gehen das Kings College Cambridge entgegen seinem Wunsch am Trinity College zu studieren
+Er studierte von <num> bis <num> unter Godfrey Harold Hardy <num>-<num> einem respektierten Mathematiker der den Sadleirian Chair in Cambridge innehatte das zu der Zeit ein Zentrum der mathematischen Forschung war
+DateiTuringmaschinesvg
+In seiner für diesen Zweig der Mathematik grundlegenden Arbeit On Computable Numbers with an Application to the Entscheidungsproblem <num> Mai <num> formulierte Turing die Ergebnisse Kurt Gödels von <num> neu
+Er ersetzte dabei Gödels universelle arithmetisch-basierte formale Sprache durch einen einfachen gedanklichen Mechanismus eine abstrakt-formale Zeichenketten verarbeitende mathematische Maschine die heute unter dem Namen Turingmaschine bekannt ist
+Entscheidungsproblem verweist auf eines der <num> wichtigsten offenen Probleme der Mathematik des <num> Jahrhunderts vorgestellt von David Hilbert <num> auf dem <num> Internationalen Mathematiker-Kongress in Paris Hilbertsche Probleme Turing bewies dass solch ein Gerät in der Lage ist jedes vorstellbare mathematische Problem zu lösen sofern dieses auch durch einen Algorithmus gelöst werden kann
+Turingmaschinen sind bis zum heutigen Tag einer der Schwerpunkte der Theoretischen Informatik nämlich der Berechenbarkeitstheorie
+Mit Hilfe der Turingmaschine gelang Turing der Beweis dass es keine Lösung für das Entscheidungsproblem gibt
+Er zeigte dass die Mathematik in gewissem Sinne unvollständig ist weil es allgemein keine Möglichkeit gibt festzustellen ob eine beliebige syntaktisch korrekt gebildete mathematische Aussage beweisbar oder widerlegbar ist
+Dazu bewies er dass das Halteproblem für Turingmaschinen nicht lösbar ist d h dass es nicht möglich ist algorithmisch zu entscheiden ob eine Turingmaschine angesetzt auf eine Eingabe initiale Bandbelegung jemals zum Stillstand kommen wird das heißt die Berechnung terminiert
+Turings Beweis wurde erst nach dem von Alonzo Church <num>-<num> mit Hilfe des Lambda-Kalküls geführten Beweis veröffentlicht unabhängig davon ist Turings Arbeit beträchtlich einfacher und intuitiv zugänglich
+Auch war der Begriff der Universellen Turing- Maschine neu einer Maschine welche jede beliebige andere Turing-Maschine simulieren kann
+Die Eingabe für diese Maschine ist also ein verschlüsseltes Programm das von der universellen Maschine interpretiert wird und der Startwert auf den es angewendet werden soll
+Alle bis heute definierten Berechenbarkeitsbegriffe haben sich bis auf die Abbildung von Worten auf Zahlen und umgekehrt als äquivalent erwiesen
+<num> und <num> verbrachte Turing zumeist an der Princeton University und studierte dort unter Alonzo Church
+<num> erwarb er den Doktortitel in Princeton
+Seine Doktorarbeit führte den Begriff der Hypercomputation ein bei der Turingmaschinen zu sogenannten Orakel-Maschinen erweitert werden
+So wurde das Studium von nicht-deterministisch lösbaren Problemen ermöglicht
+Nach seiner Rückkehr nach Cambridge im Jahr <num> besuchte Turing Vorlesungen des österreichisch-britischen Philosophen Ludwig Wittgenstein <num>-<num> über die Grundlagen der Mathematik
+Die beiden diskutierten und stritten vehement Turing verteidigte den mathematischen Formalismus während Wittgenstein der Meinung war dass Mathematik überbewertet sei und keine absolute Wahrheit zutage bringen könne
+Kryptoanalyse
+DateiBletchley Park IMG <num>JPG Während des Zweiten Weltkriegs war Turing einer der herausragenden Wissenschaftler bei den erfolgreichen Versuchen in Bletchley Park verschlüsselte deutsche Funksprüche zu entziffern
+Er steuerte einige mathematische Modelle bei um sowohl die Enigma siehe auch Letchworth-Enigma als auch die Lorenz-Schlüsselmaschine siehe auch
+Turingery
+zu brechen
+Die Einblicke die Turing bei der Kryptoanalyse der -Verschlüsselungen gewann halfen später bei der Entwicklung des ersten digitalen programmierbaren elektronischen Röhrencomputers ENIAC
+Konstruiert von Max Newman und seinem Team und gebaut in der
+Post Office Research Station
+in Dollis Hill von einem von Tommy Flowers angeführten Team im Jahr <num> entzifferte Colossus die Lorenz-Maschine
+Auch konzipierte Turing die nach ihm benannten
+Bombes
+Sie waren Nachfolgerinnen der von dem Polen Marian Rejewski entwickelten
+Bomba
+und dienten zur Ermittlung der Schlüssel von Enigma-Nachrichten
+Dabei handelte es sich um ein elektromechanisches Gerät das im Prinzip mehrere Enigma-Maschinen beinhaltete und so in der Lage war viele mögliche Schlüsseleinstellungen der Enigma-Nachrichten durchzutesten und zu eliminieren bis eine mögliche Lösung gefunden war
+Reductio ad absurdum
+Turings Mitwirkung als einer der wichtigsten Codeknacker bei der Entzifferung der Enigma war bis in die <num>er Jahre geheim nicht einmal seine engsten Freunde wussten davon
+Die Entzifferung geheimer deutscher Funksprüche war eine kriegsentscheidende Komponente für den Sieg der Alliierten im U-Boot-Krieg und im Afrikafeldzug
+Arbeit an frühen Computern - Der Turing-Test
+DateiPunch cards in tray for Pilot ACE computer built at the National Physical Laboratory c <num> <num>jpg Von <num> bis <num> war Turing im
+National Physical Laboratory
+in Teddington tätig wo er am Design der ACE
+Automatic Computing Engine
+arbeitete
+Der Name der Maschine ist abgeleitet von der Analytical Engine des Mathematikers Charles Babbage dessen Werk Turing zeitlebens bewunderte
+Ab <num> lehrte Turing an der Universität Manchester und wurde im Jahr <num> stellvertretender Direktor der Computerabteilung
+Hier arbeitete er an der Software für einen der ersten echten Computer den Manchester Mark I und gleichzeitig weiterhin verschiedenen theoretischen Arbeiten
+In Computing machinery and intelligence
+Mind
+Oktober <num> griff Turing die Problematik der künstlichen Intelligenz auf und schlug den Turing-Test als Kriterium vor ob eine Maschine dem Menschen vergleichbar denkfähig ist
+Da der Denkvorgang nicht formalisierbar ist betrachtet der Test nur die Antworten einer Maschine im Dialog mit einem Menschen d h
+das kommunikative Verhalten der Maschine
+Wenn dieses von einem menschlichen Verhalten nicht unterscheidbar erscheint soll von maschineller Intelligenz gesprochen werden
+Er beeinflusste durch die Veröffentlichung die Entwicklung der Künstlichen Intelligenz maßgeblich
+<num> schrieb er das Schachprogramm Turochamp
+Da es keine Computer mit ausreichender Leistung gab um es auszuführen übernahm Turing dessen Funktion und berechnete jeden Zug selbst
+Dies dauerte bis zu <num> Minuten pro Zug
+Das einzige schriftlich dokumentierte Spiel verlor er gegen einen Kollegen
+Arbeit an mathematischen Problemen der Biologie
+Von <num> bis zu seinem Tod <num> arbeitete Turing an mathematischen Problemen der theoretischen Biologie
+Er veröffentlichte <num> eine Arbeit zum Thema The Chemical Basis of Morphogenesis
+In diesem Artikel wurde erstmals ein Mechanismus beschrieben wie Reaktions-Diffusions-Systeme spontan Strukturen entwickeln können
+Dieser als Turing-Mechanismus bekannte Prozess steht noch heute im Mittelpunkt vieler chemisch-biologischer Strukturbildungstheorien
+Turings weiteres Interesse galt dem Vorkommen der Fibonacci-Zahlen in der Struktur von Pflanzen
+Spätere Arbeiten blieben bis zur Veröffentlichung seiner gesammelten Werke <num> unveröffentlicht
+Verfolgung wegen Homosexualität und Turings Tod
+DateiBerliner CSD <num> by andreas tw - <num>jpg
+<num> half der <num>-jährige Arnold Murray zu dem Turing eine gleichgeschlechtliche Beziehung hatte einem Komplizen dabei in Turings Haus einzubrechen
+Turing meldete daraufhin einen Diebstahl bei der Polizei die ihm als Folge der Ermittlungen eine sexuelle Beziehung zu Murray vorwarf
+Da homosexuelle Handlungen zu dieser Zeit - wie in den meisten anderen Ländern - in England strafbar waren wurde Turing wegen grober Unzucht und sexueller Perversion angeklagt
+Turing sah keinen Anlass sich wegen dieser Vorwürfe zu rechtfertigen
+Nach seiner Verurteilung zu einer Gefängnisstrafe wurde er vor die Wahl gestellt die Haftstrafe anzutreten oder - da zu seiner Zeit Homosexualität von weiten Teilen der Psychiatrie als Krankheit angesehen wurde - sich behandeln zu lassen
+Er entschied sich für die ärztliche Behandlung zu der auch eine medikamentöse Behandlung mit dem Hormon Östrogen gehörte
+Diesem wurde eine triebhemmende Wirkung zugeschrieben
+Die Behandlung dauerte ein Jahr und führte zu Nebenwirkungen wie der Vergrößerung der Brustdrüse
+Auch wenn er seine körperlichen Veränderungen mit Humor kommentierte muss die Verweiblichung seiner Konturen den sportlichen Läufer und Tennisspieler schwer getroffen haben
+Turing erkrankte an einer Depression Im Herbst <num> begann Turing seine Therapie bei dem aus Berlin stammenden und seit <num> in Manchester lebenden Psychoanalytiker Franz Greenbaum
+Dieser war ein Anhänger CG
+Jungs
+und war ihm von Freunden als für seinen Fall verständnisvoll empfohlen worden
+Turing entwickelte auch ein freundschaftliches Verhältnis zur Familie Greenbaum die er auch privat besuchte
+<num> starb Turing wahrscheinlich entsprechend der offiziellen Feststellung durch Suizid an einer Cyanidvergiftung dem Anschein nach von einem vergifteten Apfel herrührend den man halb aufgegessen neben ihm auffand
+Die Ermittler versäumten es jedoch den Apfel auf Gift untersuchen zu lassen
+Es wird berichtet dass Turing seit <num> nachdem er den Film Schneewittchen und die sieben Zwerge gesehen hatte immer wieder die Verse Dip the apple in the brew
+Let the sleeping death seep through Tauch den Apfel tief hinein
+bis das Gift wird in ihm sein in der deutschen Version des Films Apfel färbt sich strahlend rot
+lockt Schneewittchen in den Tod sang
+Der These dass Turings Tod ein Unfall im Zusammenhang mit einem chemischen Versuch war wird von Andrew Hodges einem seiner Biographen entschieden widersprochen Unter seinen Biographen ist die Annahme verbreitet die Auswirkungen der Hormonbehandlung seien die Hauptursache für den Suizid gewesen
+Offizielle Entschuldigung Danksagung und Rehabilitierung
+Ab etwa den späten <num>er Jahren unternahmen britische Bürger eine Reihe von öffentlichkeitswirksamen Aktivitäten um das von Turing erlittene Unrecht bekannt zu machen und seine formale Rehabilitierung zu erreichen also einen Widerruf oder eine Aufhebung des damaligen Urteils
+Dies führte im Jahr <num> zum Erfolg
+Im Jahr <num> unterzeichneten rund <num> Briten eine bei der Regierung eingereichte Online-Petition in der eine posthume Entschuldigung von der britischen Regierung gefordert wurde Der Initiator der Kampagne der britische Programmierer John Graham-Cumming regte an Alan Turing eine Ritterwürde zu verleihen
+Am <num> September <num> veröffentlichte der damalige britische Premierminister Gordon Brown eine Erklärung in der er im Namen der britischen Regierung die Verfolgung Turings bedauerte und seinen außerordentlichen Beitrag während des Zweiten Weltkriegs würdigte
+Dabei spielte er auch auf den strategischen Vorteil der Alliierten durch die Entschlüsselung der Enigma an und unterstrich deren Bedeutung
+Da die Strafverfolgung seiner sexuellen Ausrichtung damals gesetzeskonform war wurde eine nachträgliche Aufhebung der Verurteilung Turings zunächst von offizieller Seite als unmöglich dargestellt
+Noch <num> weigerte sich die Regierung von Browns Nachfolger David Cameron <num> Homosexuelle die nach dem Criminal Law Amendment Act von <num> verurteilt worden waren postum zu rehabilitieren
+Im Jahr <num> wurde bekannt dass die britische Regierung die Absicht hatte Turing zu rehabilitieren
+Das Oberhausmitglied John Sharkey Baron Sharkey beantragte dies
+Das konservative Mitglied des Oberhauses Tariq Ahmad Baron Ahmad of Wimbledon kündigte die Zustimmung der Regierung an
+Der Liberaldemokrat Sharkey hatte in den <num>er Jahren in Manchester Mathematik bei Turings einzigem Doktoranden Robin Gandy studiert
+Eine dritte Lesung des Antrags beraumte die Regierung für Ende Oktober an
+Am <num> Dezember <num> wurde Alan Turing durch ein allein dem Monarchen zustehendes besonderes Gnadenrecht durch ein sogenanntes Royal Pardon begnadigt
+Justizminister Chris Grayling hatte diese Begnadigung bei Elisabeth II beantragt
+Turing gilt damit auch als offiziell rehabilitiert
+Im April <num> entschuldigte sich Robert Hannigan der damalige Leiter des britischen Geheimdienstes GCHQ für die Behandlung von Homosexuellen durch seine Institution und bezog dies ausdrücklich auf Alan Turing
+Nachwirkungen der Rehabilitierung
+Anfang <num> verlangten Mitglieder der Familie Alan Turings unter weiterer teils prominenter Unterstützung Stephen Fry Turing-Darsteller Benedict Cumberbatch in einer Petition an das britische Parlament die Rehabilitation auch aller anderen der in England unter den Homosexuellen-Gesetzen Verurteilten
+Die Petition wurde von ca <num> Personen unterschrieben und sollte von Turings Großneffen Nevil Hunt und der Großnichte Rachel Barns überreicht werden
+Am <num> Oktober <num> lehnte das britische Parlament einen Gesetzesentwurf ab der eine Rehabilitation in Form einer generellen Rehabilitation aller lebenden früher für Homosexualität verurteilten Personen vorsah
+Dieser Gesetzesentwurf ging einigen zu weit anderen nicht weit genug Am <num> Januar <num> wurde von Königin Elisabeth II
+ein Gesetz in Kraft gesetzt das aufbauend auf der Begnadigung von Turing allen Männern die Strafe aufhebt falls zu dem Zeitpunkt beide über <num> Jahre alt waren als sie den geahndeten Akt in gegenseitigem Einvernehmen vollzogen
+Ausgenommen sind weiterhin Verurteilungen wegen homosexueller Handlungen in öffentlichen Toiletten
+Das Gesetz schließt auch bereits verstorbene Personen ein
+Ein noch lebender Betroffener kann beantragen dass die Strafe aus seiner polizeilichen Führungsakte gestrichen wird und Historiker können darauf hinweisen dass eine Verurteilung verstorbener Personen nach geltendem Recht ungültig ist
+Das Gesetz das von Justizminister Sam Gyimah als Turings Gesetz bezeichnet wurde ist eine Ergänzung zum
+Policing and Crime Act
+und nimmt keinen Bezug auf andere Gesetze unter denen homosexuelle Handlungen verfolgt werden konnten
+Von Michael Cashman einem der Initiatoren des Gesetzes wurden jedoch weitere Vereinbarungen abgesichert die einen entsprechend umfassenden Straferlass für alle homosexuellen Handlungen ermöglichen
+Postume Ehrungen
+DateiTuring statue Surreyjpg Am <num> März <num> wurde der Asteroid <num> Turing nach ihm benannt
+Eine Turing-Statue wurde am <num> Juni <num> in Manchester enthüllt
+Sie steht im Sackville Park zwischen den wissenschaftlichen Gebäuden der Universität Manchester und dem bei Homosexuellen beliebten Viertel der Canal Street
+An seinem <num> Todestag dem <num> Juni <num> wurde zum Gedenken an Turings frühzeitigen Tod eine Tafel an seinem früheren Haus Hollymeade in Wilmslow enthüllt
+Der Turing Award wird jährlich von der
+Association for Computing Machinery
+an Personen verliehen die bedeutende Beiträge zur Informatik geleistet haben
+Er wird weithin als Nobelpreis der Informatik angesehen
+Der Bletchley Park Trust hat am <num> Juni <num> eine Statue Turings in Bletchley Park enthüllt
+Die Skulptur wurde von Stephen Kettle gestaltet der als Material für sein Kunstwerk walisischen Schiefer verwendete
+Im Turing-Jahr <num> fanden zu Alan Turings hundertstem Geburtstag weltweit Veranstaltungen zur Würdigung seiner Leistungen und zum Gedenken daran statt
+Im Jahr <num> wurde er in die
+Hall of Honor
+Ehrenhalle des US-Geheimdienstes NSA National Security Agency aufgenommen
+Verschiedenes
+DateiTuring Plaquejpg
+Alan Turing war ein hervorragender Langstreckenläufer
+Von <num> an startete er bei Wettkämpfen für den Walton Athletic Club Bei den englischen Meisterschaften im Marathon <num> wurde er Fünfter in <num><num> h nur gut fünf Minuten langsamer als die Zeit mit der sich Stan Jones beim Polytechnic Marathon des folgenden Jahres bei dem Turing verletzt fehlte als dritter britischer Mann hinter Jack Holden und Tom Richards für den Marathon der Olympischen Spiele <num> in London qualifizierte
+<num> musste Turing wegen einer Beinverletzung seine Sportkarriere beenden
+Angeblich hat sich Apple beim Design seines Logos eines angebissenen Apfels ursprünglich in Regenbogenfarben vom Tod des Computerpioniers Turing inspirieren lassen
+Diese Annahme wurde jedoch von Steve Jobs mit den Worten widerlegt dass er wünschte damals daran gedacht zu haben er es aber nicht habe Apple hatte die Legende im Sinn nach der Isaac Newton zu seiner Gravitationstheorie inspiriert worden sein soll als ihm ein Apfel auf den Kopf fiel Der Logo-Designer Rob Janoff meinte der Biss sei lediglich als Größenmaßstab hinzugefügt worden um etwa eine Verwechslung mit einer Kirsche auszuschließen
+In seinen Lebenserinnerungen berichtet der Computerpionier Heinz Billing vom Max-Planck-Institut für Physik München dass sich Alan Turing und Konrad Zuse <num> in Göttingen getroffen haben
+In Form eines Kolloquiums befragten britische Fachleute neben Turing u a John R Womersley und Arthur Porter deutsche Wissenschaftler wie Zuse Billing Alwin Walther und Helmut Schreyer
+<num> wurde im Heinz Nixdorf MuseumsForum in Paderborn zu Ehren von Turing ein einjähriger Zyklus von Ausstellungen unter dem Titel Genial
+Geheim gezeigt
+Berichte von Bekannten über ihn sind teilweise skurril Er habe seine Teetasse immer mit einem Fahrradschloss an seine Heizung gekettet und sei mit zweckentfremdeter Gasmaske Fahrrad gefahren um sich gegen seinen Heuschnupfen beim Fahrradfahren zu schützen
+Bewohner des Örtchens Bletchley erschraken darüber und glaubten bei seinem Anblick an einen deutschen Giftgasangriff
+Am Institut für Informatik der Westfälischen Wilhelms-Universität in Münster wurden Ende der <num>er Jahre von Achim Clausing zwei Originaldrucke der bedeutendsten Veröffentlichungen Turings im Nachlass von Heinrich Scholz entdeckt wovon eine seit <num> verschollen gewesen war Es handelt sich um die Arbeit On Computable Numbers with an Application to the Entscheidungsproblem von <num> die Scholz noch im selben Jahr mit einer Postkarte von Turing angefordert hatte Auf Basis dieser Arbeit hielt Scholz nach Clausings Aussage das weltweit erste Seminar über Informatik Die zweite Arbeit stammt aus dem Jahr <num> und ist eine Abhandlung über die Entwicklung der künstlichen Intelligenz die Turing mit einem handschriftlichen Kommentar versah Dies ist wohl mein letztes Exemplar
+Bei Sothebys wurden vergleichbare Drucke Turings die keine Widmung aufwiesen für <num> Euro versteigert
+<num> wurde eine bis dahin unbekannte Sammlung von <num> Briefen von Turing entdeckt
+Eine weitere Sammlung mit <num> Briefen wurde darüber hinaus im gleichen Jahr in einem Aktenschrank in einem Lagerraum der Universität Manchester aufgefunden
+Die Briefe stammen aus den Jahren <num> bis <num>
+Die an der Universität Manchester entdeckten Briefe behandeln überwiegend seine Forschungsarbeit und wurden vom Archiv der Universität übernommen sie sind im Internet einsehbar
+Im Juli <num> gab die Bank of England bekannt dass auf der ab Ende <num> in Umlauf kommenden neuen <num>-Pfund-Note das Bild von Turing und sein Zitat This is only a foretaste of what is to come and only the shadow of what is going to be zu sehen sein wird
+Werke
+Veröffentlichungen
+Wichtige Veröffentlichungen
+Englische Ausgaben
+Deutsche Ausgabe und Übersetzungen
+Patente
+<num>
+<num>
+Literatur Auswahl
+Theorie und Diskussion
+David J Bolter Turings Man Western Culture in the Computer Age
+University of South Carolina Press Chapel Hill <num> ISBN <num>-<num>-<num>-<num>
+S Barry Cooper Jan van Leeuwen Hrsg Alan Turing His Work and Impact Elsevier New York NY <num> ISBN <num>-<num>-<num>-<num>-<num>
+Jack Copeland Jonathan Bowen Mark Sprevak u Robin Wilson Hrsg The Turing Guide
+Oxford University Press Oxford <num> ISBN <num>-<num>-<num>-<num>-<num>
+Juliet Floyd Alisa Bokulich Hrsg Philosophical Explorations of the Legacy of Alan Turing
+Turing <num>
+Springer Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+Boston Studies in the History of Science <num>
+Geschichte und Biographie
+George Dyson Turings Cathedral
+The Origins of the Digital Universe
+Pantheon <num> ISBN <num>-<num>-<num>-<num>-<num> Turings Kathedrale Die Ursprünge des digitalen Zeitalters Propyläen Verlag Berlin <num> ISBN <num>-<num>-<num>-<num>-<num>
+Francis Harry Hinsley Alan Stripp Codebreakers - The inside story of Bletchley Park Oxford University Press Reading <num> ISBN <num>-<num>-<num>-<num>
+Andrew Hodges Alan Turing - The Enigma Burnett Books London und Simon and Schuster New York <num> Vintage New York <num> Biografie Alan Turing - Enigma
+Kammerer und Unverzagt Berlin <num> <num> Auflage Springer <num> ISBN <num>-<num>-<num>-<num>
+David Leavitt The Man Who Knew Too Much
+Alan Turing and the Invention of the Computer
+W W Norton
+Co <num> ISBN <num>-<num>-<num>-<num>
+Dermot Turing Alan Turing - The Life of a Genius The History Press <num> ISBN <num>-<num> Prof - Alan Turing Decoded Pavilion Books <num> ISBN <num>-<num>
+Gordon Welchman The Hut Six Story - Breaking the Enigma Codes Allen Lane London <num> Cleobury Mortimer MM Baldwin Shropshire <num> ISBN <num>-<num>-<num>-<num>
+Belletristik
+Rolf Hochhuth Alan Turing
+Erzählung
+Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num>
+David Lagercrantz Der Sündenfall von Wilmslow
+Übersetzung aus dem Schwedischen Wolfgang Butt
+Piper München <num> zuerst <num>
+Wolf Schneider Große Verlierer
+Von Goliath bis Gorbatschow
+Rowohlt Reinbek <num> ISBN <num>-<num>-<num>-<num> darin enthalten ein Kapitel über Alan Turing
+Neal Stephenson
+Cryptonomicon
+Goldmann <num> ISBN <num>-<num>-<num>-<num> Originalausgabe New York <num>
+Robert Harris
+Enigma
+Heyne München <num> ISBN <num>-<num>-<num>-<num>-<num> Englische Originalausgabe <num>
+Filme Auswahl
+<num> Breaking the Code Der codierte Mann
+Fernsehfilm-Biographie Großbritannien <num> Min Buch Hugh Whitemore Regie Herbert Wise Produktion BBC mit Derek Jacobi als Turing online-Video
+<num>
+Enigma - Das Geheimnis Regie Michael Apted
+Dieser Film basiert auf dem Roman
+Enigma
+des britischen Autors Robert Harris aus dem Jahre <num>
+<num> Codebreaker
+Doku-Drama Großbritannien Buch Craig Warner Regie Clare Beavan Nic Stacey Produktion Channel <num> mit Ed Stoppard als Alan Turing Deutschsprachige Erstsendung bei ServusTV als Der Codeknacker
+Alan Turing
+Erstsendung <num> Juni <num> - Inhaltsangabe
+<num> Der Fall Alan Turing oder Wie ein Mathegenie Hitler knackte OT La drôle de guerre dAlan Turing ou Comment les maths ont vaincu Hitler Dokumentarfilm Frankreich <num> <num> Min Buch und Regie Denis van Waerebeke Produktion Les Films dici arte France Off World RTBF Erstsendung <num> Juni <num> bei arte Inhaltsangabe von arte online-Video
+<num>
+The Imitation Game Doku-Drama Großbritannien <num> <num> Min Buch Graham Moore Regie Morten Tyldum Produktion Weinstein
+Mit Benedict Cumberbatch als Alan Turing Keira Knightley als Joan Clarke Charles Dance u a nach der Biographie von Andrew Hodges
+Musik
+A Man From The Future Pet Shop Boys <num> Die Texte im Stück basieren auf der Biographie Alan Turing The Enigma von Andrew Hodges der hier mit Tennant und Lowe zusammenarbeitete
+Weblinks
+Alan Turing in der Ehrenrolle Roll of Honour von Bletchley Park
+Andrew Hodges Alan-Turing-Portal - turingorguk englisch
+The Turing Archive for the History of Computing - alanturingnet englisch
+The Turing Digital Archive In University of Cambridge englisch
+Genial
+geheim - Alan Turing in <num> Etappen In Heinz Nixdorf MuseumsForum Sonderausstellung zum <num>
+Geburtstag von Alan Turing <num>
+Artikel
+André Schulz
+Turing und Schach
+In Schach Nachrichten <num> Juni <num>
+Stefan Betschon
+Turingmaschine im Rückwärtsgang
+In
+Neue Zürcher Zeitung
+<num> Januar <num> zum <num>
+Geburtstag von Alan Turing
+Einzelnachweise
+Alan Turing Colleagues share their memories
+In
+BBC News
+<num> Juni <num> alphabetische Mitgliederliste der Royal Society PDF <num> MB abgerufen am <num> Juli <num>Andrew Hodges
+Alan Turing - a short biography
+In turingorg <num> Alan Turing Manchester celebrates pardoned genius
+In
+BBC News
+<num> Dezember <num> abgerufen am <num> Dezember <num>Caroline Davies
+Enigma Codebreaker Alan Turing receives Royal Pardon
+In
+The Guardian
+<num> Dezember <num>Friedhelm Greis
+Homosexualität Queen begnadigt Alan Turing
+In
+golemde
+<num> Dezember <num> Royal pardon for codebreaker Alan Turing
+In BBC News <num> Dezember <num> abgerufen am <num> Dezember <num>siehe auch Liste
+Recipients of British royal pardons
+sowie Artikel
+Royal prerogative of mercy
+in der englischsprachigen Wikipedia Er knackte den geheimen Code Er wollte nichts als seine Ruhe Doch man liess sie ihm nicht Am Ende wurde er von den Briten diszipliniert deren Überleben er gesichert hatte Eine Hommage an Alan Turing den Dechiffreur der Nazi-Enigma und Erfinder des Computers In
+Das Magazin
+Nr <num> <num> Themenheft Digitales GlückAndré Schulz
+Die goldene Gans die niemals schnattert
+In Schach Nachrichten <num> Juni <num> über Turing und SchachBoris Mayer
+Kein Code war ihm zu schwer
+In
+Jungle World
+<num> Juni <num> Nr <num> abgerufen am <num> August <num>
+In BBC News <num> Juni <num> abgerufen am <num> Juni <num> to seep through sth
+In reversonet Collins Wörterbuch online siehe unten unter den Beispielen aufgerufen <num> Februar <num> NA Thousands call for Turing apology
+In BBC News <num> August <num>Felix Knoke
+Netzweltticker Briten fordern Entschuldigung an Computer-Pionier Turing
+In
+SpOn
+<num> September <num>Werner Pluta
+Alan Turing Späte Rehabilitierung für den Computerpionier
+In
+golemde
+<num> Juli <num> abgerufen am <num> Juli <num>Nicholas Watt
+Enigma codebreaker Alan Turing to be given posthumous pardon
+In The Guardian <num> Juli <num> abgerufen am <num> Juli <num> Royal pardon for codebreaker Alan Turing
+In
+BBC News
+<num> Dezember <num> abgerufen am <num> März <num> Katholische Nachrichten-Agentur KNA
+dpa
+Schwule sollen rehabilitiert werden
+In
+Badische Zeitung
+<num> Februar <num>Owen Bowcott
+UK issues posthumous pardons for thousands of gay men
+In The Guardian <num> Januar <num> abgerufen am <num> Februar <num> Fotos Die Turing-Statue in Bletchley Park In whudatde <num> August <num> Turing-Jahr <num>
+In
+Gesellschaft für Informatik
+<num> abgerufen am <num> August <num>Chris Christensen
+Review of IEEE Milestone Award to the Polish Cipher Bureau for The First Breaking of Enigma Code
+In
+Cryptologia
+<num> April <num> S <num> doi<num><num><num> bezahlpflichtigI E G Green
+In isolation and autonomy the marathon ambition of a computer genius Alan Turing
+In Track Stats September <num> englischPat Butcher
+In Praise of Great Men
+In globerunnerorg <num> September <num> englischJohn Graham-Cumming
+An Olympic honour for Alan Turing
+In The Guardian <num> März <num> englisch He Steve Jobs replied that he wished he had thought of that but hadnt In Walter Isaacson
+Steve Jobs <num>Holden Frith
+Unraveling the tale behind the Apple logo
+In
+CNN
+<num> Oktober <num> englisch Heinz Billing Ein Leben zwischen Forschung und Praxis Selbstverlag F Genscher Düsseldorf <num> S <num> wiedergegeben nach Herbert Bruderer Konrad Zuse und die Schweiz Wer hat den Computer erfunden Oldenbourg Wissenschaftsverlag München <num> ISBN <num>-<num>-<num>-<num>-<num> S <num> online Hans-Heinrich Pardey Genial und schrullig In
+Frankfurter Allgemeine Sonntagszeitung
+<num> Januar <num> ArtikelanfangLaura Döing
+Die geheimen Taten des Alan Turing
+In
+Deutsche Welle
+<num> Januar <num>Elmar Ries
+Auf den Spuren eines Pioniers In der Unibibliothek Münster liegen Sonderdrucke des Informatikers Alan Turing
+In Westfälische Nachrichten <num> Januar <num> abgerufen am <num> Dezember <num> Josh Halliday
+In The Guardian <num> August <num> abgerufen am <num> August <num> Alan Turing Papers Additional im Archiv der Universität ManchesterConcert
+A Man From The Future
+In
+Pet Shop Boys
+<num> April <num>Teresa Dapp
+Musikalische Verneigung vor Alan Turing
+In
+dpa
+Mittelbayerische Zeitung
+<num> Juli <num>
+DateiTommarp kloster <num>JPG DateiScale drawing underwaterjpg DateiArrow and spear heads - from-DC<num>jpg Datei<num> <num> Kampagne Sommer Bild <num> Keramikofenjpg Die Archäologie
+und λόγος
+lógos
+Lehre wörtlich also Lehre von den Altertümern ist eine Wissenschaft die mit naturwissenschaftlichen und geisteswissenschaftlichen Methoden die kulturelle Entwicklung der Menschheit erforscht
+Sie hat sich weltweit zu einem Verbund unterschiedlichster theoretischer und praktischer Fachrichtungen entwickelt
+Die Archäologie interessiert sich ausschließlich für den Menschen und seine materiellen Hinterlassenschaften wie etwa Gebäude Werkzeuge und Kunstwerke
+Sie umfasst einen Zeitraum von den ersten Steinwerkzeugen vor etwa <num> Millionen Jahren bis in die nähere Gegenwart
+Aufgrund neuer Funde in Afrika die etwa <num> Millionen Jahre alt sind wird auch ein deutlich früherer Beginn der Werkzeugherstellung in Betracht gezogen Materielle Hinterlassenschaften der jüngsten Geschichte beispielsweise Konzentrationslager und Bunkerlinien aus dem Zweiten Weltkrieg werden heute ebenfalls mit archäologischen Methoden ausgewertet auch wenn dieser Ansatz einer zeitgeschichtlichen Archäologie fachintern umstritten ist
+Obwohl die Archäologie eine verhältnismäßig junge Wissenschaft ist ist es kaum mehr möglich alle Zeiträume zu überblicken so dass sich verschiedene Fachrichtungen herausbildeten
+Dabei können die Epochen regional unterschiedlich datiert sein teilweise sind sie nicht überall dokumentierbar Neben der Orientierung an Epochen z B
+Mittelalterarchäologie oder Regionen z B
+Vorderasiatische Archäologie gibt es auch die Spezialisierung auf bestimmte Themengebiete z B
+Christliche Archäologie Rechtsarchäologie Industriearchäologie
+Obwohl die Methodik sich großteils ähnelt können die Quellen unterschiedlich sein
+In der Vor- und Frühgeschichte hat man es hauptsächlich mit materieller Kultur zu tun in der Frühgeschichte kann dabei teils auf Schriftquellen zurückgegriffen werden
+Diese stehen für Archäologen im Gegensatz zu Wissenschaftlern anderer Teildisziplinen der Geschichtswissenschaft aber nicht im Mittelpunkt
+Erkenntnisse zu Umwelt Klima Ernährung oder zum Alter von Funden tragen zur Rekonstruktion vergangener Kulturen bei
+Forschungsgeschichte
+Anfänge der Altertumsforschung in Europa
+In Europa entwickelte sich die Archäologie um <num> weil man Zeugnisse für die in den Quellen der Antike geschilderten Ereignisse finden wollte Cyriacus von Ancona
+um <num>
+um <num> ein italienischer Kaufmann und Humanist gilt als einer der Gründungsväter der modernen klassischen Archäologie
+Die in der Renaissance einsetzende Wiedergeburt klassisch-antiker Gelehrsamkeit führt im <num> und <num> Jahrhundert zu einem gesteigerten Interesse an griechischen und römischen Altertümern und zu einer Welle der Sammelleidenschaft antiker Kunstgegenstände
+Doch auch weniger reisefreudige Gelehrte beginnen sich für die vorhandenen Zeugnisse vergangener Zeiten zu interessieren
+Ab Mitte des <num> Jahrhunderts tritt an die Stelle der Sammelleidenschaft die akribische Erfassung der Denkmäler
+In dieser Zeit werden zahlreiche Enzyklopädien und Kataloge veröffentlicht welche im späten <num> Jahrhundert vielfach mit Kupferstichen und Holzschnitten illustriert werden
+In England veröffentlicht William Camden <num>-<num> im Jahre <num> seine Britannia einen Katalog der sichtbaren Altertümer
+Bemerkenswert ist dass er bereits Bewuchsmerkmale in Kornfeldern bemerkt und als solche interpretiert
+Michele Mercati <num>-<num> gilt als der erste europäische Gelehrte der Steinwerkzeuge als solche einstufte sein Werk wird jedoch erst <num> veröffentlicht
+Trotz großer Popularität hat die Archäologie als Wissenschaft noch keinen Stellenwert denn es herrscht die Ansicht vor dass ausschließlich historische Quellen und die Bibel zur Interpretation der Vergangenheit geeignet seien
+So gilt es noch lange als ein Faktum dass - wie James Ussher aus der Bibel ableitete - die Menschheit im Oktober <num> v Chr entstand
+<num> wagt es Isaac de La Peyrère die sogenannten Donnerkeile Steinzeitartefakte menschlichen Aktivitäten zuzuordnen welche vor Adam lebten Präadamiten-Hypothese Nach einer Intervention der Inquisition widerruft er seine Theorie
+DateiSepulture de CocherelJPG DateiJättakullen den <num> juli <num> bild <num>JPG In Skandinavien werden Bodendenkmäler schon früh beachtet
+Bereits <num> gräbt man einen Dolmen bei Roskilde aus
+Im Jahre <num> erhält Uppsala einen Lehrstuhl für Altertumskunde
+<num> wird in Houlbec-Cocherel in Nordfrankreich eine neolithische Grabkammer ausgegraben
+Sie gilt als die älteste archäologische Grabung weil hier <num> der erste erhaltene Grabungsbericht erstellt wurde
+Der Kieler Professor Johann Daniel Major führt um <num> umfangreiche Ausgrabungen in Jütland durch und lässt zahlreiche Hügelgräber öffnen
+Sein Ziel ist es die Herkunft der Einwohner der Halbinsel mit archäologischen Methoden zu klären
+Bernard de Montfaucons LAntiquité expliquée erscheint ab <num>
+In zehn Bänden stellt er Kunstgegenstände aus dem Mittelmeerraum dar
+Montfaucons Werk bleibt für lange Zeit das Standardwerk
+Mitte des <num> bis Mitte des <num> Jahrhunderts
+Archäologische Forschungsmethoden setzten sich nun sukzessiv durch
+Oftmals trafen einzelne Gelehrte schon früh bahnbrechende Schlussfolgerungen welche aber oft - da noch nicht zeitgemäß - unbeachtet blieben
+Einer der Bahnbrecher war der französische Amateurarchäologe Jacques Boucher de Perthes der als Erster prähistorische Artefakte richtig zuordnete wofür ihm aber erst mehr als <num> Jahre später durch die Bestätigung Charles Lyells <num>-<num> Anerkennung zuteilwurde
+Eine wichtige Erkenntnis war die Entdeckung des stratigraphischen Prinzips
+Bereits lange vorher war die Zusammengehörigkeit und somit Gleichaltrigkeit von Funden welche sich in einer Schicht befanden beispielsweise ein Steinartefakt im Fundzusammenhang mit einer ausgestorbenen Tierart immer wieder diskutiert worden wurde aber nicht allgemein akzeptiert
+Ein Modell das in seinen Grundzügen noch heute gilt wurde von <num> von Christian Jürgensen Thomsen veröffentlicht
+Er war Kurator in Kopenhagen und erfand das Dreiperiodensystem das die Vorgeschichte der Menschheit in drei Phasen einteilt nämlich die Steinzeit die Bronzezeit und die Eisenzeit
+Etwa <num> Jahre später um <num> unterschied J Lubbock die Steinzeit noch in die des geschlagenen und die des geschliffenen Steins
+Die Begriffe Paläolithikum Altsteinzeit und Neolithikum NeusteinzeitJungsteinzeit waren geboren
+Die Epochen sind in sich vielfach untergliedert aber die damals gefundene Unterteilung gilt - mit Einschränkungen - bis heute
+DateiPompeji um <num> ueberblickjpg
+Die ersten großen Ausgrabungen fanden in den antiken Städten Pompeji und Herculaneum statt
+Beide waren am <num> August <num> n Chr durch den Ausbruch des Vesuvs ausgelöscht worden
+Pompeji wurde Ende des <num> Jahrhunderts beim Bau einer Wasserleitung wiederentdeckt
+<num> begannen die Grabungen
+In Herculaneum wurde erstmals <num> gegraben <num> ließ Karl III
+von Neapel die Stadt gezielt ausgraben
+<num> konnte das Theater die Basilika und die Villa dei Papiri freigelegt werden
+Mit seinem Sendschreiben von den Herculanischen Entdeckungen der ersten archäologischen Publikation begründete Johann Joachim Winckelmann <num> die neue Wissenschaft der Archäologie und gilt seither als Vater der klassischen Archäologie
+Winckelmann ist auch der Erste der eine Periodisierung und geschichtliche Einordnung der griechischen Kunst versucht
+Seine Entwicklungsstufen alter Stil - hoher Stil - schöner Stil - Stil der Nachahmer - Verfall der Kunst sind durch die enthaltene Wertung jedoch überholt
+Für die Verbreitung seiner Forschung und deren Rezeption in der zeitgenössischen Literatur und Kunst war der Göttinger Professor Christian Gottlob Heyne entscheidend der mit Winckelmann korrespondierte seine Schriften rezensierte und bekanntmachte und in seinen Vorlesungen verwendete
+<num> wurde an der Christian-Albrechts-Universität zu Kiel der erste Lehrstuhl für klassische Archäologie eingerichtet
+Die ägyptischen Baudenkmäler allen voran die Pyramiden waren bereits im Altertum beliebte Reiseziele siehe Weltwunder
+Im <num> Jahrhundert hatte sich die Erkenntnis durchgesetzt dass es sich hierbei um Königsgräber handelt
+Die Ägyptologie nahm mit Napoléon Bonapartes Ägypten-Feldzug <num> ihren Anfang
+In Begleitung des Heeres befanden sich auch Wissenschaftler
+Von besonderer Bedeutung ist der Fund des Steins von Rosetta welcher <num> Jean-François Champollion die Entzifferung der Hieroglyphen ermöglichte
+Von besonderer Bedeutung für die ägyptische Archäologie ist Auguste Mariette <num>-<num> welcher ab <num> als Direktor des ägyptischen Altertümerdienstes mehr als dreißig Fundstätten ausgrub
+Seine Methoden waren brachial beispielsweise Sprengladungen
+Die Feststellung der Fundumstände und wissenschaftliche Auswertungen waren damals noch nicht festgelegt aber er beendete die Ära der reinen Schatzsucher so Giovanni Battista Belzoni <num>-<num> welche zuvor zahllose Funde nach Europa geschafft hatten
+Mariette selbst hat seit <num> rund <num> Objekte nach Paris Louvre gebracht
+Nun setzte er sich jedoch vehement dafür ein dass Ägyptens Altertümer nicht mehr außer Landes verschleppt wurden
+Zur Aufbewahrung der Funde gründete Mariette den Vorläufer des Ägyptischen Nationalmuseums in Kairo
+Karl Richard Lepsius <num>-<num> erstellte zwischen <num> und <num> eine umfassende Aufnahme ägyptischer und nubischer Denkmäler
+<num> wurde das Ergebnis in den zwölf Bänden der Denkmaeler aus Aegypten und Aethiopien veröffentlicht welche allein <num> Farbtafeln enthalten
+Um die archäologische Erforschung Griechenlands machte sich um <num> besonders Ludwig Ross verdient der als erster systematische Ausgrabungen auf der Akropolis von Athen durchführte
+Ab Mitte des <num> Jahrhunderts
+Mitte des <num> Jahrhunderts entwickelt sich die Archäologie zunehmend zur Wissenschaft
+Unterscheiden sich die Ausgräber bisher nur unwesentlich von Schatzsuchern und Grabräubern werden nun die Grabungstechniken verfeinert eine gute Dokumentation und exakte Einordnung der Funde immer wichtiger
+Antoine Ives Goguet <num>-<num> hat bereits <num> die Auffassung vertreten es müsse drei Stufen prähistorischer Technologie Steinzeit Bronzezeit Eisenzeit gegeben haben
+Durchsetzen konnte sich das Dreiperiodensystem jedoch erst mit dem Dänen Christian Jürgensen Thomsen <num>-<num> welcher erstmals ein Museum <num> nach diesem Prinzip ordnet
+Sir John Lubbock <num>-<num> führt <num> eine weitere Unterteilung der Steinzeit in Paläolithikum Altsteinzeit und Neolithikum Jungsteinzeit ein
+Erst ab <num> wird das hohe Alter der Menschheit allgemein anerkannt
+Im selben Jahr erscheint Darwins
+Über die Entstehung der Arten
+Der bereits <num> entdeckte Fund des Neandertalers welcher von Johann Carl Fuhlrott und Hermann Schaaffhausen vergeblich als eiszeitlich eingestuft wurde kann sich als solcher in Deutschland erst ab <num> durchsetzen als Rudolf Virchow stirbt der als pathologische Autorität jede weiterführende Diskussion unterbunden hatte
+In Schweden entwickelt Oscar Montelius <num>-<num> ein System der differenzierten Typologie zur Einordnung Periodisierung von Fundstücken und schafft die Grundlage einer relativen Chronologie
+<num><num> werden aufgrund eines ungewöhnlich niedrigen Wasserstandes bei Obermeilen am Zürichsee hölzerne Pfeiler Steinbeile und Keramik entdeckt
+Die Siedlung wird von Ferdinand Keller untersucht
+Lange Zeit glaubt man bei diesen Feuchtbodensiedlungen habe es sich um Pfahlbauten im Wasser gehandelt
+Ab den <num>er Jahren entspann sich eine heftige Diskussion um die Lage der Pfahlbauten
+Es konkurrierten Ufer- und Wasserpfahlbauten
+Heute weiß man dass es Land- und Wasserpfahlbauten gab
+Die neuen Untersuchungen in Hornstaad am Bodensee belegen Pfahlbauten im Wasser bis zu <num> Meter vom Seeboden abgehoben
+Rekonstruktionen beispielsweise in Unteruhldingen am Bodensee zeigen nicht nur die verschiedenen Lösungsvorschläge der Archäologie sondern auch den aktuellen Forschungsstand nach den Befunden der Unterwasserarchäologie Pfahlbaumuseum Unteruhldingen
+<num> beginnen die Ausgrabungen in Hallstatt
+Die archäologische Erforschung der Kelten beginnt <num> als Oberst Schwab die ersten Ausgrabungen in La Tène am Neuenburgersee Schweiz durchführt
+<num> wird die Eisenzeit Europas erstmals in eine ältere Phase Hallstattzeit und einer jüngeren Latènezeit unterteilt
+Édouard Lartet <num>-<num> untersucht <num> eine Fundstätte in den Pyrenäen Massat und findet dabei auch eine Geweihspitze mit eingraviertem Bärenkopf der erste Fund jungpaläolithischer Kunst
+Später gräbt er mehrere französische Höhlenfundplätze Gorge dEnfer Laugerie Haute La Madeleine und Le Moustier aus
+Besondere Aufmerksamkeit erlangen die großartigen Höhlenmalereien welche <num> in der Höhle von Altamira entdeckt werden
+Die Entwicklung der Klassischen Archäologie in der zweiten Hälfte des <num> Jahrhunderts wird von Heinrich Schliemann <num>-<num> dominiert
+Der Geschäftsmann und Hobbyarchäologe Schliemann gilt als Begründer der Vorgeschichtsarchäologie Griechenlands und des ägäischen Raumes
+<num> gräbt er auf Ithaka und <num> beginnt er in Hissarlik zu graben
+Dort vermutet er das Troja Homers und wird recht behalten obwohl er sich in der Bauperiode selbst täuschte
+Seine Ausgrabungsmethoden waren sehr umstritten so mancher Fachmann hält von Schliemanns Fähigkeiten nichts
+Sein Ruhm stützt sich vor allem auf die wertvollen Funde beispielsweise Schatz des Priamos Seine Entdeckung prähistorischer vorhomerischer Kulturen und Siedlungen löst zahlreiche weitere Grabungen im ägäischen Raum aus
+Lange unterschätzt wurden die durch ihn bewirkten methodischen Fortschritte wie die Betonung der Stratigraphie oder der Einsatz der Fotografie als Mittel der archäologischen Dokumentation
+<num> erhielt der Gründer des Instituts für Ur- und Frühgeschichte an der Universität Wien Moritz Hoernes die erste das Gesamtgebiet der Prähistorischen Archäologie umfassende Lehrbefugnis Europas
+<num> und <num> Jahrhundert
+DateiHoward carterjpg DateiBarzanjpg In Ägypten leistet ab <num> Sir William Matthew Flinders Petrie <num>-<num> als Forscher und Ausgräber Pionierarbeit
+Ein Meilenstein der archäologischen Forschung sind seine Methoden und Ziele der Archäologie die er <num> veröffentlicht
+Darin legt Flinders Petrie vier Prinzipien dar
+Sorgfalt im Umgang mit den Monumenten die man ausgräbt und Rücksichtnahme auf potenzielle künftige Ausgräber
+peinliche Sorgfalt bei der Ausgrabung und Registrierung jedes vorgefundenen Details
+detaillierte und saubere Vermessung und Kartierung
+komplette Veröffentlichung der Resultate
+<num> erscheint der erste Band des Handbuchs der Archäologie Herausgeber ist Heinrich Bulle <num>-<num>
+Als vorbildliche Grabung dieser Zeit gilt die <num> begonnene Ausgrabung des Gräberfeldes von Assini Argolis welche von schwedischen Archäologen vorgenommen wird
+Der gesamte Aushub wird gesiebt und eine erstklassige Grabungsdokumentation erstellt
+Der berühmteste archäologische Fund des <num> Jahrhunderts gelingt Howard Carter <num>-<num> im selben Jahr
+Er findet nach sechsjähriger Suche das Grab des Tut-anch-Amun
+Pionier der Luftbildarchäologie war nach dem Ersten Weltkrieg der britische Pilot Osbert G S Crawford er fotografiert vom Flugzeug aus archäologische Fundstätten in England
+Gustaf Kossinna <num>-<num> stellt <num> seine siedlungsarchäologischen Methoden vor
+Seine Interpretationen welche den Germanen eine überragende kulturelle Bedeutung zuschreiben dienen dem Nationalsozialismus als Beweis für die Überlegenheit der Germanen und der arischen Rasse
+Die Diskreditierung in der Nachkriegszeit führte dazu dass auf Jahrzehnte eine Anbindung archäologischer Funde an ethnische Gruppen obsolet war
+Die erste ordentliche Professur wurde <num> in Marburg geschaffen und im folgenden Jahr mit Gero Merhart von Bernegg aus Bregenz besetzt
+Er hatte sich <num> mit Die Bronzezeit am Jenissei habilitiert
+Bei ihm promovierten bis zu seiner Zwangspensionierung durch die Nationalsozialisten im Jahr <num> <num> Studenten nach dem Krieg kamen fünf weitere hinzu
+Ab <num> dominierte in Deutschland die Marburger Schule die diese Akademiker bildeten
+Gero von Merhart wie er meist genannt wird legte das Fach auf strenge Erfassung Systematisierung und Katalogisierung fest und mied weitgehend die kulturgeschichtliche Deutung
+Thor Heyerdahl fuhr <num> mit einem Floß von Südamerika nach Polynesien und kann als einer der Begründer der Experimentellen Archäologie betrachtet werden
+Im <num> Jahrhundert greift die Archäologie vermehrt auf Techniken anderer Wissenschaften zurück
+Als Beispiele seien die <num> entwickelte C-Datierung zur Datierung von organischen Stoffen und die Strontiumisotopenanalyse zur Erforschung der Wanderbewegungen der ur- und frühzeitlichen Menschen genannt
+Die Archäologie hat sich zur Verbundwissenschaft entwickelt
+Die Erforschung der <num> in den Ötztaler Alpen gefundenen vorgeschichtlichen Leiche Similaun-MannÖtzi ist hierfür beispielhaft
+Mit Hilfe der DNA-Analyse konnten weltweit erstmals die Verwandtschaftsbeziehungen von <num> Individuen aus einer bronzezeitlichen Begräbnisstätte in der Lichtensteinhöhle rekonstruiert werden
+Die New Archaeology der <num>er Jahre brachte die Forderung Erkenntnisse aus Lebenswissenschaften in die Archäologie einzuführen
+Das Konzept der Tragfähigkeit stammt aus der Ökologie und wurde angewandt um Fragen von Bevölkerungsdichte und Siedlungsentwicklung zu untersuchen
+Optimal Foraging konnte Reaktionen auf Klimaveränderungen gleichermaßen erklären wie jahreszeitliche Wanderungen und Landnutzungsformen
+Zudem wurden mathematische Simulationen und Modellbildungen und computergestützte Geoinformationssysteme als Methoden in die Archäologie eingebracht
+Die New Archaeology war besonders im angelsächsischen Kulturraum stark entwickelt und konnte sich im deutschen Sprachraum nie durchsetzen
+Als Grund gilt dass in der angelsächsischen Tradition die Archäologie traditionell zur Anthropologie gehört nicht zu den Geschichts- oder Kulturwissenschaften
+Als Antwort auf die New Archaeology entstand in den <num>er Jahren die Postprozessuale Archäologie die Methoden aus den Kultur- und Sozialwissenschaften stärker in den Vordergrund rückte
+Ein Kernbegriff ist die aus der Soziologie stammende Agency die Handlungsmotive und -optionen betrachtet
+Berücksichtigt man zusätzlich die inhärente Subjektivität jeglicher Interpretation einer Kultur von der nur die materiellen Artefakte erhalten sind setzen postprozessuale Archäologen auf hermeneutische einerseits und selbstreflektierende Praktiken andererseits
+Heutige Nachfahren der zu untersuchenden Kulturen werden gleichermaßen in die Arbeit der Archäologen einbezogen wie bislang vernachlässigte soziale Perspektiven
+Zusammen mit anderen Gedächtnisinstitutionen sind archäologische Funde und Ausgrabungsstätten das besonders sensible kulturelle Gedächtnis und oft wirtschaftliche Grundlage z B
+Tourismus eines Staates einer Kommune oder einer Region
+Gerade archäologische Funde und Ausgrabungsstätten haben auch politische Brisanz und sind in vielen bewaffneten modernen Konflikten des <num> Jahrhunderts als Teil des kulturellen Erbes eines der Primärziele und damit von Zerstörung und Plünderung bedroht
+Oft soll dabei das kulturelle Erbe des Gegner nachhaltig beschädigt oder gar vernichtet werden beziehungsweise werden dabei archäologische Funde gestohlen und verbracht
+Internationale und nationale Koordinationen hinsichtlich militärischer und ziviler Strukturen zum Schutz von archäologische Funde und Ausgrabungsstätten betreibt das Internationale Komitee vom Blauen Schild Association of the National Committees of the Blue Shield ANCBS mit Sitz in Den Haag
+Umfangreiche Missionen dazu gab es zum Beispiel <num> in Agypten und in Libyen <num> in Syrien <num> in Mali bzw im Irak und seit <num> im Jemen
+Fachgebiete
+Archäologie ist ein Sammelbegriff vieler archäologischer Disziplinen welche meist bestimmte Zeitabschnitte oder Regionen bezeichnen
+Die einzelnen Disziplinen unterscheiden sich nicht nur im behandelten Forschungsgegenstand sondern auch in den verwendeten Methoden z B
+bei der Unterwasserarchäologie
+Daneben bilden archäologische Methoden einen Teilaspekt einer eigenständigen Wissenschaft beispielsweise in der Forensik
+In Fächern wie der Altamerikanistik oder auch der Klassischen Archäologie können die inhaltlichen Schwerpunkte nicht-archäologischer Natur sein
+Nach Epochen und Regionen
+Die Disziplinen der Archäologie unterscheiden sich thematisch zeitlich und räumlich
+Dementsprechend unterschiedlich sind die Quellen derer sie sich bedienen
+Während in der Prähistorischen Archäologie keine oder sehr spärlich schriftliche Quellen vorliegen und man sich vorwiegend auf die materiellen Hinterlassenschaften dieses Zeitabschnitts beruft können andere archäologische Fachrichtungen zusätzlich Schriftquellen auswerten
+Prähistorische Archäologie oder Vor- Ur- und Frühgeschichte
+Die Prähistorische Archäologie befasst sich mit einem Zeitraum welcher mit den ersten Steingeräten vor etwa <num> Millionen Jahren beginnt und mit der Frühgeschichte Völkerwanderungszeit Römische Kaiserzeit frühes Mittelalter und den ersten Schriftquellen endet
+Provinzialrömische Archäologie
+Dieses Spezialgebiet ist in der Schnittstelle zwischen der Ur- und Frühgeschichte und der Klassischen Archäologie angesiedelt
+Mit den Methoden der Ur- und Frühgeschichte sind die römischen Provinzen Ziel der Forschung
+Klassische Archäologie
+Der Schwerpunkt der Klassischen Archäologie liegt in den Hinterlassenschaften der antiken Welt
+Genauer der Griechen Etrusker und Römer in historischer Zeit etwa zwischen dem <num> Jahrtausend v Chr und dem <num> Jahrhundert n Chr Zur Klassischen Archäologie zählen auch die
+Etruskologie
+und die Ägäische Vorgeschichte die sich mit kykladischen minoischen und mykenischen Funden befasst
+Mittelalterarchäologie oder Archäologie des Mittelalters
+Die Mittelalterarchäologie beginnt fließend mit dem Ende der Frühgeschichte etwa <num> Jahrhundert und endet theoretisch mit dem Übergang zur Neuzeitarchäologie ca <num> Jahrhundert
+Im Unterschied zur prähistorischen Archäologie arbeitet sie in einem Zeitraum über den in zunehmendem Maße auch Schriftquellen vorliegen
+Zudem ist häufig aufgehender Baubestand vorhanden den die Archäologie des Mittelalters mit den Methoden der historischen Bauforschung Bau- oder Monumentenarchäologie untersucht
+Neuzeitarchäologie
+Historische Archäologie
+Historische Archäologie ist ein Begriff der die Parallelüberlieferung von materiellen archäologischen Quellen und schriftlicher Überlieferung umschreibt
+Er wird einerseits pragmatisch für die Archäologie des Mittelalters und der Neuzeit oder nur die der Neuzeit verwendet
+Im methodologisch-phänomenologischen Sinne zielt er andererseits weltweit auf Kulturen bzw Epochen mit sogenannter dichter schriftlicher Überlieferung ab
+Die nachfolgenden Disziplinen stellen geografische Schwerpunkte dar
+Ägyptologie
+Die Ägyptologie befasst sich mit dem antiken Ägypten etwa <num> Jahrtausend v Chr bis <num> Jahrhundert n Chr Die
+Koptologie
+welche die Kultur der frühen Christen in Ägypten untersucht ist ein Teilbereich der Ägyptologie
+Vorderasiatische Archäologie
+Dieses Fachgebiet geht aus der überwiegend philologisch ausgerichteten Altorientalistik hervor und widmet sich den alten Kulturen des Nahen Ostens im Wesentlichen das Gebiet der Türkei des Iraks des Irans Syriens Libanons Israels und Jordaniens Babylon Assyrien Sumer Akkad Elam Hethiter und Urartu aber auch mit den Nachfolgestaaten
+Der untersuchte Zeitraum reicht vom <num> Jahrtausend v Chr
+bis zum <num> Jahrhundert n Chr
+Die Vorderasiatische Archäologie steht in enger Verbindung zur Biblischen Archäologie welche die Siedlungs- und Kulturgeschichte Palästinas erforscht und der Ägyptologie da in manchen Epochen Ägypten das Gebiet des heutigen Israel und Libanon beherrschte sich zu anderen Zeiten orientalische Reiche Ägypten einverleibten
+Archäologie der Neuen Welt ein Teilgebiet der Altamerikanistik
+Spezialgebiete
+DateiVorgeschichtlicher korbjpg
+Nach Phasen und Aspekten der kulturellen Entwicklung
+Primatenarchäologie früheste Phase der Menschheit erste Werkzeuge
+Siedlungsarchäologie ab dem Neolithikum
+Montanarchäologie Bergbau und Hüttenwesen ab der Bronzezeit
+Christliche Archäologie vor allem Spätantike
+Kirchenarchäologie
+Rechtsarchäologie vor allem Mittelalter
+Industriearchäologie
+Nach besonderen Fundplätzen
+Gletscherarchäologie
+Küstenarchäologie
+Schlachtfeldarchäologie Zeithorizont Bronzezeit bis <num> Jahrhundert
+Stadtarchäologie Grabungen in heutigen Städten
+Trassenarchäologie entlang von Bahn- Kanal- Leitungs- und Straßenbaumaßnahmen
+Unterwasserarchäologie
+Besondere Untersuchungsgegenstände
+Textilarchäologie Kleidung
+Musikarchäologie Musikinstrumente
+Besondere Fragestellungen
+Kognitive Archäologie Frage nach dem damaligen Bewusstsein
+Archäologische Geschlechterforschung Frage nach den damaligen Rollen der Geschlechter
+Besondere Methoden
+Archäoinformatik Einsatz moderner Datenverarbeitung
+Archäometrie Einsatz moderner naturwissenschaftlicher Methoden
+Geoarchäologie Einsatz geowissenschaftlicher Methoden
+Luftbildarchäologie
+Experimentelle Archäologie
+Hilfswissenschaften
+Archäozoologie und Archäobotanik Schnittstelle zur Biologie
+Analyse von Tierknochen- Pollen- und Pflanzenfunden um die Umweltbedingungen zu rekonstruieren
+Zu den Untersuchungsobjekten gehören Bodenproben ebenso wie Mageninhalte Abfallgruben und Latrinen
+Paläopathologie Schnittstelle zur Medizin
+Paläopathologen führen medizinische Untersuchungen an menschlichen Knochen und Geweben durch um Alter und Geschlecht der Individuen zu bestimmen und auf ihren Gesundheitszustand zu schließen
+Die Paläopathologie ermöglicht Erkenntnisse über Lebensbedingungen Ernährungsgewohnheiten und Krankheiten
+Des Weiteren sind Rückschlüsse auf die medizinische Versorgung und den sozialen Zusammenhalt unserer Vorfahren möglich
+Archäoastronomie oder Astroarchäologie auch Paläoastronomie Schnittstelle zur Astronomie
+Zur Analyse prähistorischer Kultstätten wird die Archäoastronomie benötigt
+Beispielsweise werden die Sonnwendpunkte einer bestimmten Zeit berechnet um die mögliche astronomische Bedeutung von Fundstätten zu erschließen
+Historische Bauforschung Schnittstelle zur Architektur
+Nachbardisziplinen
+Geschichtswissenschaft
+Anthropologie
+Paläontologie
+Geophysik
+Numismatik
+Epigraphik
+Paläographie
+Philologie
+Historische Klimatologie und Paläoklimatologie
+Forschungsmethoden
+Archäologische Forschungsmethoden gliedern sich in solche der Quellenerschließung und solche der Interpretation
+In der Öffentlichkeit wird meist nur die Erschließung der Quellen zur Kenntnis genommen
+Zur Quellenerschließung zählt auch die typologische und chronologische Auswertung
+Erst nach der Quellenerschließung und Aufbereitung folgt die historische Interpretation
+Quellenerschließung
+Die Ausgrabung ist zwar die bekannteste Forschungsmethode jedoch nur ein kleiner Teilbereich der archäologischen Arbeit
+Die Dokumentation Auswertung Konservierung und Archivierung der Funde stellt den weitaus größten Teil der archäologischen Tätigkeit dar
+Außerdem muss die Grabung sorgfältig vorbereitet werden
+Prospektion und Voruntersuchungen
+Die Prospektion umfasst zerstörungsfreie Methoden mit deren Hilfe eine Untersuchung potenzieller oder bekannter Fundplätze ermöglicht wird
+Dazu gehören die Geländebegehung Survey die Luftbildarchäologie und geophysikalische Methoden Geoelektrik elektromagnetische Induktion geomagnetische Kartierung sowie Bodenradar und LIDAR
+Ebenfalls prospektiv einsetzen lässt sich die Phosphatanalyse
+Eingeleitet wird eine Ausgrabung durch archäologische Voruntersuchungen
+Zum Einsatz kommen hier Suchgräben magnetische Sondierung Bodenwiderstandsmessung Luftbilder und andere Methoden der Bodenforschung
+Die Voruntersuchungen dienen dazu sich ein Bild der potenziellen Grabungsstelle zu machen um die eigentliche Grabung besser planen zu können
+Ausgrabung
+DateiArchäologie schichtengrabungjpg Die meisten Fundplätze werden heute durch Baumaßnahmen entdeckt
+Über Notgrabungen auch Rettungsgrabungen genannt versucht die archäologische Denkmalpflege diese Befunde vor ihrer endgültigen Zerstörung auszuwerten
+Seltener sind Forschungsgrabungen bei denen unter primär wissenschaftlichen Interessen Fundplätze zur Grabung ausgewählt und ohne äußeren Zeitdruck untersucht werden können
+Bei der Grabung werden verschiedene Grabungstechniken angewandt
+Eine moderne Grabung ist befundorientiert d h
+die Funde werden in ihrer räumlichen und zeitlichen Einbettung auf Befunde bezogen
+Da jede Ausgrabung zur Zerstörung eines Befundes führt soll eine exakte Dokumentation den Fundplatz zumindest auf dem Papier auch später bis ins Detail rekonstruierbar machen
+Die wichtigsten Arbeitsmittel der Ausgrabung sind deshalb neben der Kelle Papier und Buntstift
+Bauforschung
+Die Bauforschung ist ein wesentlicher Teil sowohl der klassischen Archäologie als auch der Archäologie des Mittelalters wohingegen sie in der Ur- und Frühgeschichte mangels aufgehend erhaltener Bauwerke nur eine untergeordnete Rolle spielt
+Eine der Dokumentationsmethoden ist die Photogrammetrie
+Auswertung
+Gerade am sehr populären Beispiel der Gletschermumie Ötzi ist zu erkennen dass die Ausgrabung nur einen Bruchteil der archäologischen Arbeit darstellt
+Der <num> entdeckte Fund wird bis heute wissenschaftlich untersucht
+Typologie
+Die Typologie ist die Klassifikation von Objekten nach Kriterien von Form und Material
+Sie ist grundlegend für die Einordnung des Fundmaterials da sie Vergleiche mit Fundsituationen an anderen Fundplätzen ermöglicht und zur Grundlage von Kombinationsanalysen zur relativchronologischen Datierung wie zur sozioökonomischen Einordnung und Verbreitungsanalysen wird
+Materialbestimmungen
+Wie bei der Prospektion und der Altersbestimmung werden auch für Materialbestimmungen moderne naturwissenschaftliche Techniken eingesetzt siehe Archäometrie
+Zur Identifikation und Detailuntersuchung von Artefakten dienen u a die Mikroskopie Infrarot- und Ultraschallaufnahmen Röntgen chemische Analysen Spektralanalysen und Laserscans
+Altersbestimmung
+DateiDendrochronologiejpg Ein Schwerpunkt der Fundanalyse ist die Datierung der Befunde z B
+Grab anhand der Funde z B
+Grabbeigabe
+Bei der Altersbestimmung wird zwischen absoluter Chronologie und relativer Chronologie unterschieden
+Die relative Chronologie setzt einen Fund dabei in Bezug zu einem anderen
+Ist er jünger älter oder gar gleichzeitig
+JJ
+Winckelmanns vergleichendes Sehen ist eine der ersten Methoden zur relativen Chronologie
+Fundkombination von geschlossenen Funden siehe auch Seriation und Korrespondenzanalyse
+Chorologie
+Stratigraphie
+Bei der absoluten Chronologie wird ein Fund ein absolutes Datum Jahr Jahrhundert zugeordnet
+C-Datierung für organische Stoffe
+Thermolumineszenzdatierung auch TL-Datierung für Keramik
+Dendrochronologie für Holz
+Kalium-Argon-Methode für Gestein
+Interpretation
+Die Methoden der Interpretation sind in der Regel eher geisteswissenschaftlich
+Für die prähistorische Archäologie ist der Analogieschluss die wesentliche Möglichkeit der Interpretation
+In der historischen Archäologie z B
+Klassische Archäologie oder Archäologie des Mittelalters ist es der Vergleich mit Informationen aus anderen Quellen wie schriftlicher oder bildlicher Überlieferung
+Funde
+Archäologie in Deutschland
+In Deutschland gehört die Archäologie zu den Aufgaben der Bundesländer Landesarchäologe meist als Bereich des Denkmalamtes als Bodendenkmalpflege organisiert
+Größere Städte haben oft eine eigene Stadtarchäologie
+Mehrere Institutionen fördern Forscher und Projekte durch Archäologiepreise
+Deutsche Grabungen im Ausland werden hingegen im Rahmen von Forschungsprojekten der Universitäten des Deutschen Archäologischen Instituts oder des Römisch-Germanischen Zentralmuseums durchgeführt
+Archäologie außerhalb Europas
+Archäologie in Amerika
+Die Archäologie gehört in Amerika zur Anthropologie Völkerkunde und hat aus diesem Grund eine völlig andere Ausrichtung als die europäische Forschung
+Dies folgt vor allem aus dem Umstand dass zum Zeitpunkt der Besiedlung der neuen Welt zuerst ethnographische Untersuchungen an noch existierenden Ureinwohnern stattfanden
+Die eher spärlichen präkolumbischen Funde sind ein weiterer Grund für den in der Erforschung kultureller Prozesse liegenden Schwerpunkt amerikanischer Archäologie
+Als Pionier der amerikanischen Archäologie gilt Thomas Jefferson <num>-<num> welcher ab <num> einige Grabhügel untersucht um ihr Alter zu bestimmen
+Jefferson setzt dabei erstmals eine Methode ein die als Vorläufer der Dendrochronologie angesehen werden kann er zählt die Jahresringe der auf den Grabhügeln stehenden Bäume
+Die ersten großen Ausgrabungen in Mittelamerika werden Ende des <num> Jahrhunderts im Mayazentrum Copán durchgeführt
+<num> entdeckt Hiram Bingham die Inkastadt Machu Picchu
+Im Jahre <num> fanden Archäologen in der Nähe von Mexiko-Stadt über <num> Artefakte aus der Zeit der spanischen Eroberung des Landes
+Man fand nicht nur menschliche Knochen sondern auch Waffen Kleidung Haushaltsgeräte und Gegenstände aus dem persönlichen Besitz von Hernán Cortés
+Die Fundstelle Tecoaque vorspanischer Name Zultepec wurde als Weltkulturerbe vorgeschlagen
+Archäologie in Indien und China
+<num> wird in Indien die Archaeological Survey of India gegründet
+<num><num> entdeckt man eine der ältesten Hochkulturen der Menschheit die Indus-Kultur
+Ausgegraben werden u a die Städte Harappa und Mohenjo-Daro
+Archäologie in China beginnt mit dem schwedischen Geologen J Gunnar Andersson <num>-<num> der <num> bei Yang Shao Tsun in Honan eine neolithische Wohnhöhle entdeckt und damit beweist dass China in vorgeschichtlicher Zeit bewohnt war
+<num> wird Anyang ausgegraben die Hauptstadt der Shang-Dynastie des <num> Jahrtausends v Chr
+<num> wird die Terrakottaarmee rund um das Grab des chinesischen Kaisers Qin Shihuangdi bei Xian entdeckt
+Archäologie in Afrika
+Afrika ist nicht nur in paläoanthropologischer Hinsicht die Wiege der Menschheit sondern auch die unserer Kultur
+Nur in Afrika kommen Steingeräte vor die <num> Millionen Jahre alt sind und deren Herstellung mit den ersten Homo-Arten unserer Spezies in Verbindung gebracht wird
+Die betreffenden Werkzeuge - einfache Geröllgeräte vom Oldowan-Typ später die Faustkeile um die Leitformen zu nennen - kommen auch in anderen Teilen der Welt vor nur sind sie dort deutlich jünger
+In Europa datieren die ältesten Stellen auf eine Million Jahre
+Neue etwa <num> Millionen Jahre alte Funde in Lomekwi <num> Kenia werden als Beleg für eine eigenständige archäologische Kultur interpretiert vorschlagsweise Lomekwian genannt
+Bereits seit dem <num> Jahrhundert ist der Nordosten Afrikas Gegenstand intensiver Forschungen durch die Ägyptologie und Koptologie
+Diese Region des Kontinents ist auch im internationalen Vergleich hervorragend dokumentiert
+Da jedoch die ältesten Schriftquellen im subsaharischen Afrika nicht weiter als <num> Jahre zurückreichen kommt der Archäologie gerade hier eine besondere Bedeutung zu
+Aufgrund der kurzen Forschungstradition im Vergleich zu Mitteleuropa steht man hier allerdings noch vielfach am Anfang
+Aufbereitung für die Öffentlichkeit und Schutz
+Die Vermittlung archäologischer Forschungsergebnisse erfolgt auf verschiedene Weise
+durch Fachbücher und Fachzeitschriften
+durch populärwissenschaftliche Publikationen
+in Museen vgl
+im Gelände Oberirdisch sichtbare Bodendenkmäler können durch Ausschilderung oder im Rahmen eines Wanderlehrpfades erschlossen werden vgl Archäologische Wanderung wie zum Beispiel der Archäologisch-naturkundliche Wanderweg Lübeck
+In einem Archäologischen Park treten zumeist Rekonstruktionen hinzu
+Rekonstruktionen oder der Wiederaufbau sind wissenschaftlich sehr umstritten da eine Rekonstruktion immer spekulativ ist und nur den aktuellen Wissensstand widerspiegelt
+Zudem oftmals gefärbt durch den herrschenden Zeitgeist
+Es ergeben sich jedoch auch Schnittstellen zur Experimentellen Archäologie indem die Machbarkeit und der Praxisbezug einer Theorie überprüft werden können
+durch Führungen
+durch museumsdidaktische Vorführungen meist als Experimentelle Archäologie deklariert
+Vielerorts bestehen regionale Gesellschaften und Vereine die sich der Archäologie widmen und entsprechende Aktionen tragen siehe Liste der Archäologischen Gesellschaften in Deutschland
+Zunehmend wird international auch der Schutz der archäologischen Funde für die Öffentlichkeit im Hinblick auf Katastrophen Kriege und bewaffnete Auseinandersetzungen durchgesetzt
+Das geschieht einerseits durch internationale Abkommen und andererseits durch Organisationen die den Schutz überwachen beziehungsweise durchsetzen
+Als weltweites Beispiel gilt Blue Shield International mit seinen Archäologen und lokalen Partnerorganisationen
+Die Wichtigkeit der archäologischen Funde im Bezug auf Identität Tourismus und nachhaltiges Wirtschaftswachstum werden immer wieder betont
+So wurde auch vom Präsident von Blue Shield International Karl von Habsburg bei einem Kulturgutschutz-Einsatz im April <num> im Libanon mit der United Nations Interim Force in Lebanon erläuterte Kulturgüter sind ein Teil der Identität der Menschen die an einem bestimmten Ort leben
+Zerstört man ihre Kultur so zerstört man damit auch ihre Identität
+Viele Menschen werden entwurzelt haben oft keine Perspektiven mehr und flüchten in der Folge aus ihrer Heimat
+Archäologische Institute
+Film
+Unter dem Boden ein Film von Erich Langjahr
+Literatur
+Buchpublikationen
+chronologisch sortiert
+Einführungen
+Hans Jürgen Eggers Einführung in die Vorgeschichte Piper München <num> <num> Neuaufl
+scrîpvaz Berlin <num>
+ISBN <num>-<num>-<num>-<num> Nachdruck des Werks von <num> daher nur die traditionellen Methoden neue Ansätze fehlen
+Johannes Bergemann Orientierung Archäologie - was sie kann was sie will Rowohlt Reinbek bei Hamburg <num>
+ISBN <num>-<num>-<num>-X Klassische Archäologie
+Colin Renfrew Paul G Bahn Archaeology - Theories Methods and Practice
+<num> Auflage London <num> ISBN <num>-<num>-<num>-<num>-<num> gute englischsprachige Einführung gekürzte deutsche Übersetzung von Helmut Schareika Basiswissen Archäologie
+Theorien - Methoden - Praxis
+Philipp von Zabern Mainz <num> ISBN <num>-<num>-<num>-<num>-<num>
+Manfred K H Eggert Prähistorische Archäologie
+Konzepte und Methoden
+<num> überarb
+Aufl UTB Francke Tübingen Basel <num>
+ISBN <num>-<num>-<num>-<num>-<num>
+Manfred K H Eggert Stefanie Samida Ur- und frühgeschichtliche Archäologie <num> Aufl UTB Tübingen <num>
+ISBN <num>-<num>-<num>-<num>-<num>
+Barbara Scholkmann - Hauke Kenzler - Rainer Schreg Hrsg Archäologie des Mittelalters und der Neuzeit
+Grundwissen Darmstadt Wiss Buchgesellschaft <num> ISBN <num>
+Überblick
+Paul G Bahn Hrsg Archaeology
+Cambridge Illustrated History
+Cambridge University Press Cambridge <num>
+ISBN <num>-<num>-<num>-<num>
+Reinhard Bernbeck Theorien in der Archäologie UTB Wissenschaft Band <num>
+Francke Verlag Tübingen Basel <num> ISBN <num>-<num>-<num>-X ISBN <num>-<num>-<num>-<num>
+Marion Benz Christian Maise Archäologie Theiss Stuttgart <num>
+ISBN <num>-<num>-<num>-<num>
+Manfred K H Eggert Archäologie
+Grundzüge einer Historischen Kulturwissenschaft
+Francke Tübingen <num>
+ISBN <num>-<num>-<num>-<num>
+Der Brockhaus Archäologie
+Hochkulturen Grabungsstätten Funde
+FA
+Brockhaus MannheimLeipzig <num> ISBN <num>-<num>-<num>-<num>-<num>
+Alain Schnapp Die Entdeckung der Vergangenheit
+Ursprünge und Abenteuer der Archäologie
+aus dem Französischen von Andreas Wittenburg
+Klett-Cotta Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num> Rezension von Lutz Bunk Archäologische Detektivarbeit
+Jeorjios Martin Beyer Archäologie
+Von der Schatzsuche zur Wissenschaft
+Philipp von Zabern Mainz <num> ISBN <num>-<num>-<num>-<num>-<num>
+Matthias Knaut Roland Schwab Hrsg Archäologie im <num> Jahrhundert
+Innovative Methoden - bahnbrechende Ergebnisse
+Konrad Theiss Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Geoffrey John Tassie Lawrence Stewart Owens Standards of Archaeological Excavations A Fieldguide to the Methology Recording Techniques and Conventions London <num> ISBN <num>-<num>-<num>-<num>-<num>
+Marco Kircher Wahre Archäologie
+Die Medialisierung archäologischen Wissens im Spannungsfeld von Wissenschaft und Öffentlichkeit Reihe Historische Lebenswelten
+transcript
+Verlag für Kommunikation Kultur und soziale Praxis Bielefeld <num> ISBN <num>-<num>-<num>-<num>-<num>
+Aedeen Cremin Große Enzyklopädie der Archäologie
+Die wichtigsten archäologischen Stätten der Welt
+Konrad Theiss Stuttgart <num> ISBN <num>-<num>-<num>-<num>-<num>
+Bruce Trigger A History of Archaeological Thought
+Cambridge University Press Cambridge <num>
+ISBN <num>-<num>-<num>-<num>
+S Wolfram und U Sommer Macht der Vergangenheit - Wer macht Vergangenheit
+Archäologie und Politik
+In Beiträge zur Ur- und Frühgeschichte Mitteleuropas
+Band <num> Beier
+Beran Wilkau-Hasslau <num>
+Archäologie in Deutschland
+Martin Kuckenburg Siedlungen der Vorgeschichte in Deutschland <num> <num> bis <num> v Chr DuMont Köln <num>
+ISBN <num>-<num>-<num>-<num>
+Wilfried Menghin Dieter Planck Hrsg Menschen Zeiten Räume Archäologie in Deutschland Theiss Stuttgart <num>
+ISBN <num>-<num>-<num>-<num>
+Uta von Freeden Siegmar von Schnurbein Hrsg Spuren der Jahrtausende
+Archäologie und Geschichte in Deutschland
+Theiss Stuttgart <num>
+ISBN <num>-<num>-<num>-<num> Zusammen mit dem nächsten Band die Leistungsschau der deutschen Landesarchäologien
+Archäologie in Europa
+Barry Cunliffe Illustrierte Vor- und Frühgeschichte Europas Campus FrankfurtMain <num>
+ISBN <num>-<num>-<num>-<num>
+Schriftenreihen
+Grazer altertumskundliche Studien Verlag Peter Lang Frankfurt am Main u a
+Archäologische Berichte der Deutschen Gesellschaft für Ur- und Frühgeschichte
+Archäologische Zeitschriften
+Wörterbücher
+Heinrich Otte Archäologisches Wörterbuch zur Erklärung der in den Schriften über christliche Kunstalterthümer vorkommenden Kunstausdrücke Deutsch Lateinisch Französisch und Englisch Leipzig <num> Reprint der Originalausgabe durch Reprint-Verlag Leipzig <num> ISBN <num>-<num>-<num>-<num>
+Online-Publikationen
+Guido Nockemann The DAS Project - Digitization of an archaeological collection <num> e-paper for the Day Of Archaeology <num> englisch
+Literaturrecherche
+Propylaeum Fachinformationsdienst Altertumswissenschaften
+Weblinks
+Internet-Portal zur Archäologie Der mit großem Abstand umfangreichste deutschsprachige Zugang zur Archäologie im Internet wird ständig aktualisiert
+Onlineportal zur Prähistorischen Archäologie
+Onlineportal mit umfangreicher Wissensdatenbank zur prähistorischen Archäologie
+Nützliches für Grabungstechnik und Archäologie
+Weblog über Archäologie
+Datenbank mit Literatur- und Linkhinweisen für archäologische und geschichtliche Themen
+Bibliographie zum Raub an archäologischen Stätten University at Buffalo
+Luftbildarchäologie Bilder
+Experimentelle Archäologie Archeoparagliding Rekonstruktionen Website von Marek Poznański
+Vereine und Organisationen
+Deutscher Archäologen-Verband
+Deutsches Archäologisches Institut
+Deutsche Gesellschaft für Ur- und Frühgeschichte e V
+DGUF
+Stiftung Archäologie
+Liste aller Landesämter für Archäologie in Deutschland
+Archäologische Gesellschaft Innsbruck Website der Archäologischen Gesellschaft Innsbruck
+Archäologiemuseen bei webmuseende
+wwwexarorg EXAR - Europäische Vereinigung zur Förderung der Experimentellen Archäologie e V
+EXARC European EXchange on Archaeological Research and Communication Zusammenschluss europäischer Institutionen zur Experimentellen Archäologie
+AG Computeranwendungen und Quantitative Methoden in der Archäologie Arbeitsgruppe Archäologie und Archäobotanik Afrikas im Institut für Archäologische Wissenschaften der Goethe-Universität Frankfurt
+Webseite zur Bodendenkmalpflege in Krefeld Dachverband Archäologischer Studierendenvertretungen Liste der in Österreich tätigen Grabungsfirmen und Institutionen
+Einzelnachweise
+Vgl M K H Eggert Archäologie Grundzüge einer Historischen Kulturwissenschaft TübingenBasel <num> UTB <num> Hansjürgen Müller-Beck Die Steinzeit - Der Weg der Menschen in die Geschichte CH Beck München <num> S <num> Vgl Homepage des US Committee of the Blue Shield abgerufen am <num> Oktober <num> Isabelle-Constance v Opalinski Schüsse auf die Zivilisation In
+FAZ
+<num> August <num> Hans Haider Missbrauch von Kulturgütern ist strafbar In Wiener Zeitung <num> Juni <num> Aisling Irwin
+A no-strike list may shield Yemens ancient treasures from war
+In
+New Scientist Daily news
+vom <num> Januar <num> abgerufen am <num> September <num> Jyot Hosagrahar Culture at the heart of SDGs UNESCO-Kurier April-Juni <num> Rick Szostak The Causes of Economic Growth Interdisciplinary Perspectives Springer Science
+Business Media <num> ISBN <num> Corine Wegener Marjan Otter Cultural Property at War Protecting Heritage during Armed Conflict In The Getty Conservation Institute Newsletter <num> Spring <num>
+Der
+ASCII alternativ US-ASCII oft
+ausgesprochen
+ist eine <num>-Bit-Zeichenkodierung sie entspricht der US-Variante von ISO <num> und dient als Grundlage für spätere auf mehr Bits basierende Kodierungen für Zeichensätze
+Der ASCII-Code wurde zuerst am <num> Juni <num> von der American Standards Association ASA als Standard ASA X<num>-<num> gebilligt
+und <num><num> wesentlich sowie zuletzt im Jahr <num> ANSI X<num>-<num> von ihren Nachfolgeinstitutionen aktualisiert und wird bis heute noch benutzt
+Die Zeichenkodierung definiert <num> Zeichen bestehend aus <num> nicht druckbaren sowie <num> druckbaren Zeichen
+Druckbare Zeichen sind beginnend mit dem Leerzeichen
+-<num>< >ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz
+lateinische Alphabet
+arabischen Ziffern
+Interpunktionszeichen
+Satzzeichen
+Wortzeichen
+Sonderzeichen
+Tastatur
+Schreibmaschine
+englische Sprache
+abwärtskompatibel
+ISO <num>
+Unicode
+Die nicht druckbaren Steuerzeichen enthalten Ausgabezeichen wie Zeilenvorschub oder Tabulatorzeichen Protokollzeichen wie Übertragungsende oder Bestätigung und Trennzeichen wie Datensatztrennzeichen
+Kodierung
+Jedem Zeichen wird ein Bitmuster aus <num> Bit zugeordnet
+Da jedes Bit zwei Werte annehmen kann gibt es <num>
+<num> verschiedene Bitmuster die auch als die ganzen Zahlen <num>-<num> hexadezimal <num>h-<num>Fh interpretiert werden können
+Das für ASCII nicht benutzte achte Bit kann für Fehlerkorrekturzwecke Paritätsbit auf den Kommunikationsleitungen oder für andere Steuerungsaufgaben verwendet werden
+Heute wird es aber fast immer zur Erweiterung von ASCII auf einen <num>-Bit-Code verwendet
+Diese Erweiterungen sind mit dem ursprünglichen ASCII weitgehend kompatibel so dass alle im ASCII definierten Zeichen auch in den verschiedenen Erweiterungen durch die gleichen Bitmuster kodiert werden
+Die einfachsten Erweiterungen sind Kodierungen mit sprachspezifischen Zeichen die nicht im lateinischen Grundalphabet enthalten sind vgl unten
+Zusammensetzung
+Die ersten <num> ASCII-Zeichencodes von <num>hex bis <num>Fhex sind für Steuerzeichen control character reserviert siehe dort für die Erklärung der Abkürzungen in obiger Tabelle
+Diese Zeichen stellen keine Schriftzeichen dar sondern dienen oder dienten zur Steuerung von solchen Geräten die den ASCII verwenden etwa Drucker
+Steuerzeichen sind beispielsweise der Wagenrücklauf für den Zeilenumbruch oder
+Bell
+die Glocke ihre Definition ist historisch begründet
+Code <num>hex SP ist das Leerzeichen engl space oder blank das in einem Text als Leer- und Trennzeichen zwischen Wörtern verwendet und auf der Tastatur durch die Leertaste erzeugt wird
+Die Codes <num>hex bis <num>Ehex stehen für druckbare Zeichen die Buchstaben Ziffern und Interpunktionszeichen Satzzeichen Wortzeichen umfassen
+Die Buchstaben sind lediglich Klein- und Großbuchstaben des lateinischen Alphabets
+In nicht-englischen Sprachen verwendete Buchstabenvarianten - beispielsweise die deutschen Umlaute - sind im ASCII-Zeichensatz nicht enthalten
+Ebenso fehlen typografisch korrekte Gedankenstriche und Anführungszeichen die Typografie beschränkt sich auf den Schreibmaschinensatz
+Der Zweck war Informationsaustausch nicht Drucksatz
+Code <num>Fhex alle sieben Bits auf eins gesetzt ist ein Sonderzeichen das auch als Löschzeichen bezeichnet wird DEL
+Dieser Code wurde früher wie ein Steuerzeichen verwendet um auf Lochstreifen oder Lochkarten ein bereits gelochtes Zeichen nachträglich durch das Setzen aller Bits das heißt durch Auslochen aller sieben Markierungen löschen zu können
+Dies war die einzige Möglichkeit zum Löschen da einmal vorhandene Löcher nicht mehr rückgängig gemacht werden können
+Bereiche ohne Löcher also mit dem Code <num>hex fanden sich vor allem am Anfang und Ende eines Lochstreifens NUL
+Aus diesem Grund gehörten zum eigentlichen ASCII nur <num> Zeichen denn den Bitmustern <num> <num> und <num> <num> entsprachen keine Zeichencodes
+Der Code <num> wurde später in der Programmiersprache C als Ende der Zeichenkette interpretiert dem Zeichen <num> wurden verschiedene grafische Symbole zugeordnet
+Geschichte
+Fernschreiber
+Eine frühe Form der Zeichenkodierung war der Morsecode
+Er wurde mit der Einführung von Fernschreibern aus den Telegrafennetzen verdrängt und durch den Baudot-Code und Murray-Code ersetzt
+Vom <num>-Bit-Murray-Code zum <num>-Bit-ASCII war es dann nur noch ein kleiner Schritt - auch ASCII wurde zuerst für bestimmte amerikanische Fernschreibermodelle wie den Teletype ASR<num> eingesetzt
+Die erste Version noch ohne Kleinbuchstaben und mit kleinen Abweichungen vom heutigen ASCII bei den Steuer- und Sonderzeichen entstand im Jahr <num>
+<num> wurde dann die bis heute gültige Fassung des ASCII-Standards festgelegt Diese Fassung gebar die Caesar-Verschlüsselung ROT<num> als Erweiterung von ROT<num>
+Während ROT<num> nur das lateinische Alphabet um dessen halbe Länge rotiert rotiert ROT<num> alle ASCII-Zeichen zwischen <num>
+und <num>
+Computer
+In den Anfängen des Computerzeitalters entwickelte sich ASCII zum Standard-Code für Schriftzeichen
+Zum Beispiel wurden viele Terminals VT<num> und Drucker nur mit ASCII angesteuert
+Für die Kodierung lateinischer Zeichen wird fast nur bei Großrechnern die zu ASCII inkompatible <num>-Bit-Kodierung EBCDIC verwendet die IBM parallel zu ASCII für sein System<num> entwickelte damals ein ernsthafter Konkurrent
+Die Handhabung des Alphabets ist in EBCDIC schwieriger denn es ist dort auf zwei auseinander liegende Codebereiche verteilt
+IBM selbst verwendete ASCII für interne Dokumente
+ASCII wurde durch Präsident Lyndon B Johnsons Anordnung <num> gestützt es in den Regierungsbüros zu verwenden
+Verwendung für andere Sprachen
+Mit dem Internationalen Alphabet <num> IA<num> wurde <num> eine <num>-Bit-Codierung auf Basis des ASCII als ISO <num> normiert
+Die Referenzversion ISO <num>-IRV entspricht dabei bis auf eine Position dem ASCII
+Um Buchstaben und Sonderzeichen verschiedener Sprachen darstellen zu können beispielsweise die deutschen Umlaute wurden <num> Zeichenpositionen zur Umdefinition vorgesehen
+Eine gleichzeitige Darstellung ist nicht möglich
+Fehlende Anpassungen der Software an die jeweils zur Anzeige verwendete Variante führte oft zu ungewollt komischen Ergebnissen z B
+erschien beim Einschalten des Apple II APPLE ÜÄ anstelle von APPLE
+Da sich darunter Zeichen befinden die in der Programmierung verwendet werden insbesondere z B
+die verschiedenen Klammern wurden Programmiersprachen über Ersatzkombinationen Digraphen für die Internationalisierung ertüchtigt
+Zur Kodierung wurden dazu ausschließlich Zeichen aus dem invarianten Teil von ISO <num> verwendet
+Die Kombinationen sind sprachspezifisch
+So entspricht bei Pascal
+und
+den geschweiften Klammern
+während C
+und
+dafür vorsieht
+Erweiterungen
+Nutzung der übrigen <num> Positionen im Byte
+Zur Überwindung der Inkompatibilitäten nationaler <num>-Bit-Varianten von ASCII entwickelten zunächst verschiedene Hersteller eigene ASCII-kompatible <num>-Bit-Codes d h
+solche die auf den ersten <num> Positionen mit ASCII übereinstimmen
+Der Codepage <num> genannte Code war lange Zeit der am weitesten verbreitete er kam auf dem IBM-PC unter englischem MS-DOS und kommt heute noch im DOS-Fenster von englischem Microsoft Windows zur Anwendung
+In deren deutschen Installationen ist seit MS-DOS <num> die westeuropäische Codepage <num> der Standard
+Auch bei späteren Standards wie ISO <num> wurden acht Bits verwendet
+Dabei existieren mehrere Varianten zum Beispiel
+ISO <num>-<num>
+für die westeuropäischen Sprachen die in Deutschland als DIN <num> übernommen wurde
+Deutschsprachige Versionen von Windows außer DOS-Fenster verwenden die auf ISO <num>-<num> aufbauende Kodierung Windows-<num> - daher sehen zum Beispiel die deutschen Umlaute falsch aus wenn Textdateien unter DOS erstellt wurden und unter Windows betrachtet werden
+Jenseits von <num> Bit
+Viele ältere Programme die das achte Bit für eigene Zwecke verwendeten konnten damit nicht umgehen
+Sie wurden im Lauf der Zeit oft den neuen Erfordernissen angepasst
+Auch <num>-Bit-Codes in denen ein Byte für ein Zeichen stand boten zu wenig Platz um alle Zeichen der menschlichen Schriftkultur gleichzeitig unterzubringen
+Dadurch wurden mehrere verschiedene spezialisierte Erweiterungen notwendig
+Daneben existieren vor allem für den ostasiatischen Raum einige ASCII-kompatible Kodierungen die entweder zwischen verschiedenen Codetabellen umschalten oder mehr als ein Byte für jedes Nicht-ASCII-Zeichen benötigen Keine dieser <num>-Bit-Erweiterungen ist aber ASCII denn das bezeichnet nur den einheitlichen <num>-Bit-Code
+Um den Anforderungen der verschiedenen Sprachen gerecht zu werden wurde der Unicode in seinem Zeichenvorrat identisch mit
+ISO <num>
+entwickelt
+Er verwendet bis zu <num> Bit pro Zeichen und könnte somit über vier Milliarden verschiedene Zeichen unterscheiden wird jedoch auf etwa eine Million erlaubte Codepoints eingeschränkt
+Damit können alle bislang von Menschen verwendeten Schriftzeichen dargestellt werden sofern sie in den Unicode-Standard aufgenommen wurden
+UTF-<num> ist eine <num>-Bit-Kodierung von Unicode die zu ASCII abwärtskompatibel ist
+Ein Zeichen kann dabei ein bis vier <num>-Bit-Wörter einnehmen
+Sieben-Bit-Varianten müssen nicht mehr verwendet werden dennoch kann Unicode auch mit Hilfe von UTF-<num> in sieben Bit kodiert werden
+UTF-<num> entwickelte sich zum Standard unter vielen Betriebssystemen
+So nutzen unter anderem Apples macOS sowie einige Linux-Distributionen standardmäßig UTF-<num> und mehr als <num> der Websites werden in UTF-<num> erstellt
+Formatierungszeichen gegenüber Auszeichnungssprachen
+ASCII enthält nur wenige Zeichen die allgemeinverbindlich zur Formatierung oder Strukturierung von Text verwendet werden diese gingen aus den Steuerbefehlen der Fernschreiber hervor
+Dazu zählen insbesondere der Zeilenvorschub Linefeed der Wagenrücklauf Carriage Return das Horizontal-Tabulatorzeichen der Seitenvorschub Form Feed und das Vertikal-Tabulatorzeichen
+In typischen ASCII-Textdateien findet sich neben den druckbaren Zeichen meist nur noch der Wagenrücklauf oder der Zeilenvorschub um das Zeilenende zu markieren dabei werden in DOS- und Windows-Systemen üblicherweise beide nacheinander verwendet bei älteren Apple- und Commodore-Rechnern ohne Amiga nur der Wagenrücklauf und auf Unix-artigen sowie Amiga-Systemen nur der Zeilenvorschub
+Die Verwendung weiterer Zeichen zur Textformatierung wird unterschiedlich gehandhabt
+Zur Formatierung von Text werden inzwischen eher Markup-Sprachen wie zum Beispiel HTML verwendet
+Kompatible Zeichenkodierungen
+Die meisten Zeichenkodierungen sind so entworfen dass sie für Zeichen zwischen <num>
+<num> den gleichen Code verwenden wie ASCII und den Bereich über <num> für weitere Zeichen benutzen
+Kodierungen mit fester Länge Auswahl
+Hier steht eine feste Anzahl Bytes für jeweils ein Zeichen
+In den meisten Kodierungen ist das ein Byte pro Zeichen - Single Byte Character Set oder kurz SBCS genannt
+Bei den ostasiatischen Schriften sind es zwei oder mehr Byte pro Zeichen wodurch diese Kodierungen nicht mehr ASCII-kompatibel sind
+Die kompatiblen SBCS-Zeichensätze entsprechen den oben besprochen ASCII-Erweiterungen
+ISO <num> mit <num> verschiedenen Zeichenkodierungen zur Abdeckung aller europäischen Sprachen Türkisch Arabisch Hebräisch sowie Thai siehe Tabelle rechts
+MacRoman MacCyrillic und andere proprietäre Zeichensätze für Apple Mac Computer vor Mac OS X
+DOS-Codepages z B
+<num> <num> und Windows-Codepages z B
+Windows-<num>
+KOI<num>-R für Russisch und KOI<num>-U für Ukrainisch
+ARMSCII-<num> und ARMSCII-<num>a für Armenisch
+GEOSTD für Georgisch
+ISCII für alle indischen Sprachen
+TSCII für Tamil
+Kodierungen mit variabler Länge
+Um mehr Zeichen kodieren zu können werden die Zeichen <num> bis <num> in einem Byte kodiert andere Zeichen werden durch mehrere Bytes mit Werten von über <num> kodiert
+UTF-<num> und GB <num> für Unicode
+ISO <num> für europäische Sprachen mit lateinischer Schrift
+Big<num> für traditionelles Chinesisch Republik China Taiwan Auslandschinesen
+EUC Extended UNIX Coding für mehrere ostasiatische Sprachen
+GB Guojia Biaozhun für vereinfachtes Chinesisch VR China
+ASCII-Tabelle
+Die folgende Tabelle gibt neben den hexadezimalen Codes auch noch die Dezimal- und Oktalcodes an
+Eponyme
+Der <num> entdeckte Asteroid <num> ASCII wurde <num> nach der Zeichenkodierung benannt
+Siehe auch
+ASCII-Art
+CBM-ASCII
+Bob Bemer
+Fieldata
+Ausgaben
+American Standards Association American Standard Code for Information Interchange
+ASA X<num>-<num>
+American Standards Association New York <num>
+American Standards Association American Standard Code for Information Interchange
+ASA X<num>-<num>
+American Standards Association New York <num> genehmigt aber nicht veröffentlicht
+United States of America Standards Institute USA Standard Code for Information Interchange
+USAS X<num>-<num>
+United States of America Standards Institute <num>
+United States of America Standards Institute USA Standard Code for Information Interchange
+USAS X<num>-<num>
+United States of America Standards Institute <num>
+American National Standards Institute American National Standard for Information Systems
+ANSI X<num>-<num>
+<num>
+American National Standards Institute American National Standard for Information Systems
+Coded Character Sets
+<num>-Bit American National Standard Code for Information Interchange <num>-Bit ASCII
+ANSI X<num>-<num>
+<num>
+Weitere Revisionen
+ANSI X<num>-<num> R<num>
+ANSI X<num>-<num> R<num>
+ANSI INCITS <num>-<num> R<num>
diff --git a/tests/test-type-3.sh b/tests/test-type-3.sh
new file mode 100755
index 0000000..f7ad19e
--- /dev/null
+++ b/tests/test-type-3.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+TESTDIR=$(dirname $0)
+ASSERTSH=${TESTDIR}/assert.sh
+set -e
+. ${ASSERTSH}
+
+DESTDIR=$(mktemp -d)
+trap '{ rm -rf -- "$DESTDIR"; }' EXIT
+DATADIR=${TESTDIR}/data
+BUILDDIR=$(realpath ${TESTDIR}/../build)
+echo $BUILDDIR >out
+
+${BUILDDIR}/dereko2vec -train ${DATADIR}/wpd19_10000.w2vinput -output ${DESTDIR}/wpd19_10000.vecs -type 3 \
+  -save-net ${DESTDIR}/wpd19_10000.net -save-vocab ${DESTDIR}/wpd19_10000.vocab \
+  -size 200 -binary 1 -window 5 -negative 10 -threads 16 -iter 5 -min-count 2 \
+  > >(tee -a ${BUILDDIR}/stdout.log) 2> >(tee -a ${BUILDDIR}/stderr.log >&2)
+
+stdoutlog=$(cat ${BUILDDIR}/stdout.log)
+assert_contain "$stdoutlog" "ETA:"
+if [ "$?" == 0 ]; then
+  log_success "dereko2vec prints ETA"
+else
+  log_failure "dereko2vec does not print ETA"
+fi
+
+assert_contain "$stdoutlog" "Finished"
+
+observed=$(cat ${DESTDIR}/wpd19_10000.vocab)
+#expected=$(cat ${DATADIR}/wpd19_10000.vocab)
+#assert_eq "$observed" "$expected" "wrong vocab output!"
+#if [ "$?" == 1 ]; then
+#    log_success "vocab output is identical with wpd19_10000.vocab"
+#  else
+#    log_failure "vocab output should be identical with wpd19_10000.vocab"
+#fi
+
+observed=$(echo -e "Grund\nEXIT" | ${BUILDDIR}/distance ${DESTDIR}/wpd19_10000.vecs)
+
+assert_contain "$observed" "Zusammenhang"
+if [ "$?" == 0 ]; then
+  log_success "neighbours of Grund contain Reaktion"
+else
+  log_failure "neighbours of Grund should contain Reaktion"
+fi
+
+assert_not_contain "$observed" "gestern"
+if [ "$?" == 0 ]; then
+  log_success "neighbours of Grund do not contain gestern"
+else
+  log_failure "neighbours of Grund should not contain gestern"
+fi
