This blog entry is in english. Yet english is not my native language (italian is), so bear some indulgence with typos or grammatical mistakes. Also, I have been told that I write complex things - whether this is good or bad I don't know: but so, if you are unfamiliar with complex prose you may see grammatical errors not only where there could be some, but also where just a prose you're not acquainted with is. Native speakers with an A+ grade in english say my english, obviously not perfect, imports no major issues. Lend a deaf ear to the errors, vocally disagree with my thesis if you want, but enjoy the style all the while.
None of these texts should be considered as a lesson in the scientific topic it deals with. These texts represent only the personal effort of an individual with intellectual curiosity but no professional knowledge in the field and no degree in Physics or related subjects.
However, being so, these essays can still be of some interest for students: because they may occasionally reveal useful insights, sharing with students their very same naivety and the same necessity to cope with and solve the very same intellectual challenges they may meet.
Also, keep in mind that I like intellectual experiments. So, together with useful insights, you may find plain errors, and speculations that, arguably, you wouldn't find on any academic product.
Best viewed listening to the Goldberg Variations by J.S.Bach
Algorithms are prayers.
It is quite possible, like a few argue as if it were particularly reassuring, that within ourselves we obey to an algorithm of unflinching, consequential mathematical logic; but the mathematical logic that pertains to such algorithm doesn't demand of us to be mathematicians, but prescribes us to be poets.
The biblical book of the Song of Songs (a recursive title, you see, although some versions just title the book The Song of Solomon) is considered, in the exegesis, as the most mysteriously profound book along with the Genesis and the prophetic book of Ezekiel.
In such song the most awkward verses indeed can be found, and not at all the most poetic ones as those who read it assuming they are supposed to see in it a poetry which is not there believe. Among them one puzzled even Gregorius Magnus: "Thy nose is as the tower of Libanus, that looketh toward Damascus."
(DRV, Song of Songs 7:4) Gregorius wonders: "Your nose is like a tower - what kind of a compliment is this?".
As a matter of fact, thy nose is the tool of a sense which can tell, and actually foretell, the presence of something without the avail of either sight or tact: what the song of songs therefore declares, is that your intuition can allow you to see things which are not already within sight scope, as well and as effectively and with the same clairvoyance too as standing on a tower would do for a sentinel.
The Song of Songs is clearly addressed to a woman: and in the Book of Wisdom the Bible refers to the logos, to the sophia God created the Universe with, as a female.
God's Wisdom's nose is as a tower: therefore wisdom has a sense of smell, and it's acute. You don't understand the logics of things, you smell them «like a cougar in the twilight of Quitratrue» (Pablo Neruda, Love Sonnets, sonnet XI).
But this could only be true if we assume we already know all things: chase them within yourself, for they're coded in there. Follow the scent, and when the moon's raised high, howl your loneliness at its midnight, cry your melancholy, make your nostalgia of the Eden you belong to been heard and declared.
Insights that suddenly spread across the river and lead into the trees, and validly bridge gaps by the textures and fabric of dreams, or audacious jumps that bypass patterns with the flight of a flamingo, are at times all we're left with, in the grand impasse we all live by.
The Bible says: it is all perfectly competent and fit stuff.
Dealing with algorithms, we have to clear the way of a misunderstanding, therefore we ought to deal first with recursion, because there is a big misinterpretation about it.
Recursion means, conceptually, the repetition of a pattern that repeats such pattern onto itself (onto itself: if it would repeat a pattern onto an external entity continuously pouring in, that wouldn't be recursion of the pattern but repetition of the pattern), producing at each round a different version of itself upon which, once again, the same pattern is enforced anew in order to produce one more different version of itself - and so on until some X condition occurs and the eventual version of itself gets released.
Now, the mechanical nature of digital procedures yielded a misleading and rather false identification of the idea of algorithm with the idea of recursion: in other words, some (I do not know whether this your case or not) are under the spell that algorithms are (or would have had to be) "recursive stuff", and that anyway, in some way, recursion has to be consubstantial of algorithms.
This idea is false insomuch as it is just an extension of the archetypical idea of the latin "machina": a machine is definitely mechanic when its ideogram matches the icon of an omnipotent self deduction, wreathed in all encompassing consequences all produced within itself starting from a given seminal input (if any at all: the extreme ideal is, in fact, that it starts off by itself upon... voidness) of minimal significance.
An algorithm would therefore be a closed monad ("A singular metaphysical entity from which material properties are said to derive" - Word Web 2.1 dictionary) entirely self sufficient within itself.
This idea is engrossing, but algorithms have no special necessity to be recursive in order to be algorithms: being recursive is not the definition of what an algorithm is.
The reason this misunderstanding is so ingrained is that an algorithm is a mathematical formula that repeats an identical pattern onto an input for a given x amount of times or until some y condition is met. As such every algorithm institutes a circularity (over and over the pattern, until condition y is met and the result is relinquished) or an helical spiral (over and over the pattern again, building increasingly upward bigger or downward smaller an output until condition y is met and the eventual output is finally released), and it is pretty clear to everyone's eyes why a circular motion might easily end up being downright identified with a recursion.
But despite circularity may resemble recursion, the wide amount of algorithms that do not feed themselves with themselves, confirms that recursion alone doesn't suffice to define an algorithm, alike circularity alone doesn't actually identify with recursion.
What properly institutes recursion is the self fulfilling nature of the circuit. The difference is the same between a pencil which writes over and over a circle (or a spiral) continuously consuming new and fresh ink (a standard possibility indeed!), and a magic pencil that every time it redraws the circle, does it sucking back the ink from the previously drawn circle and using it to draw it again (or a magic pencil which, as soon as it starts drawing, for this very same fact starts producing ink by itself, or redoubles it by x every time it consumes it by y, and all the alike variations where the input is stimulated and renewed by the ongoing process): only the latter are recursions.
We'd discriminate among two types of recursion: recursion as a concept and recursion as a technique. You can implement non recursive conceptual tasks thorough a recursive technique, and you can implement recursive concepts through techniques which are not recursive. So let's state what a technical recursion is, and later we differentiate it by a recursive concept.
A recursive techniques is whatever technique where an informatic function calls, from within its body statements, itself. This should not surprise you, for you're probably accustomed to seeing functions calling in, from within their body, other external functions: the "secret" to stop being puzzled by recursion is to start deeming a call to itself identical to a call to a third or external function.
If such a call to itself from within itself is not performed, by and large there is no actual technical recursion in place.
Of course, the idea appears somewhat enigmatic: how can, technically, a function call itself if, when it calls itself, it has not finished being parsed by a digital interpreter yet?
The fact it that it is possible given the way a digital interpreter of programming languages work. If a function calls itself, what the inner workings of a digital interpreter produce is sort of a queue (more precisely: a stack) of suspended calls (calculations) all piled up from down onward.
When the last invocation finally able to return an ultimate result is reached (because the condition meant to stop the recursive calls to itself has been attained - a condition which has to be included in the statements indeed, otherwise recursion would be infinite and nothing would be ever relinquished), and consequently the top of such a queue (stack) is settled down and done with, then the result finally returned by this topmost record (calculation) on the stack triggers a windfall effect: it gets passed down to the previous element piled up in the ladder of the suspended calculations, and this latest one is computed and resolved too, accordingly to the value relinquished by the topmost one: on its own, this latter result ignites on a downhill effect as well, passing the result to its own previous suspended computation in the stack and also this one is solved accordingly to the passed value. Eventually the starting element of the stack is reached, gets computed, and the eventual result is what is returned as the overall outcome of the recursive function!
HOW TO REPRESENT COMPUTATIONS
From school time, we are already acquainted with one procedure at least that proves the possibility of the representation of a mathematical procedure as a drawing; and such procedure was called analytical geometry: mathematical formulas could be translated into an univocal graph.
This already reveals that a mathematical formulation can be invested with an alternative representation, so beware: a dream could not be less real than a fascinating curve or equation transposed in images.
However, the characteristic of analytical geometry is that its graphs describe the behaviour of a mathematical formula from its onset since it reaches the level upon which the pattern we started off with at the onset would get repeated: there analytical geometry normally stops, thus drawing an ideogram of the mathematical formula and it doesn't care to follow it beyond the first repetition (or recursion) of the pattern in all the different embodiments such pattern could evolve itself through.
It is different with fractals. Fractals are still ideographic reformulations of the same mathematical pattern, but this time the pattern is followed in a more thorough path across all its evolutions, repetitions, and whirls.
Whereas analytical geometry is satisfied as soon as it has painted the graphical representation of the pattern bound to repeat itself, a fractal goes beyond that and gets concerned with painting repetitions too, at least up to some x level.
Actually, computability (an algorithmic concern indeed) is independent of its representations, which could greatly vary.
What you should understand is that computation is not even a mathematical representation, and that mathematics is not necessarily to be seen or conceived as it ultimate background reality: a computation is just a deterministic set of correlated physical events within a given system: therefore, as also Roger Penrose recalls, even a billiard pool may be absolutely fit to perform calculations; that the result of a computation is to be either a string of numbers or a spatial configuration displaying itself on a billiard table as a consequence of an input strike, is something which is of no actual concern because the very same reality is shown in both of the alternative (but equally rigorous) representations we have called in.
Of course, this billiard is a special billiard: its player is infallible; every strike it imparts, is a master strike: it invariably hits all the designed targets in the intended way, after the intended scheme, without margins of error: this player plays in the same fashion a calculator meant to represent a computation by a string of numbers cannot perform and deliver a flawed division by mistake on the display. This player is without blemish, inexorable.
Moreover, you'd also consider the chances of meta languages, namely languages whose purpose is to ease the translation of languages into other languages: metalanguages are those go-in-between alternative representations that can be inserted to spawn a further representation through all the degrees of variations, all the hues of variations that can be imported. Thus meta languages are just those set(s) of rules governing these middle states, these mid-kingdomships, that may go in between and whose unique purpose is to guarantee a more and more seamless connection between the extreme representations of the two subtended edges and/or the exigencies of other possible third representations peeking in or taking avail of the edges but still requiring some accommodations to make the edges compatible with such peeking, intruding interfaces.
An algorithm as a concept, is both analytical geometry and a fractal: it is analytical geometry insofar it represents a pattern closed in itself, and it is a closer concept to a fractal than to analytical geometry when it is unfolded, for it triggers a string of computations repeatedly applying the pattern: an algorithm is the digital representation of a mathematical formula for a pattern, engaged in a long set of evolutions all reproducing the same pattern, building up a tile.
As Douglas Hofstadter points out, since an algorithm is a stored pattern to be applied onto some input data it gets fed with, the repetitions of the pattern amounts to this: the input data get elaborated passing through the pattern manifold times until simpler and simpler version of the input get produced. This is what Douglas Hofstadter states, although it is obvious that an algorithm is not bound to yield simplified versions of the input: it could as well be concerned with yielding as an output a complexified version of the input as it would get complexified by repetitive applications of the same pattern on it, over and over.
As a residual category, it is certainly possible to envision algorithms that do not produce simplified or complexified versions of the input, but that just reproduce a string of exact copies of the input: regardless of how nonsensical such a task may appear, an algorithm whose purpose is merely to output a definite quantities of the same input is conceivable (apparently, for this is what biological cells do in meiosis (cell division).
It is not going to be worthless stressing that an algorithm meant to produce a complexified or a simplified output given a start up input can build such an output in a basically threefold way:
1. taking in continuously the same input, unaltered: for instance an algorithm meant to add 5 for 10 times to an input which is number 2, might simply produce 10 times number 7, thus taking in still the same unaltered input (2) at each round. I'd call this repetitive, not recursive.
2. taking in a continuously updated version of the input: for instance an algorithm whose input is, say, number 2 and meant to add 5 for 10 times to the output, would take in 2 only at the first round, since it would then add to it 5 and would yield 7: then it would take in 7 and adding to it 5 again would yield 13, and than would take in 13 and still adding to it 5 would yield 18 and so on for 10 times. This is more properly called recursive. I personally would not bestow the conceptual name of properly recursive to an algorithm whose input is preserved throughout all its rounds: I would appoint the term of properly recursive only to those algorithms that feed themselves with the input producing each time a different output which is then meant to be fed to the algorithm itself as an input for x rounds.
3. Both the two approaches above are suitable to be fed upon an algorithm which might perform such repetitive (1) or recursive (2) approaches on third entities which might not be the input. Such an instance may be represented by those recursive algorithms that create an argument inside themselves and then recur above such argument.
You may notice arg2 is created within the recursive function itself, and then updated ( arg2) upon passing it to the recursive call.
This procedure is a procedure I myself often use when what the algorithm has to do is to build a collection of already inspected objects and to perform comparisons on it: such a collection could not be passed upon the first call, so it has to be passed (and created!) from within. Also, we'd have to agree on what we consider as complexified and what we consider as a simplified version of something. An algorithm as such is independent of its embodiments: whatever input you feed it with, it is ideally fit to produce an output upon which the pattern has been applied: therefore quantities are of no real concern for algorithms.
That algorithms are not defined by amounts, is further demonstrated by the fact that we have an inner tendency to consider (quite wrongly) as a simplified output whatever result which, crossed by an algorithm, approaches to a value equalling zero: we consider such outputs as simplified, and we regard the outputs whose direction of evolution is the opposite as complexified ones.
Now, this very same conception if hopelessly flawed in my humble opinion: it all derives from the fact we have in mind the zero as the origin of a cartesian cross, and the operations performed scrolling along its axis as necessarily sums (or subtractions). But a cartesian cross sets off with the origin at "zero" only by convention: it could have set off with number 1 as well, and its axis could be crossed by divisions on the left axis stemming out of the origin and by multiplications on the right axis out of the origin, and this all would determine an entirely different set of evidences.
If I start "reducing" an input by an algorithm which divides it and it approaches 1, as soon as I've surpassed the 1, I'd start a set of reciprocal divisions that would start being in thew shape of 1/2, 1/3, 1/4: this would instantaneously prove that beyond the apparent minimal level 1, what I start doing is not "simplifying" the output, but I'm still complexifing it, although it is less apparent because instead of complexifying it in the direction of the mammoth, I'm (symmetrically) complexifying it in the direction of an increasing minuteness: miniaturization as another frontier of complexity.
In this perspective simplifications do not even exist: all processes are potential complexifications.
Entropy is the natural tendency of all bodies not to produce complexity without using external energy (the typical example goes: if you throw on the ground an egg, you do not expect it to break and then all of a sudden to reassemble itself and go back in the refrigerator without external contributions: so you do need to consume energy to produce complexified orders, for spontaneous orders only flow in the direction of less complex compounds). As such algorithms are anti entropic.
True, when they run they consume energy, and therefore the complexity they produce is made by using external energy and not spontaneously. None the less this is no objection.
Many acute students asks to professors how comes, if entropy holds true, than life (as an extremely complexified and sophisticated reality indeed) is possible; professors normally stress that life doesn't violate the entropy principle, since all biological systems need to incorporate energy by food to go on living; but to my eyes this doesn't answer the real question: the students are not wondering why the exemplar x is alive and how it keeps going, but they're wondering how's possible that life as a phenomenon in the first place and as such has ever got a chance, if entropy prevails.
Analogously, algorithms are anti entropic in their mere existence, regardless of the fact that when enacted they consume resources: if entropy were a fatality, we shouldn't be here, and most of all we should not be here discussing... algorithms!
On the matter of what is complex and what is simple, we could add one more observation.
Many things merely depend upon a convention, which as such can be traded as a given fact but actually just is and just goes on being a merely subjective, and at times not irresistible, viewpoint.
For instance the tendency of entropy to produce less ordered compounds is regarded as a tendency to produce "order": but every body senses that it is generously subjective whether we'd consider a less complex item decomposed into its components as an increase of disorder (like, actually, every common sense would have persuaded us into: if a complex object gest divided into its components, what follows in my humble opinion is not an increase of order, but precisely of disorder!) or an increase of order as entropy declares to entail (insofar the idea is that the decaying object, by spreading out all its components, makes them available to be distributed more evenly into the space: consequently there is more evenness in the world because we have less conglomerates of complex things, and evenness viewed as fairness of distribution is "order"; as you see, what is order and what is disorder is vastly subjective, and the prevailing idea is not by this mere fact necessarily the best one).
As Eli Maor reminds us, algebra derives by the title of an arabic work "'ilm al-jabr wa'l muqabalah" which means " the science of reduction and cancellation": the term algebra derives by this as the term algorithm does. Eli Maor distinguishes "between 'abacists' who computed with the good old abacus, and 'algorists' who did the same symbolically with paper and pen".
Algorithms are therefore considered a science of "reduction", but what is reduction is to be agreed upon.
Still Eli Maor reports ancient mathematic procedures named "completion" which, given the name, would have suggested a gradual filling of a capacity until completion of it, and which none the less were reserved to mean a subtraction, namely a completion in the sense of an annihilation: termination to zero was conceived like a fulfilling completion!
By the way, the word calculus and therefore computation, just for completeness's sake, derives from the latin (would you guess?) calculus which meant pebble, because old abacuses were "calculators" made up of rods upon which pebbles could skip to produce different spatial representations of a computational reality.
Of course, all computations show one of their main features in the fact they're time consuming. And at times they can be extremely time consuming (a computer too long engrossed into algorithmic calculations might end up freezing -at least apparently- or being less responsive to alternative inputs by the user because it is eating up significative amounts of resources in order to accomplish the tasks the algorithm entails). Also, you may have noticed that when you start your computer, you need a phase of booting which is meant to perform all those algorithmic calculations needed to set off the operative system and make it ready.
I consider pregnancy like the booting of the biological system: complex algorithms are to be enacted when building up a body, and they arguably do demand a lot of time, even months. What makes pregnancy different from digital algorithms is (but such remarks implies no deterministic stance by me: I do not surreptitiously involve that I judge biology just a complexified branch of informatic) that the end of the algorithm is given once and for all by a consideration of elapsing time.
I believe that some internal biological clock is certain to be there, otherwise we could not explain how comes gestations have definite rates of time for each different breed; such internal clock has to be set and regulated by and upon something reliable enough to be judged by every breed as outlasting the breed itself on a breed scope and, of course, has to be dramatically regular enough to be suitable to be deemed a reliable and standing rhythm giver: and the only bodies which to my eyes could perform such a task are heavenly bodies.
Namely I do say that I believe all biological clocks are given their beats by the direction of planetary motions: nothing else could inform a whole breed over time and space both that a predefined amount of time has elapsed from the igniting moments, regardless of where the breed instances dwell, regardless of the century they have the venture to walk by.
So the question is: is it possible that a correct gestation for a earthly breed would be undertaken and performed upon Jupiter? And if not, is it possible that one of the reasons the Earth is inhabited and Saturn is not depends upon the fact some gravitational aspect is suitable only in the earthly location to beam as a reliable time giver? Of course, since there must be an interaction between biology and the planets where biology too plays a role, we might argue that a different biology could have found a different planet to suitable as well to produce the necessary synergy; but what I wonder is, since life in our system appears being only on earth, is it possible that there is something in this gravitational arrangements that makes gestation possible only on earth, regardless of how the biological system might have been arranged? We already have problems persuading into a copulation animals kept in captivity, namely out of a natural environment: would it be possible, perhaps, that pregnancy would never come to an effective close upon an entirely different environment like a spaceship orbiting pretty far off from the earth/sun/moon system?
Would earthly pregnancy, maybe arguably started on earth, be possible or be apt to be carried out successfully, if at a second time we go into a spacecraft and travel nearby Alpha Centaury?
We have the so called halting problem: when has an algorithm to stop calculating?
The main involvement is that if it doesn't stop, maybe an algorithm is useless insofar it is quite possible that intermediate results would be unreliable: it is quite possible that at each round an algorithm has
to update all the preceding values arrayed to be delivered to the output - a possibility indeed: an algorithm meant to output a list of numbers updated by one might also be instructed to update all the already produced numbers to be delivered to the output by, say, 50, in case it meets, say, a 7 in the (repetitive or recursive) input.
So, of course, a solution to the halting problem might well be, regardless of how trivial it appears, setting a given time: just stop after x hours.
I do not believe that this is the way we should consider biological gestations: they do not stop at a certain time just to stop, but because it is known (arguably among other involvements) that at that time the "output" is "ready". No programmer I'm am aware of would ever recommend such a thing like a proper way to decree the halting moment of an algorithm: and none the less the fact we see that the greatest programmer of all, Nature itself, chose exactly this procedure, should make a bell ring and alert all of us that within this option there must be some very subtle implication. Heavens didn't grant me the honour of understanding what, but merely human observation suggested to me that highlighting this fact was a sensible thing to do.
Anyway pregnancy, unlike bacterial meiosis, says to us that such a process requires a major organism, namely an organism already ready to process the time scansions given by a planet, sort of a nesting of a clock within a clock, which therefore reveals that grown up organisms are all exposed to register planetary fields influences even beyond and regardless of pregnancy: if pregnancy is affected, it is well possible that much wider biorhythms are affected.
Please note that this is not sci-fi: what should worry you is exactly that I'm serious, Mr. Feynman...
THE FIELD ALGORITHMS MOVE BY
We might ask ourselves: is a mere sum (1,2,3,4...) an algorithm? Yes and no.
Firstly, you'd consider that before number four (the number beyond which man is ousted of Eden accordingly to the Bible, since Eden has 4 sides guarded by 4 angels) you have no way to determine which algorithm might be in action in a series.
In fact if you take the output
1,2,3
it may well be the consequence of an algorithm whose purpose is to add 1 to each newly produced digit, or it might as well be a so called, for instance Fibonacci series: a Fibonacci series is a collection of numbers where each number is the sum, of the two preceding ones: so, for instance, the first items of a Fibonacci series are:
1,2,3,5,8,13,21,34...
As you may notice, the first three items are still
1,2,3
but the algorithm which was at work in the background was quite different!
Therefore an algorithm is firstly something you must know beforehand: you cannot deduce an algorithm (the enacted pattern formula) by comparing or guessing relations between the input and the generated output: never. You may bet on it, but you may never know it. And, certainly, you can't make even guesswork if all you have are just the first 3 steps of the output.
Since we cannot locate the pattern if we only have at disposal the result, could we argue an algorithm enforces an irreversible process? Yes and no.
No, for once you know the formula of the underlying pattern, and you either have the whole of the original input or the difference, you can certainly scramble a way to restore the original unity and reverse the algorithm's effects.
Yes, for as long as you don't know the stated above, the patterns is forever ciphered by irreversibility.The only thing we may infer by this consideration is not on whether we'd better consider algorithms as irreversible or not, but that maybe what we traditionally deemed as irreversible, namely and mainly time and entropy, might be either really irreversible or might be as well sort of an algorithm whose result, but not whose formula, is known to us - and applied unto us. We are within the output, and perhaps within the input too.
An algorithm builds itself upon an input which is fed to it like a continuum the algorithm has to inspect. So a continuous sequence is more apt to be conceived like the input, instead than as the output, of an algorithm.
Upon this continuum, an algorithm is not defined by what it does, but by what it does not, and it is not defined by what it picks, but by what it skips: an algorithm is a taoist reality, whereas vacuums provide the presences with their significance. And as the Gestalt says: "the whole is different than the mere sum of its parts".
Moreover, any continuum is implicitly presented as a sequence of discrete intervals, even if we reduce it to a string of items all as small as the tiniest thing we can imagine (a quark, a photon, whatever your intuition may prefer): it is still a sequence of gaps of varying breadth.
In fact, a sequence of units can be considered either as a sequence of 1s which subsume in themselves a bigger reality (as it is when we say, for instance, that in a diagram the main unit of an Army is a platoon: but each platoon, although considered as a single unit 1 in our diagram, is actually made up of more elements/soldiers) or as a sequence of the tiniest possible unit in the given system (which as such is an "ultimate" 1 indeed).
What an algorithm does on such sequences is to riddle them with still more gaps, picking from there objects accordingly to new gaps (the patterns, indeed) it has to impose in order to detect where it has to pick from.
Of course, the algorithm returns objects, but what I mean is this collection has been singled out defining each item in it as something primed from a continuum after it has been skipped and jumped upon accordingly to gaps dictated by the given pattern. An algorithm that orders to get every number out of 5, is not defined by the numbers it takes in, but by the scansions of the gaps of 5 it has imparted.
And even an algorithm that dictates to sniff all the items in order to locate those where, say, the word "yellow" " recurs, is an algorithm which can collect all the yellows, but can still be defined by what it left out; and since in the numerical example provided earlier the gap was surely a prevailing criterion, and in the latter literal example the gaps although not immediately a prevailing one, none the less were allowed in as the most spontaneous consequence, the gap vision can be legitimately declared as the winning one which as should be sponsored and adopted; when facing an equipotent choice, try make it on arguments anyway, and you might find that the equivalences weren't so equipotent at all, after all.
An algorithm is defined by what it skips, not by what it picks.
And ultimately, it may skip nothing in a continuum of quanta, namely still of gaps.
So indeed, every algorithm that defines an output collection out of an input collection, defines also a complementary unit which is what is left out of the original input once you've removed from that continuum the primed entities, accordingly to the imposed gaps.
And if an algorithm complexifies in the sense it produces a bigger output than the original input was, still the difference between the input and the output provides us with a complement (the difference) and what has been added has still been added by patterns that imposed to the algorithm not what to do, but what to skip: the fact I add number 5 to number 1, and that obviously yields 6, should not conceal from my eyes the reality of what I've algorithmically done: I've prescribed to skip 4 slots.
Every consideration about what I have, is made on the output eventually relinquished by the algorithm, when the algorithm has performed its duty and so is not longer there: namely a consideration on what I positively have is not a consideration which affects what the inner workings of the algorithms and consequently its nature were, but only of what is left once the algorithm has consumed its path.
An algorithm's core is a dodging machine which skips.
An algorithm, like a biblical commandment, prescribes not what you have to do, but what you have not to do. To be or not to be, indeed this is the quantic question, although: "I am - you have not".
I'd like now to delve deeper into this matter of the continuum as the input field provided to the algorithm and upon which the algorithm has to inflict gaps.
A field, likewise a physical field of forces, can be conceived as a sequence of lines, which as such under an euclidean viewpoint aren't but sequences of dots.
Now, how are these lines to be arranged? We can conceive two options: a field saturated with lines which are parallel to each other, or a field which gest saturated by lines that beams in a radial shape from an emitting sources in a shower of rays diverging from the spring.
In both cases the field is never really saturated.
A sequence of lines is, in euclidean terms, a sequence of dots, and dots are such as long as they're discrete intervals, namely no dot exist if you cannot distinguish it from a vacuum around it: only if such vacuum exists you can later connect dot to dot by their edges.
A set of rays diverging from a spring, would diverge from each other more and more the further they go from the origin (set your finger to make a V: they diverge...): thus the spring has to irradiate more and more go-in-between rays in order to be sure to fill in all the remote gaps, without ever ultimately attaining the goal: whatever degree of divergence, no matter how irrelevant in the beginning, would necessarily increase into infinite gulfs if we go far away enough from the spring.
Some authors consider this an involvement representing the reality of incomputability. What is incomputability? I bet the best way to express it is to consider the difference between the so called rational and irrational numbers.
Rational numbers are the numbers you're well acquainted with: 1,2,3, 500, 739: just whatever...
They're called rational not insofar they have something mentally affine to our "reason" meant as "rationality", but insofar they're affine to mathematical "ratios" namely to divisions (ratio in latin does means partition).
In fact each of those numbers can be divided, at least by 1. Consequently, also numbers like 5/2 or like 4/91 belong to the field of the rational numbers (5/2=2.5 and 4/91= 0.04395604... we don't know if and where this number finishes: but about this see the frameset below on what rational numbers mean).
Now regardless of the finite or infinite nature of some of these numbers, what concerns us and what constitutes the field and family of the so called irrational numbers is the puzzling fact that do exist some numbers that cannot be deduced by any ratio: that is, some numbers (among them the famous PI namely 3.14 etc..., π) cannot be yielded by any type of ratio, whatever type of numbers you may choose to divide in order to attempt see whether such ratio would ultimately relinquish the given irrational number: you're never to find it.
This means incomputability indeed, for in which scheme a number that cannot be devised by any other number could ever fit or be drawn/computed from?
Another irrational number is the square root of 2 (we will call it sqrt2). To demonstrate that such numbers do exists, namely that they cannot be argued by any ratio, we can proceed as follows:Why we make this assumption that a number could be the derivation of a division: what is the logics behind this assumption instead of an alternative one? Why, for instance, we don't assume that every number should be represented by a multiplication or some other, arguably complex, equation?
Have you ever realized that a division isn't but a subtraction in disguise, and more precisely a subtraction enacted as a repetitive -better: recursive indeed- pattern?
You say 10/2 and what you properly mean by that division, is: subtract number 2 from 10 as long as you cannot subtract it any longer without overstepping, and yield as a result how many times you had to make this step recur before stumbling into this constraint.
So you have
10-2=88-2=66-2=44-2=22-2=0
5 subtractive steps, so the result is 5: and I'm positive you're not to challenge that 10/2=5: but did you ever consider it wasn't but a recursive subtraction? Odds are now that you never actually did.
Of course, we can have subtractions with a reminder, namely that do not perfectly fit, and we're to consider them soon, but first I want you to grasp fully what the above entails.
What we have done by dividing is to make sure that a number is a multiple of another for x times, namely that these numbers have some common factor otherwise they couldn't convert into each other by division if they had nothing to share - exactly.
Now, why is this presence of a multiple and consequently of a common factor so pivotal and crucial that we base on it the definition of numbers as ratio-nal?
It is such because if something can be expressed like a multiple of something else, or both numbers can be expressed as both multiples of a third common root (and thus by the transitive property belong to the same domain: if a=b and b=c, then a=c), then it means that each instance of this common root isn't but a pattern of the recurring common factor:
instance = Root * Rounds;
Why this possibility of pinpointing a recursive pattern is then so pivotal? Because if such common root can be pinpointed, this means the number is computable, and consequently fits within a broader continuum all represented by the elements sharing this common root.
Now, note that there are divisions which certainly yield a reminder, but this remainder doesn't imply the common root is not there any longer: 5/4 yields 1.25 but this doesn't mean that 5 and 4 have no common factor: it simply means that 4 is inside 5 by 1 time(s) for sure, plus 0.25 times of 4 itself, which means 25% of 4, which is exactly 1:
25%=25/100=0,25;
0.25*4=1;
which means if you add to 4 number 1, you certainly get 5; which implies that 0.25% of four is the eventual common root of both 5 and 4, or couldn't fit that way: they still belong to the same continuum.
Don't be fooled by things like 4/5=0.8, which is smaller than 1; this means that 5 cannot fit into 4 unless you remove from it the 80% of it, namely:
80%=80/100=0.8;
5*0.8=4;
remove 4 from 5 and you get 1: this is the exceeding factor, which still proves we can find common building elements in both numbers. And as you may notice all the entailed operations were perfectly computable and thus could all be performed: the process didn't stop and would eventually relinquish the common logic (cause) by which the effect of the relations between 4 and 5 proceeded.
Eventually, either you are to find that the common factor is the unit 1 as the minimal entity, or that you can swap the current domain of 1 with a smaller domain of a "smaller unit 1" where now the building root is smaller then what previously assumed as the smaller one (it depends on whether by 1 you did meant the smaller possible unit, or a convenient way to subsume into a unit an actually broader set: a department is the smaller unit of a University, but each department actually still ranks a plurality of units: the single individuals, which therefore are the real common factor of whatever fractional representation of the whole hierarchy you may assemble).
Now note what James Newman says in his excellent collection "The world of Mathematics" (Vol. 1, page 576):
«A rational number can be expressed in decimal notation and where the decimal notation does not terminate, it is recurrent, that is, it repeats itself periodically; for example 10/13= 0.769230769230769230 or 14/11=1.272727.An irrational number when expressed as a decimal floating neither terminates nor exhibits such periods.»
So you may notice that the founding principle of the rational numbers isn't that they have to be finite, but entirely relies upon the fact they do exhibit a identifiable pattern which recurs: they have to be multiples, and also the reminder either is finite or if infinite must recur in itself too, and exhibit a periodic feature (subsequence of floating digits, specifically).
Now notice this: in a number like
14/11=1.272727... to infinite repetition
Firstly you don't write 1.27: in fact 1.27 is a different number than 1.27 to infinite recursion: you write 14/11 to express this.
But most of all, note that the recurrent pattern which is taken into consideration is not deemed being:
272727
but it is 27: why? Because the implication is that we locate the least of the recurring patterns.
In other words, we go on subtracting until we find the least common factor in the recurring periodical floating section too. And there we find that, once again, attaining a shared minimum signifies: this is the minimal pattern in action, and the fact there is a pattern grants us computability.
So being computable does not mean the algorithm has to have an end: it only means that we are guaranteed that an adequately long repetition of that very same algorithm's pattern (maybe even an infinite repetition, as long as a repetition can be verified to be ignited at some stage and to go on reproposing itself no matter how long the gap is as long as it is constant) would ultimately deliver the expected result.
This means that being computable and being consequently "rational", which isn't now but a synonymous of being computable, means being bound to the everlasting power of a pattern, regardless of how vastly the domain of such a pattern may stretch, if the lord overseeing this pattern is still one, still entrusted with full power along all the directions and all the alleyways of the stretch.
So the big question was then: do there exist numbers that exhibits no pattern, namely belong to no ratio whatsoever, which as such are not finite, and whose consequent floating digits never show one single identifiable pattern also if you go on computing at near light speed for the age of the universe? How can you verify they exist, provided you don't have two universe lifetimes to compute all along?
Let's assume by reduction ab absurdum (namely we assume what we know cannot be possible is possible, and we see the consequences it would entail) that sqrt2 is the result of some ratio A/B.
Let's assume also that this A/B ratio is already simplified, namely we're sure we've divided it by any common factor until its simplest form is achieved - that is, if the ratio would have been, say, 5000/2000 we would have divided both by 10 until the eventual shape 5/2 is achieved and no further division by the same number can be performed. Note that sqrt2=a ratio, is an assumption we draw arbitrarily, and which we want to prove.
Now, if this equivalence sqrt2=A/B holds true, than also powing to 2 all the elements would yield an equivalent this step utilizes the axiom after which if declared equals, namely the two elements on the left and the right of an = sign, are multiplied by the same number, or the same operation is performed on both, this still tantamount to the original equivalence and expression). So:
pow(sqrt2)=powA/powB or, since the pow of a sqrt is the number itself:
2=powA/powB
So far so good.
Now let's multiply both sides of this equation by powB (performing the same operation on two sides of an equation leaves its meaning unaltered):
2*powB=powA
We notice that 2*powB is necessarily an even number (every number multiplied by 2 becomes even!).
If so, also powA must be even since the equation implies so: 2*powB=powA.
You have to know that for a pow being an even number, the original factor which gets powed must be an even number as well (powing is but a multiplication of a number by itself), so we can say that A=(2*something) too.
So 2*powB=powA can be also written as:
2*powB=pow(2*something).
or, since the pow of 2 is 4:
2*powB=4*pow(something)
Let's divide both sides by 2 (again, the same operation on both sides of an equation leaves its meaning unaffected) and we get:
powB=2*pow(something) Now, powB must be an even number if it has to be equal to 2*whatever.
So now powB has a characteristic, being even, which partakes with powA.
This cannot be: in fact we made sure at the beginning that we eliminated from the ratio A/B all the common factors and that it was the simplest ratio of the line we could yield: but if those numbers are still even, it means there is still an even common factor they can be divided by (in our case: 2).
Since this outcome is a paradox, the only solution is that our original arbitrary premise, namely that sqrt2= some A/B ratio is not correct.
Consequently sqrt of 2 is a number that comes out of no ratio, and of no computation.
Irrational numbers exist.
(the general outline of this pythagorean demonstration taken by a prof. Morris Kline book)So, a variety of authors argue that the empty spaces in the spatial representations of the field we were arguing before, aren't but the representation of these non computable enclaves.
If this holds true, I'd bet my cent that the better representation of a field is therefore also the representation of it as a set of rays emanating from a spring and not as a set of parallel lines (as meridians would be).
I guess this because parallel lines would never allow for non linear expansions of incomputability: the blank spaces between parallel lines would be just as much computable as the black lines are, thus being not really uncomputable or differentiated in their incomputability from them: although numbers are infinite (the dotted but infinite parallel lines), you can single out segments of them; but incomputability should never allow for definite segments being analogously taken out of it (although you can curtail them at some decimal floating point just to cut too long a story short!), consequently the ever expanding sets of uncomputable blank spaces in between rays, which the more the ray goes on the more spread the gulf between the V sign of the ray, are to my eyes best suited to embody the reality of unfillable incomputability. Which, anyway, is not an axiom.
One last characteristic needs to be analyzed: a spreading gulf may include no specific direction - actually it is possible it is even the lack of this direction what makes it undetermined.
None the less, a straight line is something more puzzling. What kind of arrangements the dots that compose a straight line have to follow in order to be straight and not to wander around?
We'd consider what being perpendicular means: being perpendicular means singling out a one option out of a set of a multitude of concurrent options: if you paint a dot and far from it you draw a line, and now you try to connect the dot to the external line by another line, you'll find that you can draw an infinite amount of segments all competently connecting the dot with such external line (even symmetrical ones, since you can diverge of an amount of x degrees on both sides of the perpendicular), but among these segments all equally fit to connect, one and only one is the segment which also represents the shortest, fastest route from the dot to the external line, and this is the segment which from the dot crosses the external line in a perpendicular way (namely describing square angles of 90 degrees at the cross point).
The reason I'm concerned with perpendicularity, is that by saying "the shortest route" from a dot to an external line, this would imply saying much less than saying "perpendicular": this is why I'm attempting to solve the conceptual difficulties inherent to the idea of perpendicularity and of the straight line which necessarily goes with it: just arguing that we should travel "by the shortest route" is more of an auspice than of a condition, for it still says nothing about how to attain such "shortest route".
Consequently saying that in order to achieve the objective (the "shortest path") we need to be perpendicular, maybe we do not solve everything yet, but we do add something at least: in fact arguing that "the shortest route" has to be found would mean to deliver oneself to trial and errors, but conversely saying we need to be perpendicular means to introduce in the pledge a few elements which are priorly and surely computable.
We could therefore argue that a line is a set of dots perpendicular to each other. Notwithstanding, this is not enough yet: if the only criterion would be perpendicularity, you can be perpendicular in more directions as far as a shapeless dot is concerned, so perpendicularity is not a concept sufficient to prescribe what type of path the dots have to follow when they align to form a straight line instead of an arbitrary curve.
The concept that comes to help us is the concept of direction.
What does direction mean? Let's consider a division: 10/2. It is always identical to itself, and none the less can be read in two different directions although the output is the same (the Gestalt, once again...): is it the ten which has to split up itself in two parts in order to fill in the capacity of two slots amounting each to 5, or is it number 5 which is meant to be instructed it would have to call in a copy of itself in order to distribute itself evenly across a whole capacity of 10?
Now, what is that can give a direction out of two (or more, for the matter)?
Not that I deem the direction as essential in itself insofar it enacts a dilemma: I find it essential insofar it allows a criterion to make straight lines a possibility; in other words, I'm concerned with the fact there is a choice of directions, but not with which to undertake.
Moreover, there is a greatly conventional nature in directions as a choice to be made: as such, this choice may have little significance, just like computation as it is represented by a mathematical expression doesn't intrinsically differ or prevail on the same computation as represented by a billiard scheme. Take life and death: we could reverse it back to front and nothing really changes: we'd just have to understand (not) a different set of analogously connected cause and effects; a hump of cells mysteriously springs out of a muddled inert matter, among decay vermin and dust; gradually a weak being gets created, with wrinkles and maybe no or white hair: this creature steadily proceeds, if death (or should we call it birth?) doesn't occur earlier, towards an age of vigour and sexual fitness, and then would get weak once again, and would gradually shrink until in callowness it disappears into one cell which splits in two and generates two cells fit for reproduction. Thus you would get old by youthing, and you'd die by prematurity and early age. Spontaneous creation hasn't seduced us but because of the interchangeability of this fantasy, and this fantasy is strong insofar the only thing we miss to get firmly persuaded of its logics as we got firmly persuaded of the logics of the current one, is an habit long enough to regard its folly as perfectly "natural".
About directions, if you consider time, it is a strange beast:
it flows in one specific direction: you can't journey it back.
it flows as if it would be constrained and forced: you can't stop it.
it flows at a steady rate: you can't slow it down.
These characteristic are quite close to one chance alone: attraction form an external source. Of course, if Copernicus has taught something to us, also the opposite may be true: repulsion from an external source. In fact the true lesson of Copernicus' legacy is this: before arguing for the obvious, give the fitness of its exact opposite a chance to produce the very same outcome. And if we got it right indeed, we could even add: then compute all the residual combinations of the input factors, as an algorithm would, and test their chances too. So let the obvious be your sworn enemy, a lesson not only Descartes but Michael de Montaigne and David Hume too repeated and have taught us.
As far as I can see, the only thing which can give a direction to a set of perpendicular motions, is a likewise attraction or repulsion. Or can dots have a foreknowledge of their destination and long for it, as when you deliberately take aim at something, namely taking aim at the eventual dot in the segment?
It is somewhat problematic considering the nature of a straight line as a sequence of perpendicular dots, without also assuming an internationality in it, the exertion either of a push or of a pull - and a push can be either repulsion or propulsion, whereas a pull can conversely and seemingly appear fit only to some external attraction.
How can you tell whether you're under the spell of an external source? By the fact that you accelerate (or decelerate) the closer (or the farthest) you are from the external force. If your pace is steady, it is more likely yours is propulsion, although a fading supply of internal energy might cause sudden decelerations or accelerations (resupply) - phenomena, these latest ones, which by the way can be told from a plurality of external sources claiming you by the fact that accelerations and decelerations would not be coexistent with a linear path. So a straight path along with accelerations is consistent only with propulsion affected by supplies, a straight path at steady velocity only with propulsion, a wavering path with acceleration by more external sources plus maybe resupply problems, and a straight line with acceleration to one single external source.
An irradiating spring can be conceived either as a generator of straight lines endowed with propulsion, or as a source repelling dots from its center (as well as drawing them in from some outside basin).
However we define these fields, they are to generate straight lines which describe the field of the objects (dots) an algorithm has to jump around; so algorithms appear being mostly concerned with the computable lines, although what they want to compute is how to break them as if to introduce into them more gaps than those already surrounding them.
Their purpose is, consequently, to provide routes among the dots which are not straight, namely alternative routes that define the pinpointed dots as belonging to paths other than those straight paths they beam out from.
This is what algorithms do: they skip positions to create alternative avenues.
Of course, normally algorithms get fed by inputs which are already digested pre selections of elements out of these fields: for instance an algorithm can be fed with all the numbers which are odd and between 301 and 501 and the algorithm would have to apply a pattern onto this subgroup. In such case the input may well have the shape of parallel (and no longer irradiating) lines (many times it has it indeed: a variety of typically algorithmic inputs are in fact matrixes, namely arrays made of arrays, which therefore have rows and columns of items), and an algorithm would be required to perform a further kind of scansion among this set of furnished objects. To our eyes it may appear this scansion is the only one which has been performed, but actually it is the second at least, for the provided inputs have already been singled out of a wider whole. Therefore every algorithm hides a presumption, and this is why algorithm are so strictly connected, and so often, with highly specific and related data structures: because they presume a presumption.
Actually the outer space of irradiating fields may also be conceived as hosting a plurality of springs, each radiating its own property: dots would then be the crossroads of these beams, and the qualities of each dot the cumulation of the different type of crossroads of these raying noumenons. Quantum physic would belong to these rays indeed.
Algorithms should then jump between these crossroads to find the given combinations, and this is another way consistent with this outlook to describe who algorithms are.
Also, algorithms make a further presumption: they exhibit a faith in the high, elevated probability of finding an order, and remaking it. Novus Ordo Saeclorum: New Arrangement of the Ages.
If the purpose of an algorithm would have been to search for things in chaos, it would altogether have ceased being an algorithm and it would just have been groping amidst chaos: but that's not an algorithm, because every algorithm presumes the objects and the field it has to search in does exhibit an order, and that such order and logos can be both detected and exploited. Algorithms are trustful.
So how an algorithm searches its wanted objects is a matter of what we know about these objects in the field they thrive on. Writing an algorithm means knowing firstly as much as possible about the objects even before we arrange the algorithm itself.
Therefore writing an algorithm means to find the property which is more likely to be exhibited by each of these passed crossroads and which is more likely to be connected with the property we are in search for (i.e: if I search all objects which are yellow, and I know a few objects are red, maybe it is faster to skip the reds openly instead than taking in the yellows - which indirectly skips the yellows), and all this has to be made attempting to locate the most economic path (the more "perpendicular" one, perhaps we might argue, to the target), with the eventual aim to arrange these objects accordingly to a new route; and such new route home is described by where the algorithm abstains from doing, not by where the algorithm does something: for what algorithms really decree is not what has to be done, but where nothing has to be done.
Algorithms are perpendicular prayers.
This text is protected by Copyright and cannot be reproduced, either in totality or in part, without the consent of the author. Also derivative works cannot be produced without the consent of the author.
Minor excerpts may be quoted as long as a clearly readable link leading to this file is put in place soon after or soon before the quotation. Only the author has the right to reproduce in its totality this work on other servers.
If the text includes external snippets, you may hide their borders (useful for codes): click here
This subscriber has snippets too: Read the snippets. Shoutbox: 82reviews: 170Visitors: 9,973 Daily average: 8Overall visits to all the topics: 362,003 Daily average(Calculated from the website subscription day): 249.31Optional sorting commands: Normal order: click here Order by amount of visits: click here Order by most recently commented (attention: this will exclude from the returned results all the entries that have no comment): click here Order by highest amount of comments (attention: this will exclude from the returned results all the entries that have no comment): click here Order by vote (attention: this may exclude from the returned results all the entries that have no votes): click here Current order: normalShowing topics: 1, 20 Available total (with or without comments): 56
List topics by this author without this topic text: click here Other topics available for this author: click on any title below to view the complete item:
There is a max limit to the amount of comments that can be held by a page, limit above which any new comment that is inserted will determine the deletion of the older comment in the queue. The max amount of comments that can be inserted is of: 100.
To perform this operation it is necessary to be Full Poster members. If you are a member, insert your Identification Number and Password in the proper fields, and then proceed:
This list is currently empty or its edge has been surpassed. Back to the blog.
JoinAll for free
searchprofiles
UpdateLogin
English
Italiano
Deutsch
Delicious
To perform this operation it is necessary to be Full Poster members. If you are a member, insert your Identification Number and Password in the proper fields, and then proceed: