« Essence de la connaissance » : différence entre les versions
Aller à la navigation
Aller à la recherche
Contenu ajouté Contenu supprimé
Aucun résumé des modifications |
(Contenu remplacé par « A présent Assothink: [http://m3m.homelinux.org/wikiMC/index.php/Essence_de_la_connaissance m3m.homelinux.org/wikiMC/index.php/Essence_de_la_connaissance] ») |
||
| Ligne 1 : | Ligne 1 : | ||
A présent Assothink: [http://m3m.homelinux.org/wikiMC/index.php/Essence_de_la_connaissance m3m.homelinux.org/wikiMC/index.php/Essence_de_la_connaissance] |
|||
== Introduction == |
|||
Sous ce titre trop vague se trouve une recherche assez concrète. |
|||
Elle touche aux maths, un peu à la philo, à l'informatique et à la cognostique. |
|||
Elle a deux buts, et l'atteinte de ces buts est fort imprévisible: |
|||
*la construction d'un possible nouveau langage informatique |
|||
*la construction d'un modèle de pensée artificielle |
|||
== Evidences == |
|||
Dans la recherche des notions premières, le but ultime semble toujours in fine inaccessible. |
|||
La présente démarche ne s'épuisera pas de ce coté là, mais se tournera plutôt vers la pyramide des constructions. |
|||
Donc avec une certaine paresse, divers concepts seront considérés comem évidents. |
|||
Je suppose qu'une couche fondatrice pourra être explorée dans des livres de math ou de philo.<br> |
|||
Ici l'indication "concept!" sera la marque de la limite de cette paresse. |
|||
Par ailleurs le sens de certains de ces concepts ne prend forme qu'avec l'introduction de concepts ultérieurs: pas de construction séquentielle immaculée. |
|||
English: pourquoi des concepst en anglais ? Eh bien à cause des analogies ou perspectives informatiques. |
|||
== Element, set and function == |
|||
concept! <span style="color: rgb(0, 0, 255);">'''element'''</span> |
|||
Toute entité abstraite pouvant être connue ou décrite. |
|||
concept! element <span style="color: rgb(0, 0, 255);">'''set'''</span> |
|||
Une collection d'éléments. |
|||
L'ensemble lui-même peut à son tour être considéré comme élément.<br> |
|||
concept! element <span style="color: rgb(0, 0, 255);">'''fonction'''</span> |
|||
Une fonction est un élément particulier.<br> |
|||
Une fonction se décrit pas la transformation d'un input en output. |
|||
L'input et l'output ne peuvent être vides. |
|||
L'input et l'output sont des éléments d'ensembles. |
|||
La description d'une fonction implique de préciser les ensembles input et output. |
|||
== Opérations sur ensembles<br> == |
|||
set <span style="color: rgb(0, 0, 255);">'''setSet'''</span><br> |
|||
L'ensemble de tous les ensembles. Notion peu féconde, mais indispensable. |
|||
*fonction setSet,setSet -> <span style="color: rgb(0, 0, 255);">'''union'''</span> -> setSet |
|||
*fonction setSet,set -> <span style="color: rgb(0, 0, 255);">'''union'''</span> ->setSet<br> |
|||
*fonction setSet,setSet ->'''<span style="color: rgb(0, 0, 255);">intersection</span>''' ->setSet |
|||
*fonction setSet,setSet -> <span style="color: rgb(0, 0, 255);">'''diff'''</span> ->setSet |
|||
*fonction setSet,set -> <span style="color: rgb(0, 0, 255);">'''diff'''</span> ->setSet <br> |
|||
set <span style="color: rgb(0, 0, 255);">'''fullSet'''</span> |
|||
L'ensemble contenant tous les éléments. |
|||
set <span style="color: rgb(0, 0, 255);">'''emptySet'''</span> |
|||
L'ensemble vide, c'est à dire ne contenant aucun élément. |
|||
== Booléens == |
|||
concept! élément <span style="color: rgb(0, 0, 255);">'''false'''</span><br> |
|||
Un élément.<br> |
|||
concept! élément <span style="color: rgb(0, 0, 255);">'''true'''</span> |
|||
Un élément autre que false. |
|||
set <span style="color: rgb(0, 0, 255);">'''B'''</span> |
|||
L'ensemble constitué de true, de false, et de rien d'autre. |
|||
fonction B -> <span style="color: rgb(0, 0, 255);">'''not'''</span> -> B |
|||
fonction set,set -> <span style="color: rgb(0, 0, 255);">'''equals'''</span> -> B |
|||
(et donc: fonction B,B -> <span style="color: rgb(0, 0, 255);">'''equals'''</span> -> B)<br> |
|||
fonction B,B -> <span style="color: rgb(0, 0, 255);">'''and'''</span> -> B |
|||
fonction B,B -> <span style="color: rgb(0, 0, 255);">'''or'''</span> -> B |
|||
fonction B,B -> <span style="color: rgb(0, 0, 255);">'''xor'''</span> -> B |
|||
fonction setSet,fullSet -> <span style="color: rgb(0, 0, 255);">'''contains'''</span> -> B |
|||
fonction setSet,setSet -> '''<span style="color: rgb(0, 0, 255);">subSet</span>''' -> B |
|||
fonction setSet -> <span style="color: rgb(0, 0, 255);">'''isEmpty'''</span> -> B<br> |
|||
== Entiers<br> == |
|||
concept! set <span style="color: rgb(0, 0, 255);">'''Z'''</span><br> |
|||
L'ensemble des nombres entiers (positifs et négatifs).<br> |
|||
fonction setSet -> <span style="background-color: rgb(255, 255, 255);"><span style="color: rgb(0, 0, 255);">'''cardinal'''</span></span> -> Z<br> |
|||
fonction Z -> <span style="color: rgb(0, 0, 255);">'''next'''</span> -> Z<br> |
|||
Le suivant d'un nombre entier, qui est un autre nombre entier (et qui n'est le suivant que de ce premier nombre)<br> |
|||
fonction Z,Z -> '''equals''' -> Z <br> |
|||
élément <span style="color: rgb(0, 0, 255);">'''zero'''</span><br> |
|||
Hum... Le cardinal de '''emptySet'''.<br> |
|||
élément <span style="color: rgb(0, 0, 255);">'''one'''</span><br> |
|||
Le suivant de '''zero''' ('''zero''' -> '''next''' -> '''one''').<br> |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''plus'''</span> -> Z<br> |
|||
fonction Z <span style="color: rgb(0, 0, 255);">'''minus'''</span> -> Z |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''minus'''</span> -> Z<br> |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''bigger'''</span> -> B<br> |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''smaller'''</span> -> B<br> |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''strictBigger'''</span> -> B |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''strictSmaller'''</span> -> B |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''product'''</span> -> Z<br> |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''quotient'''</span> -> Z<br> |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''modulo'''</span> -> Z |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''divides'''</span> -> B |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''isSquare'''</span> -> B |
|||
fonction Z,Z <span style="color: rgb(0, 0, 255);">'''isPrime'''</span> -> B |
|||
... |
|||
== Réels == |
|||
set '''<span style="color: rgb(0, 0, 255);">R</span>''' |
|||
L'ensemble des nombres réels. |
|||
Les fonctions décrites pour l'ensemble '''Z '''peuvent être définies pour l'ensemble '''R '''(avec une signification un peu décalée, comme par exemple pour la fonction ratio). |
|||
<blockquote>La principale différence entre entier et réels est liée à la notion de densité. Entre deux entiers distincts donnés, combien peut-on intercaler d'entiers ? Un nombre fini et aisément calculable. Entre deux réels distincts donnés, combien peut-on intercaler de réels ? Un nombre infini. </blockquote> |
|||
== Sous-ensembles conditionnels == |
|||
set '''<span style="color: rgb(0, 0, 255);">functionSet</span>''' |
|||
L'ensemble des fonctions. (Donc une fonction est bien un élément). |
|||
set '''<span style="color: rgb(0, 0, 255);">conditionSet</span>''' |
|||
Un sous-ensemble de l'ensemble de fonctions, celui consitué des fonctions ayant la forme générale |
|||
<blockquote>setSet,fullSet -> condition -> B </blockquote> |
|||
fonction setSet,conditionSet <span style="color: rgb(0, 0, 255);">'''conditionSubSet'''</span>-> setSet<br> |
|||
Cette fonction reçoit pour input un ensemble et une condition. |
|||
Elle produit comme output un ensemble constitué de tout ou partie des éléments du premier ensemble, ceux pour lesquels la fonction condition est vérifiée (renvoie true). |
|||
Eventuellement l'ensemble output est vide. |
|||
== Exploitabilité des ensembles<br> == |
|||
Les concepts émis jusqu'ici sont utiles et intéressants, mais en pratique certains ensembles ne sont pas exploitables, notamment par un ordinateur, pour la raison qu'il est impossible de les représenter au moyen d'une quantité finie d'information. |
|||
Les ensembles Z et R sont inexploitables. |
|||
L'ensemble B est exploitable. |
|||
L'ensemble setSet est inexploitable. |
|||
L'ensemble vide est exploitable. |
|||
Dans les deux paragraphes qui suivent, le but est de trouver à des ensembles inexploitables des sous-ensembles ''commodément'' exploitables. |
|||
== Intervalles d'entiers == |
|||
condition '''<span style="color: rgb(0, 0, 255);">interval</span>''' |
|||
Une condition interval comprend une condition basse (bigger ou strictBigger) eu une condition haute (smaller ou strictSmaller). |
|||
Les conditions interval sont définies pour R et pour Z. |
|||
Une condition interval a comme input complémentaire les valeurs limites. |
|||
L'une des conditions peut être absente, mais pas les deux. |
|||
Un interval est représenté comme en math par ]a,b[ ou [a,b] ou [a,b[ ou [a,...[ ou ]...,b] etc... L'écriture '...' signifie plus ou moins l'infini. |
|||
condition <span style="color: rgb(0, 0, 255);">'''finiteInterval'''</span> |
|||
C'est une conditon interval dont les deux composantes sont définies. |
|||
set <span style="color: rgb(0, 0, 255);">'''Zinterval'''</span> |
|||
Un conditionSubSet de Z dont la condition est un interval. Non exploitable. |
|||
set <span style="color: rgb(0, 0, 255);">'''ZFiniteInterval'''</span> |
|||
Un conditionSubSet de Z dont la condition est un '''finiteInterval'''. Exploitable. |
|||
<blockquote>Il est à noter que dans les langages informatiques habituels, les types ''int'', ''long'', ''short'' et ''byte'' correspondent à des '''ZFiniteInterval'''.<br></blockquote> |
|||
== Intervalles échelonnés de réels == |
|||
condition <span style="color: rgb(0, 0, 255);">'''multiple'''</span> |
|||
Une condition multiple renvoie true, si l'élément reçu comme argument est un multiple d'une base donnée. |
|||
Une condition multiple a comme input complémentaire cette base. |
|||
condition '''<span style="color: rgb(0, 0, 255);">multipleFiniteInterval</span>''' |
|||
Une condition combinant une condition interval et une condition multiple. |
|||
set '''<span style="color: rgb(0, 0, 255);">RMultipleFiniteInterval</span>''' |
|||
Un conditionSubSet de R dont la condition est un multipleFiniteInterval. Exploitable. |
|||
<blockquote>Il est à noter que dans les langages informatiques habituels, les types ''float'' et ''double'' correspondent précisément à des '''ZMultipleFiniteInterval'''.</blockquote> |
|||
== Construction d'ensembles : 2 modes<br> == |
|||
Les ensembles sont construits et modifiés suivant deux modes:<br> |
|||
*le mode logique implique des opération (fonctions) sur des ensembles, ainsi que des constructions de '''conditionSubSet'''. |
|||
*le mode énumératif implique l'adjonction ou le retranchement d'éléments individuels, indépendemment de tout contexte logique. |
|||
== Comparateur<br> == |
|||
fonction '''<span style="color: rgb(0, 0, 255);">comparator</span>'''<br> |
|||
Une fonction de comparaison est une fonction de la forme<br> |
|||
<blockquote>fonction S,S -> compare -> Z[-1,+1] </blockquote> |
|||
Son output peut renvoyer trois éléments possibles. |
|||
fonction <span style="color: rgb(0, 0, 255);">'''strictComparator'''</span> |
|||
Une fonction comparaison stricte est une fonction de la forme |
|||
<blockquote>fonction S,S -> compare -> Z{-1,+1}<br> </blockquote> |
|||
Son output peut renvoyer deux éléments possibles. |
|||
Un comparateur strict est - a fortiori - un comparateur. |
|||
== Ensemble ordonné == |
|||
Un ensemble peut on non être ordonné, c'est à dire, mathématiquement, doté d'une fonction comparateur. |
|||
Tout ensemble ordonné dispose des fonctions ayant la forme: |
|||
fonction S,S <span style="color: rgb(0, 0, 255);">'''bigger'''</span> -> B |
|||
fonction S,S <span style="color: rgb(0, 0, 255);">'''smaller'''</span> -> B |
|||
fonction S,S <span style="color: rgb(0, 0, 255);">'''strictBigger'''</span> -> B |
|||
fonction S,S <span style="color: rgb(0, 0, 255);">'''strictSmaller'''</span> -> B <br> |
|||
'''Z''' est ordonné<br> |
|||
'''R''' est ordonné<br> |
|||
Tout subSet d'un ensemble ordonné est ordonné. <br> |
|||
== Ensemble strictement ordonné == |
|||
Un ensemble ordonné peut en outre être strictement ordonné, c'est à dire, mathématiquement, doté d'une fonction de comparaison stricte.<br> |
|||
Tout ensemble ordonné dispose de fonctions ayant la forme: |
|||
fonction S,S <span style="color: rgb(0, 0, 255);">'''strictBigger'''</span> -> B |
|||
fonction S,S <span style="color: rgb(0, 0, 255);">'''strictSmaller'''</span> -> B |
|||
'''Z''' est ordonné |
|||
'''R''' est ordonné |
|||
Tout subSet d'un ensemble strictement ordonné est strictement ordonné<br> |
|||
== Structure == |
|||
concept! element <span style="color: rgb(0, 0, 255);">'''structure'''</span> |
|||
Assemblage d'éléments (parfois homogènes mais généralement hétérogènes) appelés membres et juxtaposés sans former d'ensemble. |
|||
L'assemblage lui-même constitue un élément. Une structure est définie par les ensembles auxquels appartiennent ses membres. <br> |
|||
Les structures composés d'un seul membre constituent un moyen de créér des ensembles synonymes.<br> |
|||
<blockquote>Quelques exemples:<br> |
|||
*structure coordinate : { R[-1000,+1000]x1e-6 }<br> |
|||
*structure Rplus : { R[0,+1000]x1e-6 }<br> |
|||
*structure Point2D : { coordinate ; coordinate }<br> |
|||
*structure Point3D : { coordinate ; coordinate ; coordinate } |
|||
*structure disc : { Point2D ; Rplus }<br> |
|||
*structure sphere : { Point3D ; Rplus }<br> |
|||
</blockquote> |
|||
== Caractères == |
|||
concept! set <span style="color: rgb(0, 0, 255);">'''char'''</span> |
|||
L'enseble des caractères, tel qu'utilisés dans la communication standardisée non-numérique. |
|||
Aucun rapport avec les ''codifications'' historiques des caractèrse en EBCDIC ASCII Unicode... |
|||
Aucun rapport avec les 'événements du clavier'.<br> |
|||
Pour les caractères, de nombreux subSet énumératifs sont définis: |
|||
*set '''upperAlphabeticChar''' (contains 26 chars) |
|||
*set '''lowerAlphabeticChar''' (contains 26 chars) |
|||
*set '''numericDecimalChar''' (contains 10 chars) |
|||
*set '''numericHexaChar''' (contains 16 chars) |
|||
*set '''bitChar''' (contains 2 chars) |
|||
*... |
|||
Au sein de ces subSets, des fonctions de comparaison (bigger , strictBigger, smaller, strictSmaler) sont définies. |
|||
Les subsets sont strictement ordonnés. |
|||
== Temps == |
|||
Concept! <span style="color: rgb(0, 0, 255);">'''clock'''</span> |
|||
L'horloge est une source d'information particulière. |
|||
function clock -> <span style="color: rgb(0, 0, 255);">'''time'''</span> -> R |
|||
La function time a pour particularité de ne jamais donner deux fois le même résultat. |
|||
Plus exactement, des appels successifs à la fonction '''time''' donnent des résultats toujours croissants. |
|||
Le nombre réel produit par la fonction time dépend d'un choix d'unité. La seconde est un choix tuel acceptable. |
|||
== Générateur aléatoire == |
|||
Concept! random |
|||
Comme le temps, le générateur aléatoire est une source d'infomation particulière. |
|||
function random -> <span style="color: rgb(0, 0, 255);">'''nextB'''</span> -> B |
|||
function random, Z -> <span style="color: rgb(0, 0, 255);">'''nextZ'''</span> -> Z |
|||
Les valeurs produites par les fonctions du générateur aléatoire sont imprévisibles (au moins en principe).<br> |
|||
Cette imprévisibilité est la caractéristique principale - peut-être unique - du concept random. |
|||
== Evénement == |
|||
Concept! event |
|||
Un événement s'inscrit das le temps. Il est engendré par une source, et intercepté et traité par des auditeurs... |
|||
== Instance and reference<br> == |
|||
Concept! <span style="color: rgb(0, 0, 255);">'''instance'''</span><br>the material representation of a concept<br>An instance is unnamed.<br>An instance is created (and destroyed)<br>An instance is accessible only through reference. |
|||
Concept! '''<span style="color: rgb(0, 0, 255);">reference</span>'''<br>Any reference name giving access to an instance of a concept<br>reference are linked to (1 or none) instance, whereas instance may be linked to zero, one or many references.<br> |
|||
<br> |
|||
<br> |
|||
<br> |
|||
CONCEPT LEVEL<br>abstract definition of the concepts and their links<br>INSTANCE LEVEL<br>creation, destruction, referencing of instances<br>ACTION LEVEL<br>logical action, logical processing<br>COMMUNICATION LEVEL<br>rules of exchange between CAIC groups<br> |
|||
<br>CONCEPT-LEVEL |
|||
C: set << concept <br>// set – or container - of 0.. many other concepts<br>// representation : {concept}<br>// representation : {N concept}<br>// representation : {0 concept}<br>// representation : {1 concept}<br>// representation : {2 concept}<br>// representation : {2+ concept}<br>// representation : {2- concept}<br>// representation : {}<br>O: size set << int <br>O: union {set} << set<br>O: interesection {set} << set<br>O: diff (2 set) << set<br>A: add set : concept<br>A: add set : set |
|||
C: seq << set ! <br>// set, with ordering<br>// representation : (concept)<br>// representation : (N concept)<br>// representation : ()<br>O: get (seq,int) << object<br>O: getIndex (seq,object) << int |
|||
C: bool << concept ! <br>// concept which has two possible state : false or true<br>C: false << bool !<br>C: true << bool ! |
|||
C: scalar << concept ! <br>// many ordered state : smaller, bigger will be defined, and others<br>C: zero << scalar !<br>C: one << scalar !<br>O: equal {2 scalar} << bool<br>O: bigger (2 scalar) << bool<br>O: smaller (2 scalar) << bool<br>O: strictBigger (2 scalar) << bool<br>O: strictSmaller (2 scalar) << bool<br>O: sum {scalar} << scalar<br>O: inverse scalar << scalar<br>O: diff (2 scalar) << scalar<br>O: product {scalar,scalar} << scalar<br>O: opposite scalar << scalar<br>O: ratio (2 scalar) << scalar<br>O: mean {1+ scalar} << scalar<br>O: between {3 scalar} << bool |
|||
<br> |
|||
C: int << scalar !<br>// something wich has the property of a member of the math N set.<br>// given two int objects, the second being bigger than the first,<br>// the number of int objects bigger than the first and smaller<br>// than the second will always be finite |
|||
O: interval (2 int) << {int} |
|||
C: float << scalar ! <br>// something wich has the property of a member of the math R set.<br>// given two float objects, the second being bigger than the first,<br>// the number of float objects bigger than the first and smaller<br>// than the second will be always be 'infinite'. |
|||
________________________________________________________________________<br>C: xCoordinate << float ! <br>C: yCoordinate << float ! <br>C: zCoordinate << float ! |
|||
C: point2D << {xCoordinate,yCoordinate} |
|||
C: point3D << {xCoordinate,yCoordinate,zCoordinate} |
|||
C: dist {2 point2D} << float |
|||
C: dist {2 point3D} << float |
|||
C: sqrt float << float |
|||
________________________________________________________________________ |
|||
C: polyedron |
|||
C: summit << point3D |
|||
C: center << point3D |
|||
C: line << {2 summit}<br>O: touch {line,summit} <<bool<br>O: touch {2 line} <<bool |
|||
C: face<br>O: touch {face,summit} << bool<br>O: touch {face,line} << bool<br>O: touch {2 face} << bool |
|||
L: {summit} == polyedron<br>L: {line} == polyedron<br>L: {face} == polyedron |
|||
A link may be:<br>system defined<br>enumeratively defined<br>logically defined |
|||
INSTANCE LEVEL |
|||
int fps |
|||
is equivalent to:<br>create conceptual instance of int<br>give to this instance the reference name fps |
|||
{int} a<br>(3 float) b<br>polyedron c |
|||
aa=a |
|||
is equivalent to<br>create a reference name aa<br>link the reference aa to the conceptual instance already linked to the reference a |
|||
L: references instance << {reference} |
|||
ACTION LEVEL |
|||
center center=(0,0,0)<br>polyedron polyedron<br>{0 summit} summits<br>{0 line} lines<br>{0 face} faces |
|||
{2 float} vx={-1,1}<br>{2 float} vy={-1,1}<br>{2 float} vz={-1,1} |
|||
forEach vx:<br>forEach vy:<br>forEach vz:<br> point3D p=(vx.,vy.,vz.)<br> summits.add{p}<br>done<br>done<br>done |
|||
forEach summit as s1:<br>forEach summit as s2:<br> same{s1,s2} << same<br> if same continue;<br> dist{s1,s2} << d12<br> smaller (d12,2.1) << close<br> if close:<br> line line={s1,s2}<br> lines.add{line}<br> done<br>done<br>done<br> <br> |
|||
<br> |
|||
<br> |
|||
<br> |
|||
Dernière version du 25 juin 2012 à 11:50
A présent Assothink: m3m.homelinux.org/wikiMC/index.php/Essence_de_la_connaissance