ϕ Preliminary considerations on theory of meaning

 In short:

(just as a hypothesis)
• meaning of message (word/sentence/text) for human = sustainable/reproducible and predictable mental representations caused by the message in the brain of message receiver
• mental representations consist of some very basic perceptions intrinsic for human individuals
• being able to enumerate that basic perceptions we can “encode” any complex representation — that is it is like a machine code of brain-computer
• and as well it makes possible to specify semantics of natural language formally

Details

I’m not an expert in the theory of meaning, just curious about it so I don’t pretend that the statements above are true and bring any new knowledge to the field.
But when you are going to study something it is normal to have in mind some preliminary picture consisting of what there can be and expectations about the results of study. So my expectation here is to confirm or refute the “hypothesis” by finding more adequate discoveries. Anyway this is a good starting point as it allows to formulate particular questions.. and queries to search engines 😄
Now let me explain

How I came to these conclusions 

— some observations:
1. We use finiteset of notions (words), but are able to  d talk about anything we that exist in the world
2. Any new word is defined by already existing ones
3. And many of already existing words are based on older simpler roots
— hence entire vocabulary was built from small amount of most basic notions, which correspond to something perceived by humans directly (because it the moment of creation of the initial vocabulary there was nothing to make it indirect..)

4. Humans as all other species have limited number of perception channels — or perception kinds — so why there should be an infinite number of kinds of basic mental representations?

Comments

Post a Comment

Popular posts from this blog

💻 Programming: recipe: response validation against OpenAPI schema in Python

Image
Summary: code snippets and explanation of how to validate HTTP-response using  openapi-core package If you deal with some service based on OpenAPI Specification you might want to perform validation of HTTP responses returned by it. One of the ways to do this an internet search provides for Python is to use openapi-core package. If you look at their documentation ( here or here ) you will find it very stingy: couple of short code snippets and couple of sentences just stating what is done. In particular for response validation we have exactly the following:   You can also validate against responses   from openapi_core . validation . response . validators import ResponseValidator   validator = ResponseValidator (spec) result = validator . validate (request, response)   # raise errors if response invalid result .raise_for_errors()   # get list of errors errors = result .errors ...   Here we see some confusing things: why do we need a request object to be able to validate the respo
Read more

ϕ Logic vs. ‘common sense’

Logic is a doctrine of correct judgment and it’s “our everything” (in the sense that it is necessary for any theory and learning). But to discover or ‘invent’ (formulate for the very first time) the laws of logic it is already necessary to think (judge) correctly — so there is a question: Isn’t there a kind of paradox? Or at least a vicious circle? Indeed, if you think correctly you can formulate correct logic laws and using them prove something (and maybe the way of how you judged about correctness of the laws formulated) — but if you don’t then the laws are invalid and you are unable even to find that. Seems the ability of reasoning is intrinsic for people (at least for those who is educated enough) and the ‘discovery’ of the ‘laws’ is just a result of observations (of own and other people thinking and judgments and their correspondence to a real state) and further refinements of them. But usually that ability is unconscious (intuitive) and informal (nobody judges like “A is true bec
Read more

💻 Programming: recipe: pytest: assertion after all tests run

Example of how to check some conditions when ALL test suites finished (or enforce some test running at the end of session). This may be useful to ensure that you have tested all functions of some module whose interface can change in future. The code: from   pytest   import   fixture     Data  =  dict ( cnt  =  0 )   @fixture ( scope = 'session' ) def   data_0 ():        yield   Data        # (this will be done AFTER all tests below)      assert   Data [ 'cnt' ] ==  3 ,  f 'data-cnt:  { Data [ "cnt" ] } '   @fixture def   data ( data_0 ):        Data [ 'cnt' ] +=  1        return   Data [ 'cnt' ]   def   test_11 ( data ):        print ()      print ( 'test-11:' ,  data )   def   test_12 ( data ):        print ()      print ( 'test-12:' ,  data ) Output: ERROR test_1.py::test_12 - AssertionError: data-cnt: 2 _________ Other articles ~ programming
Read more