Symbiosism

Symbiosism is a philosophy about the mind and man's place in nature. It is a Darwinian theory, which considers language an organism residing in the human brain and claims that language is a memetic life form. Symbiosism is defined by the Leiden School.

Overview

Memes are meanings, i.e. iso-functional neuroanatomical constructs corresponding to signs in the sense of Ferdinand de Saussure. Meanings thrive, replicate incessantly and constitute the essence of language. An essential characteristic of memes is that linguistic meanings have the nature of nonconstructible sets in the mathematical sense and do not abide by constraints governing Aristotelian logic, such as the principle of the excluded middle. The Leiden conception of the meme contrasts with the Oxford definition as a unit of imitation, a behavioral notion that in Leiden is captured by the term meme. The fecundity of memes as replicators and their fidelity of replication are limited, more so in pre-linguistic contexts.

Language is a mutualist symbiont and enters into a mutually beneficial relationship with its hominid host. Humans propagate language, whilst language furnishes the conceptual universe that guides and shapes the thinking of the hominid host. Language enhances the Darwinian fitness of the human species. Yet individual grammatical and lexical meanings and configurations of memes mediated by language may be either beneficial or deleterious to the biological host. The symbiosis is rendered more complex than just simple mutualism, both by the physiological discrepancy between language as an overall condition and the nature of individual ideas conveyed through language, as well as by the ecological difference between vertically and horizontally transmitted memes. The symbiotic theory of language propounded by George van Driem grew out of the Leiden school of language evolution, fathered by Frederik Kortlandt.

Resources
  • van Driem, George (2001). Languages of the Himalayas: An Ethnolinguistic Handbook of the Greater Himalayan Region : Containing an Introduction to the Symbiotic Theory of Language (2 vol). Brill. p. 1412. ISBN 90-04-12062-9.
  • van Driem, George. 2003. The Language Organism: The Leiden theory of language evolution, in Jiří Mírovský, Anna Kotěšovcová and Eva Hajičová, eds., Proceedings of the XVIIth International Congress of Linguists, Prague, July 24–29, 2003. Prague: Matfyzpress vydavatelství Matematicko-fyzikální fakulty Univerzity Karlovy.
  • van Driem, George. 2004. Language as organism: A brief introduction to the Leiden theory of language evolution, pp. 1–9 in Ying-chin Lin, Fang-min Hsu, Chun-chih Lee, Jackson T.-S. Sun, Hsiu-fang Yang and Dah-ah Ho, eds., Studies on Sino-Tibetan Languages: Papers in Honor of Professor Hwang-cherng Gong on his Seventieth Birthday (Language and Linguistics Monograph Series W-4). Taipei: Institute of Linguistics, Academia
  • van Driem, George. 2005. The language organism: The Leiden theory of language evolution, pp. 331–340 in James W. Minett and William S-Y. Wang, eds., Language Acquisition, Change and Emergence: Essays in Evolutionary Linguistics. Hong Kong: City University of Hong Kong Press.
  • Kortlandt, Frederik Herman Henri. 1985. A parasitological view of non-constructible sets, pp. 477–483 in Ursula Pieper and Gerhard Stickel, eds., Studia linguistica diachronica et synchronica: Werner Winter sexagenario anno MCMLXXXIII gratis animis ab eius collegis, amicis discipulisque oblata. Berlin: Mouton de Gruyter.
  • Kortlandt, Frederik Herman Henri. 1998. Syntax and semantics in the history of Chinese, Journal of Intercultural Studies, 5: 167-176
  • Kortlandt, Frederik Herman Henri. 2003. The origin and nature of the linguistic parasite, pp. 241–244 in Brigitte Bauer and Georges-Jean Pinault, eds., Language in Time and Space: A Festschrift for Werner Winter on the Occasion of his 80th Birthday. Berlin: Mouton de Gruyter
  • Salverda, Reinier. 1998. Is language a virus? Reflections on the use of biological metaphors in the study of language, pp. 191–209 in Mark Janse and An Verlinden, eds., Productivity and Creativity. Studies in General and Descriptive Linguistics in Honor of E.M. Uhlenbeck. Berlin: Mouton de Gruyter.
  • Salverda, Reinier. 2003. Letter to the Editor, New Scientist (1 February 2003), 2380: 25.
  • Wiedenhof, Jeroen Maarten. 1996. Nexus and the birth of syntax, Acta Linguistica Hafniensia, 28: 139-150
gollark: > `import hashlib`Hashlib is still important!> `for entry, ubq323 in {**globals(), **__builtins__, **sys.__dict__, **locals(), CONSTANT: Entry()}.items():`Iterate over a bunch of things. I think only the builtins and globals are actually used.The stuff under here using `blake2s` stuff is actually written to be ridiculously unportable, to hinder analysis. This caused issues when trying to run it, so I had to hackily patch in the `/local` thing a few minutes before the deadline.> `for PyObject in gc.get_objects():`When I found out that you could iterate over all objects ever, this had to be incorporated somehow. This actually just looks for some random `os` function, and when it finds it loads the obfuscated code.> `F, G, H, I = typing(lookup[7]), typing(lookup[8]), __import__("functools"), lambda h, i, *a: F(G(h, i))`This is just a convoluted way to define `enumerate(range))` in one nice function.> `print(len(lookup), lookup[3], typing(lookup[3])) #`This is what actually loads the obfuscated stuff. I think.> `class iｎt(typing(lookup[0])):`Here we subclass `complex`. `complex` is used for 2D coordinates within the thing, so I added some helper methods, such as `__iter__`, allowing unpacking of complex numbers into real and imaginary parts, `abs`, which generates a complex number a+ai, and `ℝ`, which provvides the floored real parts of two things.> `class Mаtrix:`This is where the magic happens. It actually uses unicode homoglyphs again, for purposes.> `self = typing("dab7d4733079c8be454e64192ce9d20a91571da25fc443249fc0be859b227e5d")`> `rows = gc`I forgot what exactly the `typing` call is looking up, but these aren't used for anything but making the fake type annotations work.> `def __init__(rows: self, self: rows):`This slightly nonidiomatic function simply initializes the matrix's internals from the 2D array used for inputs.> `if 1 > (typing(lookup[1]) in dir(self)):`A convoluted way to get whether something has `__iter__` or not.
gollark: If you guess randomly the chance of getting none right is 35%ish.
gollark: Anyway, going through #12 in order:> `import math, collections, random, gc, hashlib, sys, hashlib, smtplib, importlib, os.path, itertools, hashlib`> `import hashlib`We need some libraries to work with. Hashlib is very important, so to be sure we have hashlib we make sure to keep importing it.> `ℤ = int`> `ℝ = float`> `Row = "__iter__"`Create some aliases for int and float to make it mildly more obfuscated. `Row` is not used directly in anywhere significant.> `lookup = [...]`These are a bunch of hashes used to look up globals/objects. Some of them are not actually used. There is deliberately a comma missing, because of weird python string concattey things.```pythondef aes256(x, X): import hashlib A = bytearray() for Α, Ҙ in zip(x, hashlib.shake_128(X).digest(x.__len__())): A.append(Α ^ Ҙ) import zlib, marshal, hashlib exec(marshal.loads(zlib.decompress(A)))```Obviously, this is not actual AES-256. It is abusing SHAKE-128's variable length digests to implement what is almost certainly an awful stream cipher. The arbitrary-length hash of our key, X, is XORed with the data. Finally, the result of this is decompressed, loaded (as a marshalled function, which is extremely unportable bytecode I believe), and executed. This is only used to load one piece of obfuscated code, which I may explain later.> `class Entry(ℝ):`This is also only used once, in `typing` below. Its `__init__` function implements Rule 110 in a weird and vaguely golfy way involving some sets and bit manipulation. It inherits from float, but I don't think this does much.> `#raise SystemExit(0)`I did this while debugging the rule 110 but I thought it would be fun to leave it in.> `def typing(CONSTANT: __import__("urllib3")):`This is an obfuscated way to look up objects and load our obfuscated code.> `return getattr(Entry, CONSTANT)`I had significant performance problems, so this incorporates a cache. This was cooler™️ than dicts.
gollark: The tiebreaker algorithm is vulnerable to any attack against Boris Johnson's Twitter account.
gollark: I can't actually shut them down, as they run on arbitrary google services.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.