test-věra

a:1:{i:0;a:3:{s:5:"class";s:0:"";s:5:"style";a:3:{s:16:"background_color";a:3:{s:6:"color1";s:4:"#fff";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}s:10:"link_color";s:0:"";s:4:"font";a:4:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:5:"color";s:0:"";}}s:7:"content";a:1:{i:0;a:3:{s:4:"type";s:7:"col-one";s:5:"class";s:0:"";s:7:"content";a:9:{i:0;a:3:{s:4:"type";s:4:"text";s:7:"content";s:333:"<p style=\"text-align: center;\">Čísla jako fascinující symboly<br />Okultismus v předválečných časopisech<br />Věda zkoumá „tunel do věčnosti“<br />Chvála individualismu<br />Se Sluncem se nedomluvíme<br />Různé podoby pošetilosti<br />Vymalujte si hvězdným prachem</p>
<p style=\"text-align: left;\"> </p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:1;a:3:{s:4:"type";s:4:"text";s:7:"content";s:24738:"<p style=\"text-align: left;\">Čísla jako fascinující symboly<br />Magie čísel v historii a náboženství<br /><br />Mystika čísel věří ve tři předpoklady. Za prvé – číslo ovlivňuje bytí věcí, neboť jim propůjčuje řád. Za druhé – číslo se tak stává prostředníkem mezi božským a pozemským. A tedy za třetí – pokud provádíme libovolné operace s čísly, mají tyto operace vliv i na věci, které s nimi souvisejí.<br /><br />„Odejmi číslo ze všech věcí a vše pomine,“ řekl kolem roku 600 Isidor Sevilský. „Čísla jsou projev boží moudrosti v našem světě, přístupná poznání lidského ducha,“ napsal svatý Augustin.<br />Tak například trojka je mimo jiné také významným christologickým symbolem - vztahuje se k osobě Krista. Třikrát mu bylo předpovězeno ukřižování, třikrát požádal svého otce, aby od něho odňal kalich hořkosti, třikrát poodešel, aby se modlil s apoštoly, třikrát ho zapřel Petr, tři hodiny trvala tma po ukřižování, zmrtvýchvstání se stalo třetího dne atd. Trojka je domovem také ve většině pohádek: tři sourozenci, tři kouzelné předměty, tři dobré či špatné skutky. Jak praví lidové úsloví, do třetice všeho dobrého i zlého. Božskou (Svatou) trojici mají nejen křesťané, tři Višnuovy krky se objevují v Indii, božskou trojici měli staří Etruskové.<br /><br />Jsi jednička. Seš nula. Do třetice všeho dobrého i zlého. Jeden je za dvacet a druhý bez dvou za osmnáct. Třináctá komnata. 33 Kristových let. Sedm hladových let. 12 apoštolů. Desatero. To je jen několik příkladů proniknutí čísel do běžného jazyka, čísel, která cosi vyjadřují, symbolizují. Jejich kotviště v měnícím se přístavu jazyků je prastaré, mnohdy jde o tisíciletou historii a o významy v naší křesťanské kultuře původně biblické, ale i islámské, staročínské... Průpovídky, ustálená slovní spojení s čísly přešla do běžné mluvy z hlubších struktur náboženství, magie, historie. Čísla totiž mají vedle své číselné hodnoty také hodnotu pocitovou a v oblasti náboženství, ale také v krajině esoteriky, magie a pověr na sebe nabalila velké množství vlastností, které se k nim mají vázat. Tyto významy a vlastnosti jsou ale někdy protichůdné, neboť v různých kulturách a mýtech se váží k jiným příběhům, k odlišným poselstvím.<br /><br />Tak například třináctka je v naší kultuře nešťastné číslo, přitom Kristus povolal 12 apoštolů a sám byl tedy třináctý. Podle staré tradice pozval papež Řehoř denně ke stolu dvanáct chudých, aby s nimi pojedl. Jako třináctý se k nim měl tiše přidat anděl. V Talmudu se píše: Jednou bude izraelská země rozdělena na dvanáct dílů, třináctý připadne králi Mesiáši. Ve všech těchto případech je číslo 13 jakýmsi svatým završením. Mnohé indicie ukazují na to, že v matriarchálních kulturách bylo 13 měsíců po 28 dnech, což samozřejmě souviselo s lunárním cyklem žen. Patriarchát toto rozdělení roku přeměnil na dvanáct dílů, a třináctka získala jakousi ďábelskou pověst. Objevuje se i v důležité pohádce O šípkové Růžence jako třináctá, zlá víla. Psychologové, kteří interpretují pohádky coby mýty s poselstvím o době a člověku o této pohádce tvrdí, že stojí na přechodu mezi matriarchátem a patriarchátem. V Mexiku byla třináctka pozitivním a šťastným číslem – třináct bylo bohů a také nebeských sfér. Také podle kabaly jde o šťastné číslo.<br /><br />Už ve staroindických textech jsou čísla vzývána: „Zdar jedné! Zdar dvěma! A stu zdar!“ Zaříkávání, ve všech obřadech spjatých s množstvím kultur a náboženství, se často vázala k pevnému-magickému počtu opakování. V čínském myšlení označuje například jednička univerzální jednotu, přičemž číselná řada jang seřazuje mužská – lichá čísla a řada jin sestává s ženských čísel – sudých. Ve starém Babylóně dostávali bohové přiřazené číslo podle své velikosti a významu. Židovská kabala vyvinula esoterickou číselnou nauku, vybudovanou na vysoce komplikované mystice čísel, která se zabývala tajemstvím stvoření. V mystických muslimských kruzích se zaměnitelnost čísel a písmen využívalo ke stále složitějším operacím, jež se projevují ve výkladu Koránu, v předpovídání budoucnosti a třeba i v poezii.<br /><br />Zvlášť důležitou úlohu měla sedmička a dvanáctka. Sedm bylo tehdy známých planet (v 10. století) dvanáct je znamení zvěrokruhu. V západním světě se po celý středověk silně projevovalo antické dědictví, které v pythagorejské nauce hledalo souvztažnost mezi číselnými poměry, hudební harmonií a strukturou kosmu. Zejména Filon Alexandrijský ve svém díle propojil starozákonní a pythagorejské ideje a položil tak základy číselnou mystikou silně ovlivňovaného výkladu Bible. Číselné spekulace pythagorejců pronikly do mystiky středověku.<br /><br />Číslo deset bylo ceněno v kulturách s desítkovou soustavou, která se s velkou pravděpodobností odvíjela v předhistorických dobách z počtu prstů na rukou. Pro pýthagorejce byla desítka „všezahrnující, všeohraničující matka. Deset přikázání zná nejen křesťan, ale také buddhista, pět jich je pro mnichy a pět pro laiky. Podle kabaly stojí boží trůn na deseti sloupech. V islámu pěti smyslům vnějším odpovídá pět smyslů vnitřních a Mohamed měl deset učedníků, jimž přislíbil ráj. Čísla se využívala k lepšímu pochopení složitého světa, jako symboly, ale také k předpovídání budoucnosti.<br />Staří pythagorejci<br /><br />Pythagorejská aritmetika pracovala původně s přirozenými a racionálními čísly, přirozená čísla se znázorňovala pomocí oblázků. Kamínky – co oblázek to jednotka – byly pořádány do podoby pravidelných obrazců. Trojka jako trojúhelník, čtyřka jako čtverec, šestka jako obdélník… Proto se některá čísla nazývala čtvercová, jiná obdélníková, atd. Oblázková aritmetika má svůj předobraz ve starověké počítací praxi. Pythagorejcům vděčíme za rozdělení čísel na sudá a lichá a zavedení dalších pojmů do matematiky, například dokonalého čísla. To je takové, jehož dělitelé, když jsou sečteni, dají číslo samotné. Prvním takovým číslem je šest, neboť 1 + 2 + 3 = 6, druhým je číslo 28: 1 + 2 + 4 + 7 + 14 = 28. Do roku 1971 bylo nalezeno 32 takových dokonalých čísel. Jako se každé školní dítě učí slavnou Pythagorovu větu, tak z učení tohoto antického myslitele (nar. v 6. stol. př. Kr.) a jeho žáků těžila náboženská, literární a magická díla. Aristoteles (4. stol. př. Kr.) se ale k mystice Pythagora a jeho žáků vyjadřuje kriticky: „Zcela v zajetí matematiky si pythagorejci mysleli, že jejich číselné principy tvoří podstatu všeho jsoucna. Protože v matematice jsou čísla přirozeně prvořadá, a protože se pythagorejci domnívají, že spatřují v číslech mnoho podobností s tím co je, se vším děním … měli za to, že veškerá příroda je podle čísel uspořádána. … Když jim někde něco chybělo, neváhali to uměle doplnit, jen aby byl systém ucelený.“ A skutečně, protože například desítku pokládali za nejdokonalejší číslo, neboť představuje součet prvních čtyř celých čísel: 1 + 2 + 3 + 4 = 10 a bylo ji možno zobrazit jako trojúhelník se základnou ze čtyř jednotek, snažili se za každou cenu objevit deset nebeských těles, a když počet těles nepostačoval, vymyslili si těleso desáté, aby „dokázali“ svou teorii.<br /><br />Zajímavé je postavení lichých čísel. Ta hrají důležitou roli v lidových pověrách, ale i v teologii. A jak vnímali lichá čísla myslitelé starověku a středověku? Podle Platona jsou sudá – ženská čísla neblahá, lichá – mužská naopak příznivá. Vergilius říká: Bůh se raduje z lichého čísla. Tradiční islámský výrok: Vskutku, Bůh je liché číslo (totiž Jeden) a má rád lichá čísla. Shakespeare: Liché číslo přináší štěstí.<br />Numerologie - primitivní počítání se „vševědoucími“ výstupy<br /><br />Numerologie sice, alespoň verbálně, propagačně, vychází z mystiky vytvářené po tisíciletí kolem čísel, ale je v pojetí jednotlivých propagátorů a uživatelů jednak krajně zjednodušená a upravená pro praktickou potřebu, a také různě modifikovaná, bez jasných východisek a pravidel jaké jsou například v matematice. Stala se v dnešní době především výdělečným podnikem, oborem doplňujícím nabídku esoterických pomůcek, kurzů, jasnovidného odhalování budoucnosti či vlastností člověka. Numerologické příručky a kurzy jsou jednou z nabídek zboží a služeb na esoterickém trhu. Ve výpravné knize seznamující s věšteckými technikami (Budoucnost – odhalte, co vás čeká, přeložené z anglického originálu) se v úvodu kapitoly o numeralogii praví: „Numerologie je velmi kontroverzní obor. Zdá se, že co člověk, to jiný názor na její původ a metody.“<br /><br />Numerologie získává „informace“ o zkoumané osobě tak, že sečte číslice v datu jeho narození, a vyjde-li dvojmístné číslo, sečte opět tyto číslice a získá tak „číslici osudu, života“. Například: 7. 3. 1975 numerolog rozloží na 7 + 3 + 1 + 9 + 7 + 5 a vyjde mu součet 23, ten opět rozloží a sečte, 2 + 3 = 5, a výsledné číslo je 5. Každé číslo je v numerologii charakterizováno jistými lidskými vlastnostmi, způsoby chování, temperamentem, možnostmi v životní dráze. Dotyčný s výslednou pětkou by měl být živý a podnikavý vtipálek, jemuž sedí práce mezi lidmi. Každou chvíli se prý pouští do obrovských změn ve svém životě. (Něco takového je „technicky možné“ leda v akčním filmu.) V jiné numerologické příručce (Tajemství čísel – Jiří M. Fuchs) se ale dočítáme, že číslo 5 je nedefinovatelné, jeho vlastnosti nelze přesně určit. Není prý spolehlivé a v nejistých dobách často zklame. Jeho jediná vlastnost je nedůslednost. Jindy je pětka spojována se smyslovým životem, je to číslo lásky a manželství neboť ženská dvojka se spojuje s mužskou trojkou.<br /><br />Číslice osobnosti lze zase získat podle tabulky, v níž devět čísel odpovídá písmenům v abecedě, tedy každé číslo má pod sebou tři příslušná písmena, devítka jen dvě. A opět se rozkládá a sčítá, tentokrát jméno dotyčného, jehož písmena jsou podle této (Pythagorovy) tabulky převedena na čísla. Čísla odpovídající samohláskám se píší nad nimi, souhláskám pod jménem. Postupuje se opět jako při výpočtu čísla osudu. Zvlášť se ovšem sčítají čísla pod jménem odpovídajícím souhláskám a zvlášť horní čísla odpovídající samohláskám. Číslo vzniklé součtem numerické hodnoty samohlásek má odhalit skryté touhy a podstatu osobnosti, říká se mu číslo skryté podstaty. Součet čísel zastupujících souhlásky je číslem vnějšího sebevyjádření. Poté se sečte numerická hodnota obou čísel, jejich součet je pak číslem osobnosti. A opět jsou k těmto číslům přiřazovány vlastnosti, temperament, životní náplň, které se liší v jednotlivých příručkách.<br />Filipika proti numerologii<br /><br />Jedenáctka se v historii magie čísel uplatňovala méně. Hrála roli jako číslo hříšníků a pokání, existovalo 11 forem omylu. Jedenáct žen ve staré Spartě chránilo dionýsovské orgie od degenerace, v Římě „jedenáctimuži“ (tak by se dala kriminalistická skupina v počtu 11 mužů také přeložit) zastávali roli jakýchsi kriminalistů, měli za úkol stíhat zločince. Numerologie přidává k číslu duchovní vhled a parapsychologické nadání, vůdcovské schopnosti, pracovitost, silnou vůli, srdečnost a veselost (Kniha osudu od Jane Struthersové). Další jednoduchá příručka tvrdí, že číslo 11 znamená představivost a živou povahu, ale působí jen ve výjimečných případech. Kniha Budoucnost spojuje pod tímto číslem naprosté protiklady. Člověk s číslem 11 je obdařen mocí, silou, elánem, odvahou, ustrašeností, idealismem, fanatismem, pragmatismem, chápavostí, potřebou reforem… Je to tedy odvážný ustrašenec a chápavý a pragmatický fanatik. Po prostudování více publikací numerologické literatury a při srovnávání jednotlivých čísel dojde čtenář nutně k poznání, že obraz „vypočítávané“ osobnosti nezávisí na faktech, na skutečnosti, ale na tom, podle které knížky, příručky, či kurzu se konkrétní numerolog řídí. Stačí, aby byl člověk soudný, a neujde jeho pozornosti, že charakteristiky čísel aplikované na osobnosti neodpovídají, jsou opakem reality nebo zase vágní. Je tedy překvapivé, že se numerologie těší jistému zájmu a vážnosti, i když, připusťme, jde většinou o příznivce tíhnoucí k okultismu všech forem. Ještě méně pochopitelný je zájem médií, která si zvou numerology jako experty na čísla dokonce i do seriózních zpravodajských pořadů, většinou po vylosování čísel pro politické strany před volbami.<br /><br />Numerologické rozbory jsou poskytovány za úplatu a vzhledem k vágnosti odpovědí a primitivnosti výpočtu je každá cena vlastně nadsazená. Výpočty jsou to jednoduché, takže pokud se s nimi je člověk ochoten obeznámit, během dvou hodin se na numerologa „vyškolí“. Co si ale numerolog počne, má-li odpovědět na logickou námitku, že pokud se žena provdá a její nové příjmení způsobí změnu čísla osobnosti, měla by se v té chvíli změnit také její osobnost, potažmo budoucnost (byť se třeba za pět let rozvede, změní příjmení nebo se vrátí k dívčímu, a všechno je opět jinak). Radši nemyslet na veletoče v osudu a povaze dam, které změnily příjmení několikrát za život. Odvážné je také tvrzení numerologů, že: „Čísla, podobně jako řeč, nejsou něčím, co člověk vymyslel nebo vytvořil, ale něčím co našel. Čísla jsou původní kvalitou, skutečností vyššího řádu. Při správném pozorování čísel se zjevují zákony a tajemství stvoření. Všechno má svůj řád a ve svědectví čísel se skrývá mnoho mocných sil, neboť jak praví staré záznamy, čísla přejala dokonalost nebes. Smysl ukrytý v číslech zůstává po celá tisíciletý nezměněný. Čísla jsou nositeli určitých vibrací a symbolů. S těmito vibracemi a symboly pracuje i součastná numerologie. Z data narození a jména je schopna vyčíst mnohé schopnosti člověka, jeho profesionální možnosti, riziko zdravotních potíží a mnoho dalších povahových vlastností a schopností. Čím lépe si budeme uvědomovat vibrace čísel a číselných kombinací v datu narození člověka a v ostatních základních vibracích, které na člověka působí, tím budeme moci lépe chápat sami sebe a své blízké.“ (kniha Tajemný svět čísel)<br /><br />„Řeč čísel má v neposlední řadě také velký význam a je schopna dobře poradit v oblasti vztahů, ať už se jedná o vztahy partnerské, pracovní či přátelské. Pomáhá lépe chápat chování zkoumané osoby a způsob jejího vyjadřování. Při výběru životního partnera nás upozorní na možné klady a zápory vztahu a pomůže vyvarovat se tak zbytečných chyb a nedorozumění. Numerologie je prvním krokem na cestě za lepším pochopení člověka,“ tvrdí dále numerologové (Kniha osudu) a skeptikovi nezbývá než varovat před abstraktní výpočty a magickými čísly místo preferování vlastních zkušeností, znalostí a třeba také intuice, což je vlastně neuvědomělé vyhodnocení podprahových informací.<br /><br />V bohaté numerologické literatuře se zájemce o fakta setkává, stejně jako ve všech esoterických oborech, s povznesenou řečí plnou křečovitých tvrzení, patosu a tajemných narážek. Chybí fakta, data, osobnosti, srovnání, analýzy, experimenty. Naopak častá je nabídka služby numerologických výpočtů, které mají odhalit za pevně stanovenou částku nejen osobnost zájemce, ale i její minulost, případně budoucnost. Jeden z mnoha textů uvádějící do této nauky informuje, že:  „Numerológia je nauka, ktorá má veľa spoločné s astrológiou. Numerológia vznikla neskôr a s astrológiou súvisí preto, že obidve využívajú vesmírneho žiarenia, čerpajú z kozmickej energie. Vieme, že vo vesmíre sa odohrávajú cyklické deje, ktoré sa dajú vyjadriť číslami. Málokto si uvedomuje, že tieto čísla majú neviditeľnú, ale mocnú vibračnú silu, ktorá na nás pôsobí od okamžiku nášho narodenia. Je viditeľná v správaní človeka. Vytvára určitú povahovú skladbu našej osobnosti a tým súčasne naznačuje smer nášho života.   Numerológia je vedný odbor, známy už v dávnych dobách, využívaný prastarými mudrcmi, pomocou ktorého možno na základe vibrácii čísel daných človeku vyčítať veľa užitočných informácii, napomáhajúcich zlepšiť životný štýl, odstrániť bariéry či poodhaliť najskrytejšie hlbiny ľudského vnútra. Táto v našom svete netradičná vedná disciplína vychádza z faktu, že všetko je v pohybe a pod vplyvom vibrácii čísel.“<br /><br />V interpretaci výsledků svých rozborů si numerologové mezi sebou mnohdy odporují, přičemž jimi odhalované „poznatky“ jsou mimoběžné racionální kauzalitě. Zákazník bývá oklamán sebejistotou závěrů, které se přitom hodí prakticky na kohokoli – jde o takzvaný Barnumův efekt. Phineas Taylor Barnum byl cirkusovým podnikatelem 19. století – „jasnovidcem“. Barnumovým efektem později nazval Paul Meehl tendenci hodnotit smyšlený popis osobnosti, jakoby přesně odpovídal vlastní osobě daného člověka. Asi před 50 lety termín mezi psychology zdomácněl, prováděla se pozorování a experimenty.<br /><br />Je téměř jisté, že vážnost numerologie je posilována její blízkostí „královně věd“ – matematice. Obě oblasti „pracují“ s čísly! Matematika se v novověku s číselnou magií rozešla, stala se jazykem vhodným pro vyjádření obecných přírodních zákonů i méně obecných pravidelností a symetrií. Postupně se stala samostatným vědním oborem. I v matematice, respektive v její filosofii se však „zabydlily“ záhadné problémy tušené již starými pýthagorejci. Na příklad: Jakým způsobem čísla existují? Proč je matematika tak účinná při poznávání světa? Do jaké míry je výstavba matematiky záležitostí logiky a do jaké míry intuice? Samozřejmě, že numerologie si takové a podobné otázky neklade, spíš dává odpovědi, neboť je suverénně „vševědoucí“ jako všechny jasnovidné manipulace s psychikou. Numerologie ovšem může být také jen hrou pro obveselení, stejně tak jako nejrůznější lidové pověry, které spíš baví a nejsou brány příliš vážně.<br />Psychologická potřeba a funkce víry<br /><br />Na druhé straně lze říci, že magie čísel i se svým levobočkem numerologií patří do bohaté drúzy čarování, které vyrůstá z touhy ovlivnit věci jakýmsi zkratem, kouzlem, obelstít neúprosnost přírodních dějů a návaznosti dějů s jejich příčinami a následky. Je to potřeba hluboce zakořeněná v lidské kultuře, jak dosvědčují mýty, pohádky, všechna náboženství i naše sny.<br /><br />Psycholog PhDr. Václav Vlček tento fenomén vysvětluje potřebou víry: „Součástí lidské psychiky je i schopnost víry. Uvěření v cokoliv, tedy i v nadpřirozenou moc čísla, není výjimkou. Obsahuje v sobě schopnost posílit či obnovit narušenou homeostázu čili psychickou rovnováhu. Vnější sociální prostředí naši psychiku neustále zatěžuje. V okamžiku potřeby posílit psychickou rovnováhu se většina jedinců uchyluje k zástupným vysvětlením, či posílením sebe sama intenzivním uvěřením de facto v cokoliv. Tato schopnost lidské psychiky - posílit sebe sama – obnovovat si psychickou rovnováhu – je zřejmě stará jako trvání lidského rodu. Z hlediska psychologie v tomto procesu nelze spatřovat nic špatného, pokud nezačne ovládat náš život, nestaneme-li se oběťmi šikovných parazitů, kteří nám například spekulace s čísly za úplatu vnucují. Ono totiž všechno, byť by to bylo sebeabsurdnější, co dodá, třeba jen krátkodobě, psychickou sílu překonat zátěžové obavy, překážky či situace, je pro lidskou psychiku přínosem. Musí však být splněna jedna podmínka – na této psychické pomoci se nesmím stát závislým.“<br />Závěr<br /><br />Po prostudování literatury s tématem numerologie a webových stránek numerologů či esoteriků, kteří si ji přivzali pro zpestření do své nabídky věšteckých technik, lze nutně dospět k přesvědčení, že samotná numerologie je obor úzký, prostinký a nepřesvědčivý. Magie čísel a prezentace čísel v náboženství, magii a pověrách je ovšem téma bohaté, s mnoha historickými odkazy a společensko-psychologickými aspekty a je zajímavá jako všechna svědectví o představách člověka v průběhu staletí.<br /><br />Pověry, víra v magii a zázraky, mýty a esoterická symbolika jsou součástí kultury, historie a náboženství. Je výhodné vnímat je především v tomto kontextu nebo také jako atributy vypovídající o lidské psychice a o potřebě jistoty, o touze po nevšedních schopnostech a znalostech, které by jedince zvýhodnily. Jak ale ukazuje praxe, člověka, který se o ně opírá, řídí se jimi a věří jim, mohou v praktickém životě dezorientovat, poškodit, jsou prostě špatnými rádci. V poznávání světa a při rozhodování se osvědčilo získat kvalitní informace, znát fakta, všímat si reality, preferovat racionalitu před domněnkami, „kouzlením“, pocity a vírou.<br /><br />Na modelu takzvané magie čísel a módní věštecké a „poznávací“ numerologie, která se symbolikou čísel souvisí, lze demonstrovat, jak zavádějící jsou některé vykonstruované modely „zjišťování pravdy“.<br />Dodatek:<br /><br />Číselné hříčky svádějí k představě o magii čísel. Například tato:<br />123456789 x 8 + 9 = 987654321. Takových překvapení je v matematice a ve hrách s čísly mnoho a mohou svádět k domněnce, že čísla se při jistých konstelacích „chovají“ zvláštně. Jejich součástí jsou i tzv. „magické čtverce“ rozdělené na devět polí a obsazeny číslicemi. Confucius vypráví, jak se císař žijící kolem doby 2200 př. Kr. zabýval stavbou hrází když se mu zjevila božská želva Chi. Na zádech měla nakreslený obrazec, který přepsaný do našich číselných symbolů vypadal takto:<br /><br />4 9 2<br />3 5 7<br />8 1 6<br /><br />Magický čtverec se soustřeďoval kolem Číňany oblíbeného čísla pět. Všechny svislé a vodorovné řádky včetně úhlopříček dávají součet 15, přičemž v rozích jsou sudá čísla a uprostřed stran lichá. Tento čtverec se těší oblibě i v islámu. Muslimové věří, že obsahuje prvních devět písmem arabské abecedy ve starém semitském pořadí, která byla zjevena Adamovi.<br />Literatura<br /><br />1. Budoucnost – odhalte, co vás čeká. Knižní klub Práh, 1996 (Autoři ani místo vydání - neuvedeno)<br />2. Fuchs J.M.: Tajemství čísel aneb Úvod do numerologie, Schneider vydavatelství, Brno (Rok vydání neuveden)<br />3. Karlíková L., Šír Z.: Číslo a jeho symbolika od antiky po renesanci. Centrum pro studium demokracie a kultury, 2003 (Místo vydání neuvedeno)<br />4. Streuthersová J.: Kniha osudu – praktický průvodce věštěním budoucnosti. Media klub, 1998 (Místo vydání neuvedeno)<br />5. Tajemný svět čísel – Mytologie a symbolika. Vyšehrad, Praha 2002 (Autoři neuvedeni)</p>
<p style=\"text-align: left;\"> </p>
<hr />
<p style=\"text-align: left;\"> </p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:2;a:3:{s:4:"type";s:4:"text";s:7:"content";s:19520:"<p><br />Okultismus v předválečných časopisech<br /><br />Současná média vedená přirozenými komerčními zájmy se nevyhýbají neseriózním až dryáčnickým tématům, pokud se domnívají, že mají potenciál zaujmout. Do jejich arzenálu patří – kromě zločinu, katastrof a sexu – esoterika. Je to oblast sice vágních ale pro mnohé přesto zajímavých informací, v níž lze nejsnáze fabulovat a dráždit fantazii. Trh pouze nereaguje na potřeby lidí, on je také vyvolává, přesto nechci nad tím lamentovat natož moralizovat, zajímají mě víc motivace, racionální či iracionální podloží doby a fakta.<br /><br />Za bývalého režimu se esoterici a léčitelé v médiích vyskytovali jen vzácně, za války i po ní informace zkreslovaly a ovládaly režimní ideologie, všechno jimi bylo nasvíceno, žárlivě nepřipouštěly konkurenci. Ale jak s těmito tématy nakládaly tiskoviny za první republiky? Nebo dokonce v dobách pozdního Rakouska Uherska?<br /><br />Strávila jsem v archivu tiskovin při Národním muzeu mnoho hodin a dní, abych postupně zjistila překvapivá fakta.<br /><br />Přednost měla popularizace vědy, kultura a umění<br /><br />Tylovy obrozenecké Květy z roku 1848 (to už existovaly patnáct let) samy sebe označovaly Národní zábawník. Po divotvornostech tu nebylo památky. Tehdejší čtenáři zábawníku by asi užasli nad tím, čím se baví v zábavných časopisech čtenáři v naší době. Květy v roce 1871 měly větší formát, jejich nakladatelem byl dr. Edvard Grégr a redaktorem například Vítězslav Hálek. V tomto ročníku konečně nalézám článek z oblasti tajemna a mýtů. Jmenuje se Ďáblovy předkové. Brzy zjišťuji, že jde o seriózní studii o podobách ďábla v dějinách, literatuře či v představách lidí - od hloupého lidového čerta až po svádivého, výmluvného Mefistofela či po ďábla v knize Jobově, který partnersky komunikuje s Bohem a sází se s ním. Tato zasvěcená úvaha (napsal ji A. Fux) by byla zajímavá i pro mnohé dnešní čtenáře. V témže ročníku nacházím článek Zkamenělý mlok z uhlí nýřanského, s podtitulem Jak vypadala zvířena za doby permské. Občasné zprávy ze života vědy a techniky nejsou vzácné. V té době se žilo hodně kulturou, jsou zde články například o tom, který evropský malíř právě dokončil významné dílo, byla zde rubrika Ze světa divadelního a duchovního, literární hlídka, v níž třeba nalézáme Arbesovu studii Poovy básně Havran. Oblíbená je přírodověda a její objevy. (Například článek K historii meteorů, Národní museum zakoupilo vzácný exemplář Křemivky ozdobné atd.)<br /><br />Ani v Ilustrovaném Kurýru jsem při hledání esoterických témat neuspěla. Přelom devatenáctého a dvacátého století zato fandil technice a vědě. Tak například v ročníku 1894 se 3. ledna snaží redaktor vysvětlit legendu o Věčném Židovi Ahasferovi a dalších podobných osobách, kolem nichž vznikaly podobné novodobé mýty. Tuto úvahu ovšem vyprovokovala přednáška znamenitého specialisty pro choromyslné Dr. Henry Meigeho, který přítomným vysvětlil, že se jedná o duševní nemoc, která se jeví v zatím nevysvětlitelném a neukojitelném pudu po putování a cestování z místa na místo. Citace: chorobný původ legendy vědeckou analysí nabývá zajímavějších podkladů, k nimiž uvádí dr. Meige doklady současné.<br /><br />10. ledna otiskuje Ilustrovaný Kurýr populárně vědecký článek o mamutech na Sibiři v té době nalézaných. Téměř v každém čísle tohoto časopisu je článek, který navozuje jakési tajemno, ale vždy má racionální vysvětlení. Jsou to texty roztomile naivní a průhledné ve svém záměru vymlouvat lidem pověry a působit na čtenáře osvětou. Redaktor si například libuje, že se příteli povedla spiritistická seance a duch ochotně odpovídal klepáním, aby na konci článku čtenáře zklamal - přítel se druhý den dozvídá, že v tu dobu klepal do zdi soused, zatloukal skobičky na zavěšení obrázků.<br /><br />25. ledna 1894 jeden z článků informuje o přírodovědecké operaci za účelem pátrání po podstatě a účinku hadího jedu. Obdivovaní přírodovědci jsou i s hadem nakreslení přes celou titulní stranu. Naopak pokáráni jsou občané, kteří uvěřili, že v kostelíku nad Chuchlí řádí démon. Kostel se totiž opravoval a řemeslníci jej prý znesvětili oplzlou řečí. Jednou do něj vběhl nepozorovaně vyhublý, nejspíš cikánský koník a byl tam omylem zamčen. Koník vyváděl, zoufal si, a občané z okolí se před kostelíkem třásli strachy. Otevřeli, až když hrůzné zvuky utichly. Závěrečná věta článku čtenáře jistě dlouho trápila: Hynul zde ubohý kůň, věrný soudruh chudákův. A zahynul zajisté vinou pověrčivých lidí.<br /><br />V březnu Kurýr z roku 1894 přináší zprávu o \"úžasném pokroku ve vědě lékařské“ Jde o elektrický přístroj k osvětlování jícnu a žaludku.<br /><br />Dalším zábavným čtivem byl prvorepublikový A - Zet Pondělník. Ten v jednom z čísel v roce 1930 informuje například o úspěchu českých entomologů, kteří v naší republice objevili dva nové druhy bezkřídlých much. V tomto časopise jsem konečně narazila na článek z oblasti tajemna. Vyšel 24. února 1930 a měl titulek Tajné vědy ve službách veřejnosti. Byl psán kurzívou a obsahoval reklamní sebechválu profesora grafologie Fencla-Bílovského. Kromě grafologie má prý úspěchy v předpovědích za pomoci televise. Tak bylo možno nazývat přenos vizí na dálku v době, kdy ještě skutečná televize neexistovala. Článek byl zjevně placenou reklamou, což potvrzuje jednak kurzíva a hlavně to, že sebechválu sepsal divotvůrce sám a opatřil jej i svou adresou. V témž čísle je obsažný článek z oblasti archeologie pod titulkem Objevitel Tutanchamova hrobu zahájí pátrání po hrobu Alexandra Velikého.<br />12. května 1930 v A - Zet Pondělníku vyšel článek, který odhaluje podvodné praktiky německého a také našeho léčitele. Stojí za přetištění.<br /><br />Titulek a podtitulek zní: Zeileis překonán zázračným západočeským lékařem. Zázračný lékař rozmnožuje recepty na cyklostylu. Zjišťuje nemoci škrábáním do nehtů. Léčí choroby na dálku. Otiskli jsme nedávno několik zkušeností nemocného, který se léčil v Galspachu u Zeileise. Devět tisíc ordinací za den je jistě úctyhodný výkon, ale zdá se, že Zeileis je překonán jiným mastičkářem bydlícím u Karlových Varů. Tento zázračný lékař, říká si Wunderartz rozumí také všemu, ale Zeileise překonává v tom, že pacientům rozdává recepty tištěné na cyklostylu, čili ví napřed, že všichni stůňou na stejnou nemoc a potřebují tedy stejné léky. Diagnózu provádí tak, že nemocného poškrábe kostěným nožem po nehtech a potom prohlásí: jste nemocen se žaludkem. Nemocný řekne, že ne, ale doktor ho usadí: však vy budete. A uhádne to. Skutečně po léku, který předepíše zároveň k pití i k mazání dostane každý žaludeční bolesti a potom se jde teprve léčit k pořádnému lékaři. Český překlad německého receptu zní: do půllitru vody pět náprstků speciálního čaje, pět minut vařit a pít ráno, v poledne a večer. Kromě toho dát ráno čtyři lžíce téhož do umyvadla a dřít si tím záda od shora dolů. Toto se musí udělat šestnáckrát. Čaj lze koupit jen v drogerii u pana Erla v Jirkově a stojí 35 - 55 korun. Určit nemoc umí tento mastičkář stejně jako Zeileis, který nedávno našel na úplně zdravém Pražákovi tuberkulózu střev. Jeden dobrý člověk pak přinesl panu doktorovi lahvičku s kozí močí a říkal, že mu stůně žena. Zázračný lékař zahřál moč nad svíčkou, zamyslel se a řekl: Vaše žena má srdeční vadu, je hodně nervózní a má těžký revmatismus. Ať sem přijde za pět neděl, ale sama. Žena tohoto dobrého člověka je ale zdráva, a jenom lituje, že se tento článek zřejmě nedostane ke všem důvěřivým lidem, kteří chodí za schopným krajanem v procesí.<br /><br />V té době se téměř ve všech časopisech probírá netvor v jezeře Ness. V článcích jsou proti sobě stavěny pochybnosti vědců a odborníků a tvrzení různých svědků. V neprospěch svědků hovoří fakt, že jednou má obluda hlavu jako pes, podruhé jako ovce, potřetí se podobá nosorožci.<br /><br />V ženském časopise Hvězda jsem například v celém ročníku 1939 nenalezla článek z oblasti tajemna. V kalných vodách lovila jen pro nás dnes už úsměvná reklama na úžasný Nobelin prostředek k dosažení nádherného poprsí. V ročnících nejrůznějších zábavných a společenských časopisů jsem pořád ještě nenašla jediný horoskop. Jen inzertní stránka je zamořena vždy pěti až deseti byť jen dvouřádkovými inzeráty jasnovidek a kartářek. Například: Duševním zrakem pronikám všechna tajemství. Přijďte. Vylíčím vývoj života. Předvedu vědecký objev. Uvádím do pohybu síly, které přispějí k štěstí v povolání, manželství, lásce, podnikání. Přijmu i pozvání do rodin. Předvedu objev. Uvádím do pohybu síly, které přispějí k štěstí v povolání, manželství, lásce, podnikání. Přijmu i pozvání do rodin. Předvedu objev. Pozoruhodná je jasnovidčina nabídka, že předvede vědecký objev. Svědčí přinejmenším o tom, že věda požívala vážnosti a zdálo se být chytré se vědou ohánět.<br /><br />Zábavný časopis Expres si 24. 7. 1934 všímá v článku Znamení těžkých dob, rozkvětu živnosti kartářek. V článku se píše o souvislosti tohoto řemesla s momentální hospodářskou krizí, nezaměstnaností a bídou: Jestliže kartářky a jasnovidky bývaly od nepaměti, dnes se tato volná živnost rozmnožila přímo úžasně. Před padesáti lety bylo v celé Praze ne víc než dvacet kartářek, odhaduje se nyní úředně hlášených kartářek vysoko nad tisícovou číslici. To je jistě velmi zajímavý zjev v době pokroku a vynálezů. Ovšem je zřejmé, že neobvyklé rozšíření tohoto stavu se musí hlavně přičíst těžké době.<br />Spiritistické časopisy<br /><br />Zvláštní kapitolu tvořily na přelomu století i za první republiky časopisy věnované spiritismu. V časopise s přiléhavým názvem Hvězda záhrobní z roku 1899 jsem v článku Astrologie za našich dnů objevila větu, která do jisté míry vysvětluje, proč se mnozí lidé tehdy i dnes nedokáží spokojit s tím, co nabízí věda: Materialismus dal vše co mohl, ale vážní hledatelé pravdy, neukojivše svou duševní žízeň, čekali od budoucnosti více pronikavějších, více pravdivějších odhalení. Jistou výpovědní hodnotu měl článek v témže časopise: Zjevení a jich vědecká dotvrzení. Ukazuje, že dovolávání se vědy není až trik dnešních okultistů. Rozdíl je ovšem v tom, že se tyto laické a blouznivé texty do běžných novin a časopisů, až na vzácné výjimky, nedostaly.<br /><br />V časopise Hvězda záhrobní se v témže roce (1899) například píše: Nemožno, ujišťují skeptici, aby některý člověk zjevil se jinému anebo aby oznámil mu svůj příchod ze života do smrti. Slovo nemožno přestalo platiti již ode dob Napoleonových. Vyškrtnuto bylo i z filozofického slovníku po neočekávaných a podivuhodných objevech současné fyziky. Ten, kdo odvážil by se za naší doby, po fotografii, páře, telegrafu, telefonu, spektrální analysi hvězd, vnuknutí a hypnotismu, vymezit hranice možnosti, daleko ještě nevyrovná se nejmenšímu žáčkovi národní třídy. Že zázračná technika byla v představách lidí sestrou tak zvaných věd psychických, dokládá mimo jiné i článek v revue Proč žijeme? z roku 1909. Je v něm článek Fotografie neviditelna. Fotograf zachytil médium v transu a na fotografii, ve světelné čmouze vedle média, rozeznává astrální tělo. Článek komicky ignoruje fakt, že by mohlo jít jen o pokažený snímek a tváří se badatelsky. Další články mají názvy: Zprávy ze seancí, Telepatické přenášení myšlenek, Mumie, Udělání dobytku, Soudní pře o strašidelný dům (probíhal v Neapoli).<br /><br />Čím se liší tato témata od těch dnešních? Především tím, že naplňovaly téměř výhradně specifické časopisy, neměly přístup do serióznějších tiskovin. Pro běžné noviny a časopisy to byla témata nedůvěryhodná, neseriózní a vlastně trapná.<br /><br />V okultním časopise Československá revue psychická z roku 1938 najdeme vedle článků Zemřelý Schumann objevuje svůj ztracený koncert nebo O tibetských lamech také Horoskop presidenta Dr. Beneše. Fiasko astrologů je až dojemné. Rok před obsazením našeho státu Němci, nedlouho před Benešovou emigrací, prorokují astrologové prezidentovi v příštích letech bezoblačný život, plný úspěchů a pohody.<br /><br />Po válce se některé spiritistické časopisy opět na krátký čas vynořily nad vodu, než je smetla spolu s náboženstvím ideologie žárlivá na všechny ostatní. Psychická revue se ještě 15. 5. 1947 mohla zabývat problémem: Mohou zhmotnění duchové také jísti? Odpověď zní: mohou. Důkazem je prý médium, které nemohlo vystát rajská jablíčka a keksy. Přesto, když se do něj vtělil duch, obě tyto poživatiny s chutí snědlo.<br /><br />V roce 1947 se spiritisté radovali ze svého sjezdu, neboť ten poslední měli před válkou. Jasnovidci a média naplněni optimismem na sjezdu jasnozřeli, že: ve velmi blízké době třetina lidstva pozvedne hlavu od země a počne duchovně mysliti. Vítězný únor a brzký konec vlastního spolku, jim ovšem potměšilí duchové neprozradili. Jeden z článků v tomto ročníku mi připomněl dnešní výrobce a prodejce přístrojů na okultní bázi, šlo o Telefon do záhrobí: Význačný anglický badatel v oboru spiritismu prohlásil, že není daleko doba, kdy bude možné telefonovat do záhrobí. Finanční cena tohoto výrobku by neměla převyšovat 20 dolarů. Myšlenky duchů budou ve chvíli podávání zpráv ze záhrobí měnit hbitost ionizace v trubkách naplněných ušlechtilými plyny. Tyto změny vytvoří signály, které telefon ze záhrobí zesílí. Článek končí exaltovanou výzvou: Lidstvo se chce spojiti s těmi, kteří nás předešli a mezi oběma stranami bude vládnout živé pouto vzájemnosti a lásky, práv a povinností.<br /><br />Tyto kuriózní časopisy vydávali jednotliví nadšenci, a to mnohdy jen po několik měsíců, v jednom regionu a v maličkém nákladu, kromě časopisu Spiritická revue, která byla ve dvacátých letech šířena po celé republice a Hvězdy, která vycházela ve větším nákladu v roce 1910. Například Hvězda záhrobní vycházela jen v jednom regionu od roku 1899 do roku 1910. Byla pak přejmenována na Slunce a rok nato zanikla. Pentagram vycházel jen v roce 1919 - celkem vyšlo 5 čísel. Isis vyšla kolem roku 1905 a pak až několikrát v rozmezí let 20 - 30, podle finančních možností majitele. Lucifer vyšel několikrát v roce 1913. Církev ovšem protestovala proti jeho názvu, přestože se majitel bránil, že nejde o ďábla, ale o Světlo. V roce 1914 byl Lucifer přejmenován na Zasvěcení a poté zanikl. Časopis Horev (staroegyptský výraz pro oheň) vyšel jen pro malý okruh příznivců v roce 1938. Spiritismus se u nás praktikoval hlavně v podhůří. Šířil se k nám včetně dalších okultních teorií především z Francie, která byla centrem tajemna už díky svým zednářům a resekruciánům.<br /><br />Tehdejší iracionalitu v médiích odlišuje od jejího dnešního masového šíření právě to, že šlo o jev okrajový. Ve vysokonákladových, celostátně šířených časopisech měla přednost vědecká osvěta, byly oslavovány technické vynálezy a vysmívána pověrčivost.<br />Fenomén Pestrý týden<br /><br />Jednou ze vzácných výjimek byl pěknými fotografiemi bohatě vypravený časopis Pestrý týden. Ten míval po jistou dobu stránku nazvanou Metafyzika (nikoliv v každém čísle), kde se pojednávalo o supranormálních úkazech z celého světa. Jako velkou senzaci například uvádělo jisté sedmdesátileté médium z Podmokel, kterému se prý po dvaceti letech cvičení daří silou myšlenky udržet předměty na různých místech svého obličeje. Toto médium prý v celé okultní literatuře nemá sobě rovného. Pestrý týden na stránce Metafyzika v roce 1931 uveřejňuje odpovědi evropských universitních profesorů povětšině z technických universit na své anketní otázky. Na otázku č. 1: jaký je dnes vztah širší veřejnosti ve Francii, Německu, Anglii atd. k otázkám metapsychologickým odpovídá například Dr. Ing. C. Blacher, profesor chemicko-technického institutu univerzity v Rize takto: Podle mého mínění neprobudilo se dosud v široké veřejnosti porozumění pro význam metapsychologických problémů. Jak tomu také může být jinak při štvaní proti médiím (tím se rozumí hypersenzitivní osoby, pozn. aut.) jak je provádějí různí nám známí vědátoři - zajisté nepotřebuji uváděti jmen.<br /><br />Dále na starostlivé otázky o osud metapsychologie odpovídají například soukromý docent na spolkové vysoké škole technické v Curychu či profesor fyziky na univerzitě v Oslo. Všichni tito profesoři byli ovšem zároveň redaktory okultních časopisů. Jak je vidět, už tehdy existovali technici, přírodovědci a jistě i lékaři, kteří emigrovali z exatních věd do světa okultního, kde je jaksi volněji.<br />Závěr<br /><br />Studium starých tiskovin potvrdilo mou domněnku, že od poloviny devatenáctého století do začátku druhé světové války ve století dvacátém se v našich zemích v médiích esoterice a okultismu nedařilo. Duch doby preferoval rozum, vědu, techniku. Například spiritistické časopisy živořily na okraji společenského zájmu. Takže totalitní doby, které pak přišly, neměly co potlačovat. Můžeme-li se spolehnout na ústní podání, naopak, vysoce postavení soudruzi leckdy vyhledávali lidové léčitele, kteří byli tím pádem přinejmenším tolerováni. A ministr školství Kahuda se s podporou strany a vlády mohl věnovat svému obskurnímu výzkumu telepatie a telekineze v Psychoenergetické laboratoři.<br /><br />To co se v médiích v oblasti propagace různých mágů, léčitelů, jasnovidců, senzibilů a jejich praktik děje dnes, nemá v moderních dějinách obdoby. Stejná situace je i v dalších státech, o USA nemluvě. Příčin je jistě mnoho a jev souvisí se stavem světa, lidstva, s trendy v myšlení a cítění milionů. Některé příčiny by se daly jistě odhadnout a pojmenovat takříkajíc od stolu, ale téma odklonu velké části médií od serióznosti a rozumu k iracionalitě a pestrým podobám esoteriky by si zasluhoval hlubší studium.</p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:4;a:3:{s:4:"type";s:4:"text";s:7:"content";s:24800:"<p><br />Věda zkoumá „tunel do věčnosti“<br />Zážitky blízkosti smrti očima vědy<br /><br />Člověk žije s vědomím, že jednou zemře. Tato neradostná pravda stojí v pozadí našich skutků, záleží nám na kvalitě vyměřeného života – snažíme se jej naplnit prací, skutky, požitky tělesnými a psychickými, replikujeme se, abychom žili do jisté míry ve svých dětech, některým jedincům se podaří vytvořit předměty nebo díla, které je přežijí. Tak se chová nejen jednotlivec, ale i celé kultury a civilizace. Druhou cestou jak minimalizovat stres ze smrti jsou náboženské představy posmrtného života, idea nesmrtelné duše. Je pravděpodobné, že tyto představy v pradávnu vznikaly také proto, aby člověka v hrůze ze smrti utěšily. A všechna náboženství velká i marginální, sekty i okultismus se o takzvané mystérium smrti a o život věčný opírají, stejně jako hrají roli ve fenoménu, pro nějž vzniklo označení „zážitky blízkosti smrti“. Tyto zážitky věřícím nejen poskytují důkazy pro jejich víru v posmrtný život, ale zbavují je i obav z umírání.<br /><br />Zatímco nemocný básník Jiří Wolker říká: Smrti se nebojím, smrt není zlá, smrt je jen kus života těžkého. Co zlé je, to umírání je, zážitky blízkosti smrti (anglicky near-death experience) jakoby naopak svědčily o tom, že umírat je úžasné. Do středu pozornosti veřejnosti se dostaly poprvé zásluhou Elisabeth Kübler-Rossové, která se věnovala problémům smrti a umírání. Především ale po publikaci knihy amerického lékaře a filosofa Raymunda Moodyho „Život po životě“ v r.1975. Moody v ní publikoval zprávy o předsmrtných stavech, které sbíral od svých pacientů. Popisované zážitky nejsou hrůzyplné, naopak. Jeho kniha vyvolává představu, že umírání může být mystickým, smiřujícím a povznášejícím prožitkem přechodu do dalšího bytí. Podle Moodyho jsou zážitky u lidí i s různou anamnézou podobné, podivuhodně homogenní. Typická je představa tunelu, se světelnou září na jeho konci, do níž pacienti vstupují. Často se u nich objevovaly pocity odloučení od vlastního těla, tzv. zážitky mimotělové, někdy před jejich zrakem proběhl celý jejich život, setkávali se s blízkými zemřelými nebo svatými. Zážitky blízké smrti nejsou příliš vzácné - popisuje je pětina osob, které postihl například infarkt, srdeční zástava nebo jiná kritická situace. Jde o povznášející, euforický, mystický zážitek, který člověka povýší, zasvětí, hluboce ovlivní jeho další „přidaný“ život. To jsou závěry, k nimž často dospívají nejen ti, kteří mají za sebou zážitek blízkosti smrti, ale i čtenáři knih Raymonda Lodyho. Reakce na jeho knihu Život po životě i na další, které následovaly, byly ale rozporné.<br />Jaké prožitky ve své knize jeho respondenti popisují?<br /><br />Mnozí se ve stavu klinické smrti pohybovali tunelem vstříc nevídanému jasu a světelné postavě. Cítili přitom blaženost a nekonečnou harmonii. Světlá postava v bílé říze jim kynula vlídně rukou, vítala je na onom světě. Slyšeli hudbu, zvonky, šumění. Někdy spatřili své tělo z nadhledu, v jiných situacích se dalším zrychleně promítl v obrazech jeho život. V závěru bývali taženi zpět do života, většinou pocitem povinnosti vůči svým blízkým, nedokončeným dílem. Takové zážitky si obvykle každý pamatuje jako příjemné, euforické.<br /><br />Zážitek blízkosti smrti tak, jak ho podal ve své knize Raymond Moody podporuje u lidí tíhnoucích k trascendenci a náboženské víře mystické a spirituální představy. Naproti tomu mnozí psychologové, psychiatři a fyziologové o jeho nasbíraném materiálu prohlašovali, že jde o pouhé halucinace. Skutečnost je ale složitější.<br /><br />Americký psycholog Kenneth Ring shromáždil výpovědi 102 osob, kteří přežili infarkt myokardu a zažili syndrom blízkosti smrti. 60 % z nich zažilo nezvykle silný a konejšivý pocit klidu a míru, 37 % se vidělo být odloučeno od svého těla, 23 % prožívalo pohyb temným tunelem, 16 % z nich se přibližovalo ke světlu a 10 % do nezvykle silného a přitom neoslňujícího světla vstoupilo. Ring zjistil, že vznik a průběh těchto zážitků u jednotlivých osob neovlivňují demografické rozdíly, tedy věk, pohlaví, vzdělání, stav nebo sociálně ekonomické postavení. Často jde ale o lidi s velkou představivostí, úzkostnější a neurotičtější než je běžný průměr. Bývají to osoby, které měly problémové dětství, jsou vnímavé, a tedy to bývají častěji introverti nebo ti, s nimiž se špatně zacházelo, bývali často nemocní a vůbec měli těžký život. Další podmínkou, která přeje takovému zážitku je fakt, že dotyčný ví, nebo je alespoň přesvědčen o tom, že umírá, a je déle než minutu v bezvědomí, v mnoha případech na resuscitačním oddělení, to má totiž zásadní zásluhu na tom, že se dotyčný vrátí zpět, mezi živé. Protože Ring nevyvozoval ze svých poznatků spirituální závěry, byl jeho výzkum prvním krokem k tomu, že se tento syndrom stal předmětem zájmu seriózních vědců, psychologů a lékařů. Mnozí badatelé tohoto jevu se domnívají, že předsmrtný prožitek může být úzkostnou reakcí na hrozbu smrti.<br />Co se děje v umírajícím mozku?<br /><br />1. Především se mění poměr krevních plynů, kyslíku a kysličníku uhličitého. Při různých stupních bezvědomí provázejících předsmrtný stav přestává v určitém okamžiku mozek dostávat dostatečné množství kyslíku. Na jeho nedostatek je velmi citlivý hlemýžď v uchu, a jeho zvýšená aktivita má za následek produkci různých zvuků, především zvonění, šumění, někdy ale i nedefinovatelnou hudbu. Kyslíkový deficit je spojen s hyperkapnií – zvýšeným obsahem oxidu uhličitého v krvi. Už v padesátých letech L. J. Meduna, psychiatr na univerzitě v Illinois podával pacientům směsi kyslíku a kysličníku uhličitého v různém poměru. Vyvolal tak u nich pocit lásky všehomíra, dále sugestivního přesvědčení chápání všeho, pocity souznění a extáze. Větší množství CO2 v krvi mělo za následek vidění kruhů vtahovaných do trubky nebo nálevky, tanec jasných barev, pocit oddělení vědomí od těla. Pocity euforie, popisované obvykle lidmi, kteří přežili klinickou smrt, mohou podle odborníků souviset s nedostatkem kyslíku. Když přestane pracovat srdce, rychle klesá hladina kyslíku v krvi a naopak přibývá oxidu uhličitého. Pro nastartování zážitků blízkosti smrti je důležité, jak rychle k úbytku kyslíku v krvi dochází. Zjistilo se, že podobným zážitkům nepřeje, je-li úbytek náhlý, v takovém případě člověk upadne prostě do bezvědomí. Je-li pomalý, mozek zase stihne její důsledky postupně kompenzovat. Jen středně rychlý úbytek kyslíku je klíčový pro vznik předsmrtných zážitků.<br /><br />2. Částí mozku, která je na snížený krevní tlak obzvlášť citlivá, je spánková oblast. Zásobují ji totiž nejtenčí cévy na samém konci rozvětveného krevního řečiště. V hloubce spánkového laloku přitom sídlí limbický systém, který zodpovídá za naše emoce. Například piloti stíhaček při prudkých změnách směru, kdy vzniká přetížení a mozek se částečně odkrvuje, často pociťují příjemnou závrať a euforii. Podobné pocity mívají také lidé s nižším krevním tlakem, když rychle vstanou.<br /><br />3. Do mozku přestanou zvnějšku proudit smyslové informace, a začne si tedy vytvářet své vnitřní obrazy, vznikají halucinace. Halucinace ovšem není nic mlhavého, naopak, má pro halucinujícího všechny rysy reality, a není ani příliš vzácná, jak se běžně soudí. Přechodné halucinační zážitky může mít i jedinec netrpící žádnou duševní poruchou. Halucinační zážitky psychicky zdravých osob při absenci smyslových podnětů zvnějšku – tedy při tak zvané smyslové deprivaci jsou známou činností mozku.<br /><br />Se smyslovou deprivací pracuje experimentální psychologie již od šedesátých let. Pokusné osoby leží v naprosté tmě ve zvukotěsné místnosti do chvíle, než se objeví halucinace. Častý je intenzivní pocit vznášení. Podobné experimenty potvrzují teorii britského neurologa Jaksona, který už ve třicátých letech minulého století tvrdil, že paměť a vnitřně vytvářené obrazy jsou brzděny proudem smyslových informací. Pokud informace z vnějšího světa nepřicházejí, nebo je člověk nevnímá, je například v bezvědomí, mohou vznikat halucinace. O takových zážitcích vypovídají i lidé, kteří byli na čas uvězněni ve tmě a tichu, například při závalech. Je znám případ dvou horníků, kteří byli šest dní uvězněni 300 stop pod zemí v naprosté tmě a tichu, Vypovídali pak, že vnímali podivná světla, viděli dveře, mramorové schody, ženy se zářivými těly a nádhernou zahradu…<br /><br />4. Do mozkomíšního moku jsou uvolňovány endorfiny, vnitřní hormony zklidnění a slasti. Ty omývají mozkové a míšní buňky, potlačují bolest, navozují pocity radosti, míru a klidu. Jejich zvýšená hladina byla především vystopována u lidí, kteří poté vypovídali o zážitku jakési revize vlastního života v obrazech, a o vizích jiných světů. Endorfiny tvoří skupina takzvaných opioidních peptidů (endogenních morfinů). Vznikají štěpením prekursorové bílkoviny v mozku, pankreatu, placentě a pravděpodobně i v dalších tkáních. Působí jako neurotransmitery a neuromodulátory. Váží se, podobně jako morfin, na opiátové receptory v plasmatické membráně cílových buněk a mají i podobné účinky: příznivě ovlivňují náladu, tlumí bolest a ovlivňují výdej některých hormonů. Viz např. přehledný úvod Alice Skoumalové Biochemie hormonů odvozených od aminokyselin a proteinů.<br /><br />5. Dochází ke zrušení běžného útlumu, mozek je vybuzen a jsou potlačeny zábrany ve zrakové kůře. Změny v metabolismu mozku mají za následek nervový šum. Další a další buňky jsou aktivovány, což navozuje vnitřní vidění intenzivního světla, které samozřejmě neoslňuje, protože nemá nic společného s očima, takže mívá za následek zážitek extáze.<br /><br />6. Někdy dojde k zážitku odosobnění, k takzvaným mimotělním zážitkům. Termínem mimotělové zážitky, anglicky out-of-body experience, se označuje pocit odloučení od vlastního těla. Jedinci s tímto prožitkem vyprávějí, že viděli své tělo z výšky a jakoby z pohledu druhé osoby. Takové pocity nejsou vzácné, zažil je ve svém životě téměř každý. Objevují se někdy v průběhu snů, při snění během dne a často je prožíváme i ve vzpomínkách. Dostavují se i při poruchách vědomí po těžších traumatech nebo pod vlivem narkózy a také pod vlivem drog. Někteří lidé takové zážitky popsali, když se zotavovali z těžkého stavu na hranici života a smrti. V tom případě tedy tyto zážitky patří do rámce tzv. „zážitků blízkosti smrti“. Parapsychologové a esoterici se domnívají, že mimotělové zážitky dokazují existenci astrálního světa, do kterého ve chvíli zážitku vstupuje naše astrální tělo. Tento názor odpovídá představám spiritistů, theosofů a antroposofů o existenci čtyř složek lidského těla, těla fyzického, éterného, astrálního a vlastního „Já“. Ale například švýcarský neurolog Olaf Blanke se domnívá, že k takovým prožitkům dochází, když se mozku nedaří správně zkombinovat různé smyslové vjemy: informace od dotykových senzorů, které tělu říkají, že ležíme, signály od vnitřního ucha, které zodpovídá za rovnováhu a pomáhá určit polohu těla, sluchové vjemy, což může být dialog lékařů nad pacientovým tělem. Mozek sice funguje a všechny tyto informace přijímá, ale nedokáže je správně zpracovat a interpretovat.<br /><br />Podle vědeckého zjištění nejde o nic nepřirozeného ani patologického, ale jen o projev aktivace některých oblastí mozkové kůry, ke které dochází z nejasných důvodů ve chvílích sníženého nebo oslabeného vědomí. Mimotělové zážitky lze totiž navodit i stimulací mozkových center elektrickými impulsy, a to v oblasti závitu gyrus angularis, ležícího na hranici pravého spánkového a temenního laloku mozku. Nejde tedy, jak se domnívají esoterici, o potvrzení dualistické koncepce lidského těla o samostatné existenci těla fyzického a duchovního, těla a duše která může existovat nezávisle na těle fyzickém.<br /><br />Podmínkou takového zážitku je, aby si dotyčný byl vědom, že je blízko smrti a aby byl také alespoň krátkou dobu v bezvědomí.<br />Zážitky blízkosti smrti se objevují i v jiných situacích<br /><br />Pod vlivem halucinogenů, například LSD lze prožít někdy kompletní předsmrtný zážitek se všemi příznaky, což je při prožívání mezní hranice mezi životem a smrti spíš vzácné. Už sto let stará studie shrnuje výpovědi pacientů, kteří se podrobili chirurgickému výkonu s pomocí éteru - používal se dříve jako anestetikum. Také oni zažívali „vjezd do tunelu“, hučení, nadpozemské světlo. Obdobný vliv na změny v mozku má hašiš a oxid dusný - takzvaný rajský plyn, který zase nejčastěji umožňuje zážitek odloučení od těla. Také otravy alkoholem mohou přinášet zážitky tohoto druhu.<br /><br />Některé předsmrtné prvky tohoto fenoménu zažívají lidé při akutním ohrožení – horolezci při pádu, lidé v autě blížící se k předpokládané srážce. I když vyváznou bez újmy, mozek se v takovém momentu chová jako ve chvíli umírání nebo při požití některých drog. Popisované zážitky a pocity nemusí bezprostředně souviset se skutečnou smrtí - spíš jde o souhru určitých fyziologických podmínek, při kterých ale život nemusí být vždy v ohrožení. Thomas Lempert z Kliniky Rudolpha Virchowa v Berlíně provedl pokus se skupinou dobrovolníků, kteří se sami přivedli do mdlob kombinací rychlého dýchání a naopak zadržování dechu. Mnozí z nich pak popisovali euforické stavy, mimotělní zážitky, vstupování do jiného světa a setkání s tajemnými bytostmi.<br /><br />Také studie amerických vědců z Virginské univerzity v Charlottesville ukázala, že ze zkoumaných osob, které se ocitly v krizové situaci a následně popisovaly zážitky blízké smrti, by polovina přežila i v případě, že by jim nebyla poskytnuta první pomoc.<br /><br />Tento fakt svědčí pro podezření, že podobné nebo totožné zážitky může nastartovat okamžitý psychologický stav ve chvíli psycho-fyzického poplachu.<br />Dalším spouštěcím faktorem zážitků blízkosti smrti je v některých případech epilepsie spánkového laloku nebo i jen jeho nestabilita, což není nijak vzácná odchylka. Výzkum několika neurologů potvrzuje, že v takových případech se někdy dostavuje odlišné smyslové vnímání, „odstup od těla“ nebo pocit déjá vu – člověk se ocitne v situaci či prostoru, o němž se domnívá, že už ji zažil, že ho důvěrně zná, i když objektivně tomu tak není. Viz např. (Grof, 2004): Nejpozoruhodnější je přesvědčivý pocit, že člověk už něco takového zažil (dejá vécu) nebo viděl (dejá vu).<br /><br />Kanadský vědec Michael Persinger se aktivitou spánkového laloku dlouhodobě zabýval. Všiml si mimo jiné toho, že lidé trpící častěji jeho nestabilitou bývají mnohdy přesvědčeni o svých jasnovidných, telepatických či léčivých schopnostech. Přesvědčují okolí také o tom, že komunikují s „univerzálním vědomím“. Došel k závěru, že náboženské a spirituální prožitky se přirozeně vztahují k aktivitám spánkového laloku.<br /><br />Limbický systém považují odborníci za „centrum duchovních prožitků“. Jeho umělá stimulace elektrickým proudem navozuje transcendentální pocity. Silné duchovní prožitky a zjevení popisují také pacienti trpící temporální epilepsií - tedy druhem epilepsie, která má sídlo ve spánkové oblasti. „Předpokládá se, že touto chorobou nejspíš trpěla například Johanka z Arku, proto byly její činy podpořené hlubokými náboženskými prožitky,“ říká odborník na epilepsii profesor Pavel Mareš z Fyziologického ústavu AV ČR.<br /><br />Při záchvatech epilepsie se někdy objevují záblesky hluboce zasetých vzpomínek, jindy má epileptik pocit, že je vševědoucí, což je přesvědčivý zážitek podobný déjá vu – již viděného. Vědomí toho, že něco znám, je stejně jako mnoho dalších pocitů kontrolováno nervovou aktivitou v limbickém systému mozku. Pokud jsou skutečnosti a znalosti opravdu známé, je aktivován hippokampus, který danou skutečnost signalizuje. Ale tentýž mechanismus se zapojí i při abnormální situaci, jako je například epileptický záchvat, takže pak může dojít k falešné představě, že znám, poznávám, i když skutečnost je jiná. Další epileptici mohou zase při záchvatu vidět zemřelé příbuzné a přátelé. Tyto zážitky byly jistě příčinou toho, že se ve starověku epilepsie považovala za božskou nemoc, ve středověku pro změnu za posedlost ďáblem.<br /><br />Látkou, která vyvolává popisované zážitky je také ketamin, krátce působící, halucinogenní droga, používaná jako disociativní – rozštěpující anestetikum. Používá se v kombinaci se sedativy. Experimenty s použitím samotného ketaminu přinesly zajímavé poznatky: při jeho nitrožilním podání 50 – 100 miligramů se většinou dostaví zážitek, který má všechny rysy spojované se zážitky blízkosti smrti – pocity klidu a radosti, představu odpoutání od těla, tunelový zážitek, telepatický rozhovor s nějakou světelnou bytostí a vnoření do zářivého a přitom laskavého světla.<br />Kristus vítá, Jamadútové unášejí<br /><br />Že jde o ryze lidské a nikoliv nadpozemské zážitky, o tom svědčí jejich sepětí s kulturou, která dotyčného prosycuje svými symboly a hodnotami. Američanům se v takových chvílích zjevuje spíš matka, a odchodu na onen svět se nebrání, neboť není násilný, ale naopak lákavý, což je hodnota, kterou navozuje křesťanský ráj. Indové - hinduisté mívají při  přechodu do „jiných světů“ spíš traumatizující zážitky, protože podle jejich náboženství poslové krále smrti Jama, Jamadútové, člověka v komatu násilně unášejí. Muslimy vítá na onom světě častěji otec, i na onom světě je důležitější než v naší kultuře dárkyně života. Také děti ve všech kulturách mívají v takových situacích zážitky s tunelem, světlem a vítáním zemřelých bytostí. Často jsou to místo blízkých dospělých, kteří většinou ještě žijí, zvířátka, která v jejich blízkosti zemřela.<br />Světlo na konci tunelu<br /><br />Efekt letu tunelem a přibližování se k jásavému světlu je jistě sugestivní zážitek, který se zřejmě díky Moodyho knížkám dostal mnohokrát do literatury a filmu. Pokud jde o vidění tunelu, najdeme odpověď na tuto záhadu ve zrakové kůře, která zodpovídá za zpracování zrakových informací. Svou roli také hrají soustředné kruhy na sítnici, což je vlastně výběžek mozku do zadní části oka.<br /><br />Když je potlačen útlum zrakové mozkové kůry, její buňky jsou náhodně aktivovány, a produkují nervový šum. Čím více buněk je aktivováno, tím silnější je světlo, které zraková kůra simuluje. Soustředné kružnice na sítnici v nás vyvolávají v takových chvílích pocit pohybu. Jakmile se lékařům na jednotce intenzivní péče podaří dodat mozku opět kyslík, člověk je skutečně i pocitově tažen zpět do života. Je to přirozené završení ustáleného příběhu, který si lidský mozek od nepaměti vytváří, aby se vyrovnal s traumatem smrti nebo ohrožení. Zachránění lidé si návrat do života vysvětlují tím, že je zpět zavolali jejich blízcí, nebo nedokončené dílo. Ale v této hře o život vyhrává lékař, ruku v ruce s nezbytným kyslíkem. Pokud nevyhraje, o žádných předsmrtných zážitcích se už nedovíme.<br />Význam výzkumu zážitků blízkosti smrti<br /><br />Výzkum v oblasti zkoumání mozku v popsaných extrémních situacích má svůj význam. Lékaři, traumatologové dokážou zachránit mnohé orgány a obnovit jejich funkce - také díky špičkovému přístrojovému vybavení. Mozek je v těchto dramatických minutách nejcitlivější, a je dobré vědět, co se v něm pravděpodobně odehrává. Krevní odběry dávají odpověď na koncentraci krevních plynů a endorfinů, pomáhá i zobrazení mozku nejmodernějšími metodami. Zážitky blízkosti smrti a poznávání jejich fyziologických příčin jsou důležité pro traumatologii, neurologii, psychiatrii a další obory. Přináší nové poznatky, které zasahují do problematiky drogové závislosti.<br /><br />Díky výzkumu mozku v extrémní situaci, kdy mozek navozuje mystické zážitky, věda v kontrastu s nimi konstatuje, že zážitky blízkosti smrti nijak nepotvrzují existenci života po smrti.<br /><br />Dokonce sám Raymond Moody se ve své poslední knížce Kdo se směje naposled distancuje od předešlého paranormálního vyznění svých knih, a nabízí čtenářům představu, že hry s nadpřirozenem jsou jen cosi jako zábavné atrakce. Moody je zřejmě nekonzistentní autorská osobnost, která ignoruje realitu, ale ráda vlaje od extrému k extrému. Patří k běžným absurditám světa, že podobné osobnosti vyvolávají zájem milionů hledačů pravd a duchovního vytržení, a vůbec, značkují svou dobu. Někdy, jako v tomto případě, mohou iniciovat nastartování seriózního zájmu, který se na bizarní interpretaci jevu podívá očima vědy.<br />Poznámka<br /><br />Moody Raymond je americký doktor filosofie a psychologie, ale především parapsycholog, který proslul sepsáním několika knih z této oblasti, ale největší úspěch získal knihou „Život po životě“ z r.1975, která popisuje „zážitky blízkosti smrti“. Své paranormální studie prováděl ve svém soukromém výzkumném ústavu v Alabamě, který nazývá „John Dee Memorial Theater of the Mind“. Moody navazuje na J. Deea z 16. století, který se hleděním do skleněné koule díval do minulosti a budoucnosti a přivolával tak také duchy. Ve svém ústavu měl Moody speciálně zařízenou zrcadlovou místnost, kde jeho hosté vyvolávali duchy svých zemřelých přátel. Moody také po hypnotické seanci uvěřil v možnost reinkarnace. Sám měl prý devět předchozích životů. Výlety do minulých životů podle něj mají léčebný efekt, umožňují zbavit se depresí, fóbií nebo závislostí. Od r.1998 je Moody vedoucím katedry pro studium vědomí na Univerzitě v Las Vegas v Nevadě. Několik jeho knih bylo přeloženo do češtiny.<br /><br />Úspěch ve veřejnosti měly obrovský. Realita je ovšem jiná. Život je konečný, z biologických důvodů možnost dalšího života a reinkarnace je vyloučena.<br />Literatura:<br /><br />Raymond A. Moody Život po životě, 1991, Eminent<br />Raymond A. Moody Úvahy o životě po životě 1991 Odeon Praha.<br />Raymond A. Moody Světlo po životě, Odeon, Praha<br />Raymond A. Moody Kdo se směje naposled, Volvox Globator<br />Vědci zkoumají zážitky „ze záhrobí“ 2. prosince 2006, Lidové noviny<br />The Skeptic´s Dictionary, www.skepdic.com<br />Kultura smrti - Zuzana Marie Kostićová http://glosy.info/texty/kultura-smrti/ 20. února 2005<br />Erich Fromm – Anatomie lidské destruktivity<br />Vratislav Schreiber – Hormony a lidská mysl, nakl. Triton, Praha 2004<br />F. Crick – Věda hledá duši, Mladá fronta 1997 Praha<br />Radim Uzel – Máme boha ve svých genech? http://www.planovanirodiny.cz/view.php?cisloclanku=2006013006</p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:5;a:3:{s:4:"type";s:4:"text";s:7:"content";s:4396:"<p>&nbsp;</p>
<p>&nbsp;</p>
<p><br />Chvála individualismu<br /><br />Špatně snáším házení milionů lidských individualit do jednoho hodnotícího pytle. Protestuju proti tvrzení, že Italové jsou jaksi jiskrní a hádaví, Němci pracovití a poslušní, Francouzi kulturní a požitkářští, Skoti lakomí, Rusové mají široké srdce, Britové jsou rezervovaní... Nelze redukovat bohatou osobnost člověka na jednu dvě vlastnosti, natož národ! Jsme uhněteni z genů, memů, nepřeberných hodnot, které nabízí kultura i příroda v našem těle. Co člověk, to celý svět, míní individualista, který přiznává jedinečnost nejen sobě, ale všem. Za tuto myšlenku kopu, kde se dá. Naposled v trialogu s dvěma mladými muži u napěněných půllitrů. Vysmívali se totiž Amíkům, tedy poctivě domyšleno všem obyvatelům USA. Hodnotili s opovržením jejich zahraniční politiku, to že si nemůžou vypít na ulici lahváče, za nevinnýho jointa tam strčí člověka do lochu a vůbec jsou prostě na hlavu. Namítla jsem, že podobně vágní nepřátelské hodnocení Čechů by mohlo vypadat následovně: jsou to zloději a korupčníci prosáklí pivem. Provokace štamgasty nazvedla. Bráním se - chtěla jsem jen demonstrovat, jak je směšné, absurdní zatracovat, ale i milovat obyvatele nějakého území, pomlouvat, nenávidět nebo adorovat národ či dokonce stát. Připomněla jsem, jak nás v mládí nutili milovat Sovětský svaz a jeho národy. Špatně se ovšem tehdy mluvilo a hlavně psalo o Američanech. O těch výstředních, dravých, zazobaných agresorech se zkaženou zápaďáckou kulturou utlačujících svůj proletariát. Dokonce nám ani v dějepise neřekli, že Američani osvobozovali v druhé světové válce, mimo jiné, kus naší země. Včetně Strakonic, ve kterých jsem vyrůstala. Když se ta informace ke mně v dětství od pamětníků dostala, byla prostě k neuvěření. Mé pozornosti neunikly ani naděje místních nespokojenců s rudým režimem, a sice že se Američani vrátí, udělají převrat a my pak bolševické funkcionáře pověsíme na lucerny. Násilí plodí násilí, útlak se živí nadějí na pomstu, to je věčný společenský a psychologický mechanismus.<br /><br />Zvláště v květnových dnech, kdy se každoročně vzpomíná na konec celosvětového odporného masakru, jsem na pomlouvání Američanů citlivá, neboť mě hospodská nenávist k stovkám milionů lidí za oceánem připomíná staré nechutné časy s jejich naporoučenou láskou k jedněm a nenávistí k druhým.<br /><br />Být slušný člověk je vysoko nadřazené naší národnosti a rase. Je to sice stará pravda, ale pořád leckoho dráždí a nestala se uznávanou a žitou normou. Řekla bych, že slušných lidí je ve Spojených státech, stejně jako v jiných zemí, včetně té naší, v populaci přibližně stejný podíl. Snaží se nepodvádět, nekradou, nikoho netýrají a pomáhají si navzájem, hnusí se jim násilí. Jestli někteří na ulici pokrytecky skrývají láhev truňku v papírovém sáčku, je to pouze úsměvné, nikoli zavrženíhodné. A kdo z obyvatel kterékoli země má osobní zodpovědnost a vliv na zahraniční politiku svého státu? Připomněla jsem štamgastům podíl prostých Američanů na osvobození mnoha zemí od fašismu, zmaření tisíců jejich mladých životů. Ale ukázalo se, že staré zásluhy se dnes už nepočítají. Zato se počítají a nezapomínají dějinné křivdy. Jsou mnozí, kteří v srpnu roku 68 zapomněli rusky. A neobměkčí je ani tisíce ruských a dalších sovětských vojáků, zabitých, mnohdy zbytečně, kvůli neschopnosti a cynismu jejich režimu, v téže válce, nebo odboj mnohých Rusů proti rudé falši a krutosti, ani třeba skvělá ruská literatura.<br /><br />Z krčmy odcházím překřičena kolektivem, který míní, že tamti jsou blbí, tito vejtahové, oni falešní – řeč je o národech – a já jsem naivní. Co z těch soudů mají? Jen furiantské pohrdání, posměvačnou nenávist. Pod májovou oblohou v sobě hýčkám radost z jedinečnosti každého z nás, smutek nad jednotlivými hroby v té odporné válce vzdálené víc, než moje narození.<br /><br />Nedemokraticky si myslím, že pravdu mám já a většina se mýlí.</p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:6;a:3:{s:4:"type";s:4:"text";s:7:"content";s:4878:"<p>&nbsp;</p>
<p>&nbsp;</p>
<p><br />Se Sluncem se nedomluvíme<br /><br />Bývá občas docela výhodné, když se stane z některého tématu takzvané politikum. Než k tomu dojde, téma plíživě vznikne - většinou v reakci na neutěšené a přežité poměry - nabývá na objemu, vážnosti a popularitě, často během dlouhých desítek let. Nejdříve se, například myšlenka humanismu, rovnoprávnosti ras, volebního práva pro ženy nebo lidských práv jeví jako požadavek obskurní, obtěžující, brzdící ekonomický vývoj a bourající staré dobré tradice. Zastávají ho a šíří idealisté a další nepraktičtí lidé, kteří tím jdou mocenské vrstvě na nervy. Poté se tématu chopí vzdělaná a citlivější vrstva společnosti, později se na jiné úrovni provětrává v krčmách, až konečně politici pochopí, že přišly jiné časy a oni mohou ztratit vliv, moc, sympatie, v demokraciích pak voliče, když si téma nepřisvojí a neozdobí se jím, nekopou za něj. Připusťme, že i dnes může politika a politici sem tam něco ovlivnit, třeba prosazením nových zákonů a mezinárodních dohod, nastavením nových pravidel, i když víme, že nad nimi rozprostírají dravčí křídla ekonomicky silné nadnárodní společnosti.<br /><br />Aktuálním tématem se dnes stává obava z rozkolísaného klimatu a debata o tom, jak jeho dopady zmírnit. Tu doprovází pře o to, jestli za tajfuny, tání ledovců, děsivé povodně a hlavně za posílený a tedy nebezpečný skleníkový efekt může pomnožená a neurvalá lidská populace chrlící odpad a ničící přírodu anebo skvrny na Slunci, blížící se doba ledová a další známé i neznámé vlivy. Bylo by dobré to zjistit, protože pokud je příčinou toho všeho převážně lidská činnost, dalo by se snad ještě něco zachránit, změnit, zvrátit – snad. Prý asi 90 % odborníků má dost podkladů k tvrzení, že je skutečně na vině spíš lidský element, deset procent je takzvaných kacířů, kteří tu masívní většinu kolegů vnímají víceméně jako hysteriky. K těm či oněm se přiklánějí politici, ti chytřejší k většině. Je docela možné, že se mezi nimi najde několik idealistů, kteří si myslí a cítí to, co říkají a není úplně vyloučené, že nový nobelista Al Gore patří mezi ně. Protože je politik, je samozřejmě podezírán z toho, že chce ze znepokojivého problému vytlouci politický kapitál, protože byla Nobelova cena míru párkrát vložena do nepravých rukou, nemá jeho nedávné ocenění vysoký kredit. O cenu se dělí s dvěma tisíci vědci Mezivládního panelu OSN pro klimatické změny. Dalo by se očekávat, že těch dva tisíce klimatologů nebude desetiprocentními klimaskeptiky podezříváno z politikaření, ale ti to berou šmahem. Kdo varuje před vypouštěním skleníkových plynů, proti pestrému poškozování přírody, ten prostě pletichaří, politikaří, útočí na naši svobodu – svobodu těžit za každou cenu všechno co jde, udržovat nadprodukci aut, elektroniky, bot, hadříků, zlatých šperků… záplavu věcí potřebných ale i naprostých volovin. Svobodu hodně nakupovat a věci pak brzy nato vyhazovat, protože vyšly z módy, už nejsou posledními výkřiky techniky. Jenže všechny ty věci byly původně surovinami, které kdosi vytěžil z krajiny. A ta dostala zabrat. Budou se muset nějak zlikvidovat, spálit, načež dostane zabrat atmosféra, řeky, lesy.<br /><br />Soudím, že kus svobody lze získat i tím, že se nadbytečných věcí vzdáme. Že budeme minimalizovat plýtvání. I kdyby plyny z výfukových plynů a komínů neměly na klima vliv, škodí všemu živému na Zemi. I kdyby plýtvání a hromadění předmětů ničemu neškodilo a spalovny, které požírají odpad, dýchaly jako nemluvňata, je plýtvání a obžerství nechutné, nevkusné a nekulturní.<br /><br />Pochybuji, že někdy vyjde najevo pravda o tom, je-li ve věci rozkymáceného klimatu a krajně nepříjemných prognóz pro život na Zemi na vině především obžernost lidstva, které se žene za věčným zlatým teletem, za dostatkem, nadbytkem. Příčiny a vlivy se nejspíš sčítají, násobí a mísí. Těžko lze přesně zjistit, do jaké míry škodí životu na Zemi skvrny na Slunci, mění-li se klima před příchodem doby ledové, nebo si nejvyšší primát zatápí pod kotlem, v němž se bude vařit. A protože to nevíme úplně jistě, kromě těch 90 % klimatologů, což by mělo mít svou váhu, měli bychom proti poškozování atmosféry, biosféry a vymírání druhů zasahovat. Je to největší téma současné i budoucí lidské populace. Kardinální problém našich životů. Se Sluncem se nedomluvíme, s lidmi snad ještě ano.</p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:7;a:3:{s:4:"type";s:4:"text";s:7:"content";s:4356:"<p>&nbsp;</p>
<p>&nbsp;</p>
<div id=\"page\">
<div id=\"content\">
<h1 class=\"title\">Různé podoby pošetilosti</h1>
<div id=\"node-36\" class=\"node node-page\">
<div class=\"content\">
<p>Klišé <em>svět je globální vesnice</em> má svůj díl pravdy, zvážíme-li moc, vliv, výrobky a dlouhé prsty nadnárodních společností, všudybylství coca-coly, hamburgerů a internetu. Pod povrchem takových výroků se ale skrývají bohaté spodní vrstvy, které jsou pravdě blíž. <em>Globální vesnice</em> je totiž složena ze světů, které se liší především podobami svých pošetilostí. Zatímco v jednom z nich proběhnou volby spořádaně až nudně, jinde, jak praví poté média: si vyžádaly lidské oběti. Zatímco v našem známém světě jsou náboženské obřady nenápadné, konejšivé, kněží kážou o pokoře, lásce a smíření, náboženské zvyklosti v jiném světě provázejí vášně nenávisti či šílená nakupení chlapů, kteří slabší jedince ušlapou k smrti. V našem světě je například čarodějnictví zábava, úsměvný podvod, esoterický byznys s pouťovými prvky. Dvě <em>čarodějnice</em> z Kypru vylákaly z lidí, kterým namluvily, že je někdo uřknul, v přepočtu miliony korun. „Můj bože, jak je možné, že jste ještě naživu?“ divila se jedna z nich své oběti. A pak jí nabulíkovala, že jí nějaká žena očarovala příbuzného a kletba pak přešla na ni a její děti, ona sama prý zemře brzy na rakovinu. Dostala z naivky v přepočtu 900 000 Kč. Další kolegyně zase věštila osud zvědavému mužskému sice jen za tisícovku, jenže přitom „zjistila“, že byl uřknut. Za 25 tisíc z něj pak kletbu „sejmula“. V Polsku zase čarodějka vyháněla z domu zlé duchy a nemoci tak, že je mumláním přenesla na chudáka kuře, které následně zařízla. Majitel domu přitom musel zabalit do ručníku co nejvíce peněz, jeden z nich si dokonce doběhl do banky vyzvednout úspory, a ten pak vložit do útrob gauče, kde peníze měly zůstat a množit se po sedm dní. Nás, co známe šalby světa, nepřekvapí, že ručník s penězi do týdne zmizel. V jiných světech <em>globální vesnice</em> se naopak obvinění z čarodějnictví podobá rozsudku smrti. Parta jihoafrických středoškoláků upálila dvě ženy, protože se domnívala, že začarovaly jejich školu. Vyvlekli šedesátileté ženy z jejich domů a odvedli na školní hřiště, polili benzinem a podpálili. Obě uhořely. K podezření stačilo, že kluci mívali „nevysvětlitelné záchvaty křiku“ a náhlé „dychtění po masu během vyučování“! Čtrnáctiletý Joel z konžského hlavního města Kinshasy přišel o rodiče a ujali se ho babička s dědou. Děda ho poté, co se mu o vnukovi zdál špatný sen, nařkl z čarodějnictví. Chlapec se dostal do pazourů místního vymítače. Ten ho bil tak dlouho, dokud se nepřiznal, pak jej zavřel do truhly a nakonec byl vyhozen na ulici. Mnoho dětí v afrických státech nebo v Indii prožívá podobné drama. K obvinění z čarodějnictví i tříletého dítěte může vést malá úroda, porouchaný motor, ztráta peněz nebo úmrtí v rodině. Často se tak rodiny zbavují dětí, kterým zemřeli rodiče, a příbuzné péče o ně obtěžuje.</p>
<p>U nás je předstírání čarodějných schopností pouťově zábavné. Samozvaný čaroděj je miláčkem bulváru a čarodějnictví slouží i k přizdobení celebrit. Máme dokonce čarodějnici z povolání, která sepsala čarodějnický slabikář. Jinak ale přiznává, že používá počítač, mobilní telefon, má ráda rychlá auta a často porušuje svá předsevzetí, hlavně v jídle, takže věčně bojuje s nadváhou. Vždyť je to ženská jako my, <em>na nic si nehraje,</em> libuje si pomocí dalšího klišé kdekterá dáma. Jenom se holt narodila jako čarodějnice! No asi jako se občas narodí hastrman nebo plivník.</p>
<p>Naše <em>globální vesnice</em> má sice stejnou coca-colu, ale propastně rozdílné zvyky, vášně, pověry. Co je u nás legrace, je jinde děs. Ponaučení?</p>
<p>Každé úsloví podezírejme z povrchnosti, každé klišé se opírá o viklavý sloupek.</p>
</div>
</div>
</div>
</div>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:8;a:3:{s:4:"type";s:4:"text";s:7:"content";s:4771:"<p>&nbsp;</p>
<p>&nbsp;</p>
<p>Vymalujte si hvězdným prachem<br /><br />Pan Kokeš je suverénní jak hollywoodská hvězda. Proměřuje nám primitivním přístrojkem byt a diví se: „Jak v tom sajrajtu můžete žít?“ Byt je už s ohledem na jeho návštěvu uklizený, o čem to mluví? Samozřejmě že jde o negativní energii prýštící ze země, kosmu, elektrospotřebičů, mobilů, počítačů, umělých hmot... Nabízí produkty své mateřské firmy, které mají tu moc vše odstínit. Nálepčička velikosti nehtu za 500,- Kč zakouzlí údajně nebezpečný televizor, počítač nebo mobil. Kus alobalu v igelitu za 3000,- Kč stopne záření ze zemních dračích žil. Nakonec vytahuje z aktovky umělohmotnou krabičku na sýry. Kupodivu neskrývá romadur. „Tak tohle je ovšem vychytaná věcička! Postará se o biostimulaci prostoru,“ říká slavnostně. Hrábnu po krabičce, chci se podívat dovnitř. Nic v ní není. „Radionické záření těžko uvidíte,“ posmívá se mi Kokeš. „Ale tenhle rezonanční stimulátor vám odstíní od negativní energie celou místnost. Ovšem cena už je trošku vyšší. 24 tisíc.“ Nic jsme si nekoupili, vzteklý dealer mumlá při nazouvání do bot cosi o naší budoucí rakovině.<br /><br />O pár týdnů později usedáme v zahradní restauraci k laťkovému stolu pod vysokou kovovou konstrukci. Mezi laťky jsou zasunuty žiletky. Smířlivě to přehlížíme, neboť co je v tomto světě dokonalé? „To vypadá jako nějaká pyramida,“ rozhlíží se manžel. „Ano, je to pyramida,“ přikyvuje majitel venkovské hospody. „Pěkně vás nabije,“ slibuje. Pak ale hned poctivě upozorňuje na rizika: „Někoho ten příliv kosmický energie zmáhá. Ale zjistili jsme, že proti únavě z toho energetického nášupu pomáhá dát si panáka.“ Panáka si nedáváme, neboť co kdyby nás součet alkoholu a vesmírné energie porazil? Žiletky jsou nám už jasné, ostří se tu spolu s námi. Majitel pyramidální osvěžovny nám účtuje nezvykle vysokou sumu. Je jasné, že částka zahrnuje i položku za vesmírné nabití, které jsme si ovšem neobjednali.<br /><br />Za další týden jdu s kamarádem navštívit obchod s čarodějnickými potřebami, je dobré vědět, co všechno je v kraji možné. Prohlížíme si šperky, jimž vévodí symbol hada a umělohmotné lebčičky. Tohle že je čarodějnické doupě? „Kde máte preparáty ze sušených netopýrů a hadích očí? Kde pantakle, svěcenou vodu a černé slepice?“ Prodavačka zavětří zasvěcené klienty, nemusí nám totiž vysvětlovat obraty evokace, inkarnace a géniové zodiakální a vede nás do vedlejšího kumbálku s množstvím lahviček. Otevírá jednu po druhé a dává nám čichnout k obsahu. „Tohle je nebezpečný olej. Dá se jím přivolat anděl, ale člověk musí vědět jak na to, jinak je zle.“ Z lahviček je cítit jasmín, avokádo, pelyněk... Dvě stovky za dvacet kapek mají zhodnotit tajemnou práci Indiánů v rezervacích Spojených států. Předstírám, že jsem tomu blábolu uvěřila, stejně se nedá nijak vyvrátit. Prodavačka je vděčná za vytržení ze samoty a nudy, málokdy k ní někdo zavítá.<br /><br />Na umělohmotné zaplombované nádoby, které mají údajně vysoušet zdi a stojí 40 – 120 tisíc se už ale zákazníci nachytat dají. To bude něco od vědy, řekne si nepoučený laik, když si přečte na webových stránkách o vysoušečích pseudovědecké žvásty. Pokud by nádobu odplomboval, najde v ní pár dřívek, dráty a hadřík. Dojde mu tedy, že byl podveden, jenže podepsal smlouvu, v níž stojí, že pokud přístroj otevře, nemá nárok na reklamaci.<br /><br />Pomocný termín imaginárního tachyonu byl zase zcizen relativistické fyzice a v esoterickém byznysu se stal nálepkou pro komické výrobky. Lze si například koupit tachyonizované vložky do bot nebo hadrovou čelenku na suchý zip za 740,- Kč, nebo tachyonizovaný hvězdný prach do barvy na vymalování pokoje za 14 850,- Kč za 1 kg, tachyonizovanou ochranu před slunečními skvrnami za 34 210,- Kč. Esoterický trh nabízí věštění, odbloknutí, nabíjení či vyčištění osob, bizarní léčitelské praktiky, levitovanou vodu, šamanské čarování, spolupráci s anděly, kvantovou homeopatii, astrálního bodygarda za mizerných 10 tisíc. Náklady na okultní podnikání jsou totiž minimální, reklama přes internet téměř zadarmo, daňové úniky snadné, lidi důvěřiví a lační duchovna a zázraků.<br /><br />Nabídka stále stoupá, vymýšlejí se další atrakce, klientela ale zůstává omezená. Je mnoho slimáčků a málo salátu.</p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}i:9;a:3:{s:4:"type";s:4:"text";s:7:"content";s:1989:"<p>Životopis</p>
<p>* 9. 4. 1947  Hroznětín (okres Karlovy Vary)<br /><br />Vyrůstala jsem ve Strakonicích. Po maturitě na gymnáziu (tehdy SVVŠ) jsem vystřídala mnoho profesí v několika <br />městech. Byla jsem například aranžérka, závorářka, dělnice, pracovnice pošty, cukrářka, archivářka u památkářů, <br />kreslička, osvětová pracovnice, uklízečka, servírka, vychovatelka, učitelka mateřské školy nejdéle novinářka. <br />Od roku 1972 žiji v Praze.<br /><br />V letech 1991 – 2004 jsem se věnovala žurnalistice. Začínala jsem jako redaktorka a tajemnice redakce Českého deníku a <br />končila v příloze Věda a lidé Hospodářských novin. Byla jsem redaktorkou Týdne (někdejší časopis pro venkov a <br />zemědělce), dále mě zaměstnával Blesk magazín jako reportérku, poté Europress. Přitom jsem externě psala pro <br />Reflex, Lidové noviny, MfDnes, Print and Publishing, Packaging, Listy, pro slovenský Rozmer a Bratislavský <br />časopis Prometheus, spolupracovala jsem s rozhlasovou stanicí Vltava (pořad Naše téma) a s televizními <br />dokumentaristy (Klekánice na ČT 2, Na vlastní oči – Nova). V roce 1995 jsem založila se šesti vědci, lékaři a <br />novináři Český klub skeptiků Sisyfos, občanské sdružení, které je součástí celosvětové organizace propagující <br />kritické myšlení. V letech 2001 – 2004 jsem byla jeho předsedkyní, po deset let editorkou Zpravodaje Sisyfos, <br />dnes jsem členkou předsednictva.<br /><br />V posledních letech se přednostně věnuji psaní prózy. Jinak píši a publikuji hlavně fejetony a glosy, vzácně <br />reportáže a povídky. Romány Bereme, co je, Obsazeno a Proměny byly namluveny pro Český rozhlas a vysílány jako <br />četba na pokračování. Román Proměny byl přeložen do esperanta a kniha Bereme, co je vyšla v němčině pod názvem<br />Wir Nehmen es, wie’s kommt v prosinci 2016.</p>";s:5:"style";a:4:{s:4:"font";a:5:{s:9:"font-size";s:0:"";s:11:"font-family";s:0:"";s:6:"weight";s:0:"";s:11:"line-height";s:0:"";s:5:"color";s:0:"";}s:2:"li";s:0:"";s:5:"style";s:1:"1";s:18:"p-background-color";a:3:{s:6:"color1";s:7:"#e8e8e8";s:6:"color2";s:0:"";s:12:"transparency";s:3:"100";}}}}}}}}

Napsat komentář

Vaše e-mailová adresa nebude zveřejněna. Vyžadované informace jsou označeny *

Tato stránka používá Akismet k omezení spamu. Podívejte se, jak vaše data z komentářů zpracováváme..