Les conséquences de l'incapacité d'ajouter des nombres naturels en C

Question

système F je peux définir la fonction d'addition totale réelle en chiffres Eglise.

Dans Haskell je ne peux pas définir cette fonction en raison de la valeur inférieure. Par exemple, dans le cas haskell x + y = x, alors je ne peux pas dire que y est nul - si x est inférieur, x + y = x pour tout y. Ainsi, l'addition est pas le vrai plus, mais une approximation à elle.

C je ne peux pas définir cette fonction, car la spécification C nécessite tout pour avoir une taille finie. Donc, en C approximations possibles sont encore pires que dans Haskell.

Nous avons donc:

système F, il est possible de définir l'ajout mais il est impossible d'avoir une mise en œuvre complète (car il n'y a pas de matériel infini).

Dans Haskell, il est impossible de définir l'addition (à cause du bas), et il est impossible d'avoir une mise en œuvre complète.

En C, il est impossible de définir la fonction totale d'addition (parce que sémantique de tout est délimité) mais les implémentations conformes sont possibles.

les 3 systèmes formels (Haskell, Système F et C) semblent avoir des compromis de conception.

Alors, quelles sont les conséquences de choisir un sur l'autre?

Answer 1

Haskell

Ceci est un problème étrange parce que vous travaillez avec une notion vague de =. _|_ = _|_ ne « tient » (et même alors vous devriez vraiment utiliser ⊑) au niveau sémantique domaine. Si l'on distingue les informations disponibles au niveau sémantique domaine et de l'égalité dans la langue elle-même, il est tout à fait exact de dire que True ⊑ x + y == x -.> True ⊑ y == 0

Ce n'est pas plus que est le problème, et ce n'est pas des nombres naturels qui sont le problème soit - la question est de distinguer simplement entre l'égalité dans la langue et des déclarations sur l'égalité ou de l'information dans la sémantique de la langue. En l'absence de la question des fonds, nous pouvons généralement raisonner sur Haskell en utilisant la logique équationnelle naïve. Avec les fonds, on peut encore utiliser le raisonnement equational - nous devons juste être plus sophistiqué avec nos équations

.

Une exposition plus complète et plus claire de la relation entre les langues totales et les langues partielles définies en les soulevant est donnée dans l'excellent document « rapide et lâche Raisonnement est correct Moralement".

C

Vous prétendez que le C exige tout (y compris l'espace adressable) pour avoir une taille finie, et donc que la sémantique C « imposer une limite » de la taille de Naturals représentables. Pas vraiment. norme C99 dit ce qui suit: « Tout type de pointeur peut être converti en un type entier . Sauf que précédemment spéci fi ée, la résultat est la mise en œuvre dé fi nie. Si le résultat ne peut pas être représenté dans le type entier, le comportement est fi nie unde. Le résultat ne doit pas être dans la plage de valeurs tout entier Type «Le document de justification souligne en outre que » C a été mis en œuvre sur un large éventail d'architectures. Alors que certains d'entre eux architectures comportent des pointeurs uniformes qui sont la taille d'un certain type entier, au maximum code portable ne peut assumer aucune correspondance nécessaire entre les différents types de pointeur et les types d'entiers. Sur certaines implémentations, les pointeurs peuvent même être plus large que tout autre type entier. "

Comme vous pouvez le voir, il n'y a pas explicitement hypothèse que les pointeurs doivent être d'une taille finie.

Answer 2

Vous avez un ensemble de théories comme cadres pour faire votre raisonnement; réalité finie, la sémantique Haskell, système F sont ceux d'entre eux seulement.

Vous pouvez choisir la théorie appropriée pour votre travail, construire une nouvelle théorie à partir de zéro ou de gros morceaux de théories existantes réunis. Par exemple, vous pouvez envisager ensemble de programmes Haskell toujours de terminaison et d'employer la sémantique sans fond en toute sécurité. Dans ce cas, votre ajout sera correcte.

Pour la langue à faible niveau, il est peut-être à des considérations prise finitude dans mais pour un langage de haut niveau, il vaut la peine d'omettre ces choses parce que les théories plus abstraites permettent une application plus large.

Alors que la programmation, vous utilisez pas une théorie, mais la théorie « langage de spécification + limitations de mise en œuvre » « spécification du langage » donc il n'y a pas de différence entre les cas où les limites de mémoire présentent dans la spécification de la langue ou la mise en œuvre de la langue. L'absence de limites deviennent importantes lorsque vous commencez à construire des constructions pures dans le cadre théorique de la sémantique du langage. Par exemple, vous pouvez prouver des équivalences du programme ou des traductions de langue et de constater que tous les détails inutiles dans la spécification du langage apporte une grande douleur dans la preuve.

Answer 3

Je suis sûr que vous avez entendu l'aphorisme que « en théorie, il n'y a pas de différence entre la théorie et la pratique, mais dans la pratique il est. »

Dans ce cas, en théorie il y a des différences, mais tous ces systèmes traitent avec la même quantité finie de mémoire adressable dans la pratique il n'y a pas de différence.

EDIT:

En supposant que vous pouvez représenter un nombre naturel dans aucun de ces systèmes, vous pouvez représenter plus dans aucun d'entre eux. Si les contraintes que vous êtes préoccupé par vous empêchent de représenter un nombre naturel, alors vous ne pouvez pas représenter Nat * Nat plus.

représentent un nombre naturel comme une paire de (heuristique limite inférieure de la taille de bit maximum et une liste évalué paresseusement de bits).

Dans le calcul lambda, vous pouvez représenter la liste en fonction qui retourne une fonction qui a appelé avec le rendement réel du bit de 1, et a appelé à de fausses déclarations une fonction qui fait la même chose pour le bit du 2 et ainsi de suite.

L'addition est alors une opération appliquée à la fermeture de ces deux listes paresseux qui se propage un peu de transport.

Vous d'avoir bien sûr de représenter l'heuristique de la taille de bit maximum en nombre naturel, mais si vous avez seulement les numéros instancier avec un nombre de bits qui est strictement inférieur au nombre que vous représentez, et vos opérateurs ne se cassent pas heuristique, alors la taille de bit est un problème inductivement plus petit que les chiffres que vous souhaitez manipuler, si les opérations se terminent.

Sur la facilité de comptabilisation des cas limites, C vous donnera très peu d'aide. Vous pouvez renvoyer des valeurs spéciales pour représenter dépassement haut / bas, et même essayer de les rendre infectieux (comme IEEE-754 NaN), mais vous ne serez pas les plaintes au moment de la compilation si vous ne parvenez pas à vérifier. Vous pouvez essayer de surcharger un SIGFPE signal ou quelque chose de similaire à des problèmes de piège.

Je ne peux pas dire que y est égal à zéro -. Si x est inférieur, x + y = x pour tout y

Si vous cherchez à faire la manipulation symbolique, Matlab et Mathematica sont mises en œuvre en C et C comme langues. Cela dit, python a une implémentation bigint bien optimisé qui est utilisé pour tous les types entiers. Il est probablement pas approprié pour représenter les nombres vraiment vraiment grand bien.