Programming Matters (Laegna Programming Book)

• A: 1; down; limit to 1 or +Zero

• O: 1; down; limit to 1 or Zero

• A: 1; down; limit to 1 or +Zero

• I: 1; up; limit to -1 or -Zero

• Input Portal: Map of Combinators (iterate combinations)

• Receiver Map:

• They are not in memory listing of an active program, which is not obligued but it can close the active listings if closed, where calendar can disagree and keep some simplifications or AI memories.

• They are not linked to any active item, where even folder, file or other block can be active in this sense, files and folders belonging necessarily to block listing to be linked.

• Database item, which is activated by block itself, including if it’s file or folder, now not italic as already defined as blocks and not necessarily added here.

• Memory of Program Listing can have active items linked, including their code, visibility settings and whether they require licences of any program or keep anything in

• Web contains Blocks and web pages themselves contain Blocks.

• Aggregator: Something in terms of Laegna, which would be a type of “doemoticon”, such as Ponegate Value (Postion), complex Ponegate Value or Data Content of Ponegative number; in latter cases the search tree must finish with a single-valued ponegator of a few digits which can be seen with R=1 as single ponegative; the exact type of the ponegate might be given or a type understood by some programs might be given, where the type must be guessed by accelerators.• Properties: Names and aliases, summaries, attachments (in a folder block).

• Compression and indexing, cache mechanics: file might allow to autocompress certain parts, others might be indexed or learnt by an AI, it might be registered by search engine for accessibility; the file keeps some record of this. Latency and speed, also potential use of resources such as two copies of itself when uncompressed can be considered.

• Tasks and Missions: here, authoritative processors, web page service providers and users in they communities in internet, could see tasks and missions this piece is doing: ◦The block might have requests: it has data blocks, but those might have no information or low-quality

• Generalizations and tags:

• Reports: How much space it takes etc.

• Headers: Can be index of a text, list of files in a file

• Actors: List of active items is given and they have karma: ◦Where did the solution of one block helped another.

• Interfaces and APIs: Allow to access this with programs ◦Interfaces and APIs are blocks.

• Identificator: Active element, which makes sure different programs, containers and web pages are synchronously seeing this block as unique element or contained in unique element; it is able to use web page access or other named element access to prove with that element; such as cityzen registry in internet.

• Identifier or Key: public or protected accessor might appear, being able to protect itself in local computer, internet etc.

• Templates and Type Holders: Programs which provide type to this file, or it’s templates

• Virtualization: By API’s and how the internal memory is accessed (active interfaces), block itself or it’s contained

• Databases: providing APIs, Interfaces or logically belonging to class

• Laegna Computer Central Screen – In center, there is the big screen. Other screens are the same by the side they are connected with it, but otherwise smaller in the length which appears to outside.

• User can set modes or tasks: “working”, “watching movies”, “connect two text editor windows

• It has metaphysics / retaphysics: if it appears similar to some other variables, common space for AI analysis appears, where R is able to contain both T’s or their generalization, being domindful.

• Subblocks: They know time in several directions, where they are after or before things in their parent block, but after it in the Y dimension of time, where they go inwards in fractal; where when running down, variables report back by circle through V, but when going inside this function call raport, what they report back to where variable was defined or first used in the same instance is the fractal compression of the information, where the last leave gives the content block, and the caller tree becomes the title system or structure of headers and subheaders, each having it’s feedback content available as immediate content of this chapter, not it’s subchapters with local-chapter-style counting also from below, of it’s callers.

• It contains the criteria you have to pass; for example OpenGL structure must be called in specific order, and so the

• Variables can change values.

• A copy of variable name in header treats this as a constant, and is given the big-caps style.

• For the instance when prolog interpretation is turned off, it’s used with proper case.

• Acronyms and one-letter variables are handled properly, so that the small-caps and big-caps word are left and look normal, such as different acronyms such as CIAKGB would normalize – CiaKgb (two famous acronyms I use, not that I would refer to any association with my programming within this or without, as Bruce Lee said – “without” is an

• Otherwise, for example $ symbol might prefix the earning variables, which are to be altered; in case of simple

• Where the value is explicitly changed, if the rest of the values change in relation to their control set, and the implications of it have also changed their values along with it’s

• Logex feedback is generated if there is change in the value: it might be asserted that proper is to give a certain value back to the future value, such as R[global.time=50] = Position might state that at Turn 50 in MoM or Civ-like turn-based computer game, certain logical statement as referred by R must be at Position, thus a positive assertion or assurance, or

• Calendar would register the feed-forward, assign a forward direction to this variable, associate them with past priorities associated with tensors (such as @a in our previous

• Programmers are asked for both proof and practical solutions: by having the Conjectures, both proofs and practical

• Now, including the modules, which are Assuming it, they don’t have the “burden of proofs”: unmet assumptions won’t enter to your list as your program, at optimization level 0 it would need the proof and in optimization level 9 it would fail with error if

• Given the variables a and b, it might turn out that when not a > 7, the assumption is weaker that b > 7, but it’s not implied that a <= 7. We use dot at our implication: “b>7 ·= a>7”.

• Your monetary balanced is affected by this, where if you don’t have free lunch you do spend some money, like 2.40€ for rice and each week some meat, living almost like Buddha in a sense.

• The local answers are mostly wrong, where you don’t know the exact days where the free people serve free food, or whether at your restaurant at lower floor there is some food left by your friend, who owns the place and knows you won’t pay anyway except for Christmas and New Year Eve, when you always come with your grandmother.

• For 5 months, each time the answer is correct: you have 200€.

• If the days would count well, the 200€ would be 40€ wrong, but the precise knowledge of days would make you accept that as the 40$ would not provide quality, but little difference in quantity in what you want to buy, for example some nails but you can basically do with less nails and you would have the chairs, where some random people missing a chair

• Analyzing it’s output in relation to leaving open, and closing things, for example generating a list of answers, if missing the right answer or having the other answer is minus,

• Result: an index, a hash map, different kinds of datasets for optimization purposes, which might reduce levels in your level 0 operations; if they are progressive, yielding some truth when some digits are known, and some certanty when million digits are gone but in thousand years, automatic recompilation and recheck would happen and you would include the quality measure in your program and compilation summaries; so you would make some progress even after your death, which is like reincarnation, not like Louis XIV who did not care at all, but cared of the opposite! So you could be better man than him.

• Constraints might keep it in “Tunnel of Linearity”: Blocks in normal static language, where we are outside the paradigm of being “static” or “dynamic”.

• Dimensionality = Real. This is one-dimensional Real Number Digit.

• Dimensionality = Complex. This is the two-dimensional Complex Number Digit.

• Two dimensional matrix of lines and digit positions solves, if the dimensionality of space is raised in accordance with size of the matrix, and where multipliers smaller than 1 would not keep the proportions, it would give perfect results with whole numbers or given that sub- zero space is growing and not shrinking, with more content in case of higher dimensionality and not merely more space for the content, which is mathematically wrong in case of comparing the spaces like cm^2 based on their simple properties – in Laegna number system, for any operation, for example 0.5 squared gives 0.25, but you need workarounds with real life situations – for example, consider the information content and number of digits needed for this range, and the case that two-dimensional 0.5 is larger and not smaller than one-dimensional 0.5; Laegna proportions use the operations often in accordance, such as having the unitary dimensionality and knowledge of the real size relations, or using the R property of Laegna numbers that numbers with more digits are larger, on both sides of the whole number and subwhole number separator of positional numbers guaranteeing that when you multiply numbers smaller than 1, the R would grow according to their dimension and you assume that while their face values are equal, they now do a longer sequence of influencing the number positively. Similarly, the dimensionality of a number means: in proportion to each digit, digits it has upwards and frontwards are equivalent even if they differ in power, and backwards and downwards digits would flow with the same speed each (in some cases the finite position X would be 1-based, where the infinite of Y would be 2- based, and the numbers would map with using positional relations in a way that each digit is in separate space and each number of same size of matrix, what you can write, would be different based on using A’s and E’s in it’s position separately – given it’s size, one would account for finite and infinite dimensions being separate dimensions even if having equal value, and solve real-life calculations). We can have any-dimensional matrix. Simplified reading of the matrix simply continues to infinity in each direction and averages the

• Knots could be solved with space complexity, as the next digit at it’s negative values with last digit with positive values repeats the behavior of frequencies – for example number OE, given the base-2 system which does not have E directly, E would move to previous digit and became A, where it adds 1 to O which is -1; the result would be U.

• Matrices of space-separated numbers (where space is not referring to final U): take each number, it’s length is it’s power and it’s size is it’s value – statistically, take the average with power relating to statistical probability in a way that the influence of these numbers is weak.

• DimSpace: Spatial dimensionality is 1 for only real digits, 2 for complex and real digits, where only complex digits would not give us proper numbers – we might distill them from resulting numbers in additional operation to have the core very simple.

• DimWord: Word dimensionality 1 means that we only have digit positions and their unknowns as spaces, numbers will be written without a specific notation. Word

• DimLines: Matrix dimensionality means the number is on separate lines, 1 or 2 mean one line or several lines, where bigger number might express more complex dimension of numbers. We might have some variables to assume certain, small numbers of lines or accept any.

• r: Small R maps the coordinate system distortion and other point size manipulations of space into R, and the digit space we use to represent it into T; in logex value r would be actual space direction, and r’ the r prim would be the projected direction or how many digits we use. We use r in our context to allow certain number of digits.

• f: This is the virtual space of digits – each digit outside r is rather influencing the previous digit in sequence. This might add to number power, so that the resulting digit is more influencial with two values approaching the same direction, or it might not in which case the overleft simply affects the number; those two methods should give same result in

• 2 or 4 is the digit dimension: for example, base OA is 2, base IOAE is 4, Matrix is 4 given

• Frequential dimension: Use 0 if U and V are not accepted, 1 if U and V are accepted for

• Digits=1: The single-digit representation, where decimals give 1-8 at specific digit, one-

• Digits=2: Each digit is represented by R and T, R contains the Complex and T contains the

• Laegna: Use letters for numbers.

• Latin: Use numbers for numbers.

• Sign=2: Use only positive numbers.

• Sign=1: Use positive and negative numbers.

• Polar: use minus and plus, with minus count the numbers from up to down. Decimal system

• Linear: numbers read always in the same direction, both plus and minus.

• Caps=1: We use capitalization for extended range of the numbers, where + and – when used

• Caps=2: We use capitalization for plus and minus numbers, where the small caps digit is

• Caps=3: We use capitalization for digits after the dot / comma, and if Caps=3 plus and

• If we do not use negative numbers, “+” is also not used to show that the number is positive.

• Instead of using discrete numbers, we can have float or bigint for each digit, containing the

• Dens, generally, divide the number digits into two binary components; most trivially, for IOAE, we know that IO is local or global wrong where AE is local or global correct, here R knows whether it’s local or global and T knows whether it’s wrong or correct; alternatively, being wrong would switch the value and where one den, the R knows whether the solution was initially correct and later accepted, or initially wrong and later corrected, where the T knows whether the correct solution was to be correct or to be wrong in the first case – we we realistic and chose one of the two. Basically, we can consider each R and T combination – each two-bit combination to contain complete information about four-based digit – and then see whether they can be solved by other combinations (while binary has number of combinators or truth value tables – as much as 16 with two and 4 with one input, 20 in total for basic combinations – we can emulate this with only not, and and or (Bertrand Russell has analyzed this), getting the trivial three of programmers; with all these combinations, much like choosing not, and and or from 20 combinations – 2 from 16 and additional 1 from the 4 combinations; for example most trivially we don’t need the combination, which is opposite of not and simply leaves the one input parameter intact, returning without change – this operation is mostly used in clock frequency synchronization where in high-level languages we leave out this operation; if we would assign “U” we would say we don’t want to have any correlation, where this could be a meaningful operation – introducing an error in our program if the variable is not fed back *with the same value*, as found out by code analysis or by AI analyzing actual relations in addition to defined relations (Turing seems to emphatize in Halting Paradox that what happens if the logic is not known, in real time, but only in essence to get the right anwer; rather, to get even worse where we don’t have the code, it relates to the task at hand that we need an AI solution to figure out, if the data you get is somehow based on your results, or correlating to same source of data in a way that it would be metaphysically and relatively based on that, a claim with equal meaning in many situations – whether the owl is singing for the same reason at each morning, why the children come to school each morning, which has tautological structure mostly the same with the case when children are coming to school because an owl is singing, which might still not be true; it might have to do with general cycles of the nature, which might affect the probability and usability as an example of correlance in the bigger scope; sometimes we only need to know, given the actual environment, can we be sure that when the owl is singing, the children are coming to school, or vice versa – this can have a logical

• We are not giving the number type, but asking a question, which would hold for any type – we should develop a mathematical analysis, which gets partial solutions without full information; this is also the principle of our logical information that if different cases give the same solution, we would get the solution without getting the case – then, we need to emulate this to AI where it does not have direct information of what operation is doing that.

• Implementation of U: our AI might have internal support of U, where it has several methods:

• In addition to extreme Z and Y, frequencies of whole numbers, by using higher-precision digits such as writing one digit between brackets as several digits – AE(IO)EE would mean the third digit is IO%, the value of IO when we stretch it to match one-digit length; here, U and V precision would be contained; using infinity sign after “)” we would get infinite repetition frontwards, and using infinity sign before “(“ we would get this repetition backwards; at last positions of digits (we assume that all those infinities fit into our octave, otherwise we might use two infinity signs to mark that it’s repeated infinitely, with complete length of space or time would ideally be two times infinity times infinity, decimal number 2 followed by two infinity signs in proper writing of Laegna – this, more probably is equal to two times infinity in infinite power, which might relate to other properties of a number but is not very wrong in case in our mapping it would be rather power of infinity in given number spaces than actual operation you do with it; we imagine that there exists a point between 4 and 5, we use 4! is a limit value of 4 growing upwards, whereas for 5! we don’t know if our result is going to “grow downwards”, why I use 48 often to mark what would be marked with 58 in it’s kind of literal or trivial sense – the latter might happen in some computational mathematics, using simple and strict definition, but is not natural language construct fitting the properties and anomalies of actual infinity, where we don’t think in box; as Laegna mathematics involves larger space of operations and values, the degree of intelligent decisions comes closer to language and is less a primitive combinator of very simple definitions, which we would expect from having less possibilities as in Latin – we assume something intuitively or have very long description of what we mean in current moment, current context; rather we suppose that while discrete definitions might exist for scientific and official work, major part of their basis can be reverse-engineered from example and not it’s whole introduction, explanation or acquaintance with references or referred materials), repeating infinitely but backwards, we assume the case is rather equal: when it starts from infinity itself, repeating backwards, it would be equal to starting from here, repeating frontwards, as it’s in definition of Laegna that infinite repetitions still synchronize the local

• U precision can involve:

• Create a good design, on which the iterations, project branches with different developments of iterative progress, and the AI understanding of code assistance would be needed.

• The AI understanding means the case is at least examplified, if not generalized for an AI, and the basic theory of generalizations of more trivial aspects is given. We need to train AI as our code assistant to have our theory and to be able to integrate existing work, such as frameworks to create programming languages and provers, and relations to existing systems.

• Descriptions of the language and environment

• AI Student: We simulate the questions and answers for AI system; for example given a generator we describe, which generates examples based on given rules, we know the final state of the AI and what it should have learnt, and how to verify it’s success based on it’s behaviour: for an AI learning to estimate and measure another, possibly simpler AI, or to check the simple AI system itself, we describe a logic system, where we are able to deduce the right answer, not only the optimization, but we check a system which does not reach this right answer based on computations, in a way of logical machine, but trains it to it’s nervous

• Calculator or operation capability of a language or an AI, or calculation abilities and understanding of the human; Calculator, while it’s a separate tool, is also a purification of common and shared goal or ability: Math problems with solutions are generated, with tasks and solutions being rephrased to fit calculator input and output (Like Q: 2+4; A: 6).

• Programming language and it’s execution result: (Like write a complete program to add 2+2, either snippet or with all the imports etc., and check whether the result is correct including the program specifics, for example it might add “> ” in the end, expecting user input, or it might follow specific formatting rules); the AI check – inputs and outputs, which might make sense for an AI, for example a Q&A set which is complicated for user, and not having concrete set of rules for a program, such as analyzing given business data to score it from I to E in comparison to given purpose, mission or ideal of the company, where user won’t work with 5MB file of numbers, and a program might rather apply for specific criteria than general assessment unless it already relies on AI functionality.

• Finally the user:

• Set of tensors, tens and programming constructs form a program, which has AI assistance included and is not strictly following the code.

• With the real world tasks for this code, it’s measured if it fulfills them properly.

• The AI would learn, whether different ways to resolve the program are good, or whether it needs a better concept, or whether these tasks should not be resolved with this program.

• The mathematical task is resolved, where the series of operations, structures or mathematical algorithm is known; this is resolved into theoretical structure, which will contain the algorithmic solution without exact semantics and language rules and paradigm of

• It’s known which parts of the language we need: it might be complex language, but locally only a given set of it’s possibilities, constructs and philosophy is used. For example, if laegna logical language is processing the logical things sequentially, looking a specific subprogram, it’s expressions and it’s output, we might not be able to determine whether it’s logical or imperative language – even the case of “2 + a = 4”, which is rather trivial in logical language, could be implemented in imperative language with a being 2 as a result, which is convenient feature.

• For a language design tool, we would extend it with:

• When we know our partial set of features, we readily have partial selections of documentation – we do not know the full language, but with given features, the documentation would likely contain something similar to given selections of the documentation; the AI would learn to navigate such “partial documentations”.

• Failure cases – for example, implement “!” for limit values of digits, and for end-of- sentence, reach the problematic case and resolve, how an AI would be able to resolve it automatically, how the language design would be reconsidered once such conflict is found, and how one would look for answers, which involve both constructs: for example numbers could be written with special marks, sentences would end along with the line while numbers would need another line feed, or the ! would mean a different thing inside operations, for example “X = ae! + 4!” would require us to understand different solutions to problems: if X is variable and ae is number, then why ae is not variable name or why X is not the

• Some environments would integrate AI capabilities with meaningful fonts and styles, so the number ae! would be given a different style or font and thus recognized as a number; normally, in Laegna, numbers are separated by a font – while determining by style is trivial, where style lacks meaningful information, but is given by physical properties such as font, color, style, context and position of a number, an AI or the programming language would detect this in many cases. While in past it was a bad habit to design such mess at all, currently we look for ways how an AI would earn some money or score and do something reliably, which we were only able to resolve at cost of complexity before. Here, we can generate complex cases of language use with less than strict and perfect rules, and determine whether an AI + IDE + programmer, definitely including the language, is a combination of 4 powerful enough to seamlessly integrate the solution set of given problems.

• Instead of Test Group and Validation Group, you consider this as a rather special case; we are directly interested in mathematical basis about how those two would interact.

• Given all the variables, probabilities, successes and failures of the estimation; rather we reach the solutions involving U and V to answer the general case of unstructured statistics, unstructured input and unstructured trials and errors of the scientific method. This is our approach of Laegna Statesc.

• Either an “odd number system”, where the r and R, the coordinate system, the computer is capable of containing numbers with sub-frequency precision, where the calculator or computer wont have very limited set of statistical values, but rather each digit contains more information and the number is asymmetric – normal statistics of U would give us a set of segments we can define, and like an R-Tree they would be at specific locations; if the variable is inherently more complex, this is not the case, but it has more values.

• Laegna Discrete Number Analysis: given the set of statistical features we are interested in, or a set of possible statistical distributions, we need to define all the numbers in such way: given the unknown-zero invariance of number values, each number should map into probability results as if U was zero, which would be the most precise way to map the numeric alternative not including the statesc. Discrete number analysis means: we take whole range of our target possibilities, and we map it over a set of discrete values, where with digits we never have actual continuous value, but only it’s either round or symmetric representations, unless they are pointing to whole or rational number which is the correct result – for example if 1.(0) is true, an “irrational” by form but actually just having infinite number of zeroes, the “1” can be used referring that this is an actual whole number. With more typical, statistical range of values we need to map the discrete set of number so, that what is the closest to our set of discrete values with particular meaning, maps the balanced range of given values in the best way.

• For example, with discrete analysis: if one set of number is more precise, but other set of nearby values you can assign would get around some imperfection, which is introduced over time, we rather preserve all the theorems and known cases, than searching for literally most precise local results by their numeric values. For example, map that “E” is perfect future, “AAE” means winning in the end, “AEE” means winning soon, and “EEE” means perfect growth; “AEA” for example would be temporary success. While, when we have one specific line of time, this does not make sense easily – if we have the whole set of our timelines, and the comparisons, we can find discrete answer of complex timelines for income and expenses, where comparison of the results is rather discrete, complete and quite precise given we only do real operations with three letters – the questions and answers would map so that our decisions are rather correct, while this is topological operation and precisely, in other case “winning in the end” might mean much more, much later than for small company.

• Conditionally, it has a condition S – a frequential system we are optimizing or analyzing; S means that it holds in a local condition, being a little unusual use of S but not given that STR is a standard opposition and rather we stick with something known we plan to research further, and this is our paradigm – exists a paradigm, where conditional is S.

• Positionally, it encodes a list of possible input values in positions of digits, whether the digits are Tens or ranges of possible frequencies of the condition. Each frequency reflects it’s set of possible values for it’s input variables, or they can encode the selection of variables themselves in rather dynamic case, but we are not interested in this right now – you can analyze your specific case.

• Frequentially, by a digit value or Truth Value, for each Position, there is one return value set and for each possible set of return values, it can assign a frequency – value of a digit, where digit is either ten, or complex digit might be formed, where multiple tens are combined and an index set of states is introduced; for example we might allow frequencies “I”, “O”, “A”, “E” and “EE”, where we say we have 5 digit values or frequencies.

• Run forever, naturally.

• Yield values so that they can be assigned to iterator.

• React to “if’s” inside, so that they can declare the conditionals for themselves.

• Accept “break”, “while” and “until” to stop them from running infinitely.

• If they run infinitely long calculation, but do not report each pass by producing side-effects, the loop must use proofs and conjectures to stop; the resulting variable might contain “Z” is

• Where two infinities have relations inside their variables, we can do operations with resulting infinite numbers. If not, the Z or Y in one or another case, given the unbound variables and other effects, even trying to calculate further than the basic theory allows – if there are two unbound infinities, where we know the local variables precisely but we cannot give it the relation of the scopes, the solution is such: unrelated infinity 1 might return variable a with unit A, and the second infinity might return variable b of type B. The result, then, of multiplying a A with b B, is a * b A * B, where the answer is a * b and the unit is A * B – through interaction of those variables, we can assume things about relationship between A and B, and the extent of our precise value system might grow, but if we are interested in Logecs value of Ponegation of a * b, we just use the literal value and it’s properties, perhaps with some trial and error or calibrating until it seems to succeed given our intent. This is given in theorems and methods of infinities, where the basic method is not to research their exact values, but using heavy U-notation, Prounetons (where U, as Logex Truth Value, is called Uneton, Ro connects it to scope where we rather research the indirect relations and not concrete variable-value mappings, and P is supposed, assuming upwards

• We have two Trues.

• We have two Falses.

• We run into truth-teller paradox, where we have several correct answers. The paradox is: choosing either second or third frequency, while we guarantee that the result does not depend on itself, we do not guarantee the non-philosophical case of choosing either 2 or 3, but without considering another part of the program can optimize based on this.

• If the frequencer would not be equal to 2 (or equal to 3), it would be a simplistic solution and many people are happy with this – in DL examples I’ve seen, often for example analyzing the handwritten number, getting scores like 0.3 for 7, 0.31 for 1, and the rest for other numbers, where 7 and 1 might be remarkably similar – it would choose 1 based on this little difference and it’s constraint to choose at least something. Instead it might require user to somehow clarify, or consider more of the context, etc., not necessarily for handwritten digits, but for different use cases of frequencers.

• Whether, if a selection is not true and not specified, the other selections being false would select this one. This is whether we do deductives.

• Wherther, if a selection is not false and not specified, the other selections being true would consider this one is false, or run an equivalent scenario. This is some special case of inductives, not running for what we cannot get.

• Whether we build a probability or run for specific case.

• At which extreme we could see that it cannot hold, with certanty, which looks like deductive zone.

• At which opposite extreme we could see that it can hold, where not having a deductive turns it rather to inductive.

• At which value range we can confirm that it’s of variable value, or real random, which is dinstinct from not knowing – not knowing means if you use the feedback cycle or logic, you could optimize for best answer by clarifying the answer towards some specific value; the value being actually random means that actually leaving it open with all the

• We are training an AI and it makes guesses based on input set.

• It would guess that output set is not in a list given values.

• It would guess that output set is in a list of given values.

• Solving the non-probabilistic cases, where trivial rules are overfitting, it would see it’s not the non-probabilistic case, given it’s power and the known input data, as probabilities are

• Whenever our system decides to choose between a and b, it’s wrong in half of the cases, which fits the probabilistic distribution.

• It cannot disprove a and b, since the same happens when it tells it’s not a or b – it’s equally wrong so the choice between these opposites does not raise the value of the solution, or it’s probabilities.

• So instead of particular feedback, it would either communicate the possibilities, or it would get the backpropagation algorithm right if that one would rather create the gradients on it’s probability distributions, numbers involving U, not the direct answers.

• Since in Chat, the user gets one direct answer, but we are able to communicate the

• Given things we don’t know, in many cases we don’t even mention them in every particular case – we manage to live well but not mentioning we don’t know, for most people, exactly what time we are going to eat tomorrow, or go to sleep today; even if we do it’s not very certain. Still, we have no problem in planning of food and sleep, rather we talk in

• This, because while we don’t know particular times or for people who plan times, the actual type of food or how much exactly we eat today – we fail in any of these, the particulars, or we fail in keeping this strictly; rather, if we really eat exactly by calendar, clock and definite knowledge about right food for each day and each time, this would start to disturb us – there are really things to consider, happening randomly and every time, such as being really sick or having a special event at this day, when we should eat; in my case I have some times to eat, but it’s not a very solid rule to follow them precisely – for example today I did not go to eat as I have other things to do, and I did eat something at home at different time; that much about the calendars even in places where you theoretically got this time; even if it’s at 4’o’clock, perhaps it happens that you go to toilet and it’s actually 5 minutes later.

• So, where we know the actual map of inputs, outputs and probabilities: we can have 100 dimensions, but with probabilistic relation maybe 80% of information would not map anything in particular, but provide with theoretical problems. We can find a projection, where the words, dimensions and concepts particularly ignore certain aspects, and we do straight implication from what is known to what is known, perhaps having only some easy- to-describe probabilities where they help the calculations on their own – such map, with correct language and dimensionality mapping, and some advanced math I would call “transformation” or even “transcendion” (which means you don’t have much left of your original system, but you found new simplicity or clarity or new best solution in terms of such); for example in case of throwing the dices, you might state “I get the number I get”, doing different theorems such as despite not knowing whether it will be 1, 2, 3, 4, 5 or 6, you definitely know it equals to number by which you are supposed to move your piece, thus you naturally know in advance the process of playing the game, even if you lack any particulars – getting the number you actually get, following the rules by this number etc., is where you could map your estimation of dices, measuring the whole process many times; the cause and consequence might not give you exact number of moves, exact distance of moves, but if you follow it to the end each time, indeed it gives you many relations within, so that it rather looks like a stable system – men playing a game of luck, such as playing cards or dices, where you are normally surprised if something uncommon happens, you see them constantly getting different series you never got in your life, or having sets of cards highly unusual, but you are not particularly surprised – you are surprised, if at all, rather when they win big; but normally it’s not surprising that someone wins. This means your theory is quite complete, for example you might assume the game is over in half hours, where it depends on many random events, but you are still right – rare case where they really stay falling back to beginning, which is rather improbable and consistently so.

• From this example: you can solve it by philosophy.

• Conditional: Condition, input and output is given.

• Integrator: Given a set of frequencers, it will map the possible solutions, unknown cases and impossible solutions, creating not the solution – where we got both liars and truth-tellers paradoxes in interaction of the system -, but for the purest case we define it implements the logic, so that contradictions or harmonics would appear and we rather have a true frequential system with harmonic and destructive vibrations of the logical parts.

• Position system or Input Set: each possible input maps to one frequency of the system, a spatial frequency as those are considered rather equal by face value, without an integral direction.

• Value system or Output Set: each possible output maps to one frequency of the system, of two-dimensional frequency in this case by a view; these are rather temporal structures as the higher, or given a goal, goal-fitting vibration is rather better.

• You have 20 functions, each for separate business case.

• You have input map, where each function has 4 inputs and 4 outputs, and now you are free to map outputs of each to inputs of each, for sake of simplicity.

• You have 100 tensors, which are able for boolean values: positions of tensors determine the conditions by which each function would resolve it’s solutions, and they use the tensor values internally, these are not inputs nor outputs – the programming system, automatically, would optimize them on your behalf, or you write instructions to optimize the constructors; by these instructions you don’t implement a goal – which is given by frequential system -, but you help the system to resolve the given goal; thus, each line you write is meaningful – frequencer system is the framework to optimize, and programming the tensors you and the

• The result: the solution sets, which yield the best results, have implications, inductor is preferring them; where the solution sets, which do not fit, have explications, deductor is not preferring them. Part of logical program might not give a solution, where you might include the goal to have numeric solution (follows); by having a frequencer, your program is having more logic as a logical system, not definitely a final solution. Certain clauses would now give contradictions or definite answers.

• Constraints: Tensors might have constraints, for example tensor set to layout a document knows things like aligned positions of words, leaving the box for image empty of text etc.

• Tensions: Aligned with frequencers, they get tensions; for example stylish layout is not so strict constraint, but made of many tensions.

• Inputs: A tensor operates within some given context, with some accepted values; it is aware of the flow of the context, for example moving the image would reposition / “relayout” the text.

• Outputs: given it’s degree of freedom and limitations, tensor would reposition the words.

• Acceleration and inertia: tensors, as the preferred values fluctuate slightly, a good position of noticeable button would even depend on where you look – the button, which simply moves under your mouse disabling any other function, to be “easily clickable” won’t do; rather there is an inertial system that while best position is important, the button, once appearing to a position, has certain tendency to keep the position, along with it’s general properties. In a file, you must define a “random number” between two numbers in other place in the file, but depending on the case the number would never change unless it does not fit to it’s range or domain, or it would be recalculated if the domain would allow for much better optimization and it’s not only random.

• I: It’s not definite that the frequency is true, in which case it has “value in infinity”, where we map any unknowns under the “infinity” umbrella term.

• O: Given frequency is definitely false.

• U: Given frequency is definitely unknown, this means producing unknown output, we get 50:50% (U) distribution of True and False.

• A: Given frequency is definitely true.

• E: It’s not definite that the frequency is false.

• V: Given frequency is definitely resolved, this means given the position of V, it’s relations to the whole ponegative system, the result is correct if the letter exists, is of letter length (R=1 meaning that it is a digit), but the correct result will map the rest of numbers it belongs as fractal and computes the average – if the random behavior is canceled otherwhere, V reacts in a way similar to infinity: where the number is straight in infinity, it fractally repeats it’s value to each direction and dimension of infinity, but *does not* count those as digits, but as context – the number simply exists as if it was value slice of such infinity; the number, indeed, associating to V, repeats it’s value into V the same way, but also including the digit as part of it’s value.

• For real, each Laegna number would depend on it’s history and plan of computations, and create knots every time; it would be noticeable, which numbers were modified; for example, by getting new hope or resolving fears, you might get the same numeric advantage if you do that in precise amounts for both; in one case, your number is better by solution to low frequency, in other case the solution exists at high. You might not be interested in this, getting many results to turn this into simpler number, but you have a lot to do with this – for example, Zin, Zen and Yen meditations resolve different frequencies, and Jung said positive and negative frequencies need to be harmonic system, not that you prefer to solve the positive and not become conscious of the negative, in which case you won’t survive – something negative happens anyway.

• Each frequency grows, as a fractal, into deeper frequency levels (downwards fractal, U): for given four frequencies of a frequencer having values for IE range of 4, for each value it also has 4 frequencies (for example with 6: it might be false that this is E, but not immediately true that it’s I, nor even that it’s one of IOA – by deductive, not being E would give you IOA, but you might not want so strong deductives as you are not sure that you are running an ideal case of a closed system; in practical math you need some probing – for example, maybe the “not I” just gave an exception every time or the system did not fill the table at all, or maybe it’s mapping to E as a very special case where you are interested whether it’s I, O or A actually, not only by deduction); where deduction seems extremely strong, it’s not really better than induction. Now, you can have value U at two frequencies O and A –

• As given in the end of last paragraph: V is growing outwards, where your whole system would be wrong. By V digits it basically “grows the fractal upwards” – the V digit, even in necessity to execute the function at all if you can somehow do this utilizing in-block conditionals that despite calling your function, it might not be executed as if it was in the if block; V means that you utilize the solution as it’s given elsewhere.

• I am telling you that this sentence is true.

• Usually, it’s easy to resolve it, be it good or bad – rather, things you get by this paradox, you might do them all, more or less depending on your logic and interpretation. Rather, where the problem resides – you might lack any reason. It’s hard to see the fallacy of doing unreasonable things, but in this paradox the Posetives are perfectly exposed in this sense; the

• The paradox, indeed, does not appear if you do have a reason to act in self-fulfilling way; the case is that the thing might fulfill you – in reality, it’s rather that you have other good reasons, more often than not if the selection is simply good.

• The system has to resolve a frequencer, which can see the probabilities.

• Input and output: instead of exactly checking the literal output of your system, the probability output will be checked.

• In simplest case, it won’t separate the probabilities, but the frequential function calculates the long-term frequencies; the series of input and output flows must fit, where more local fit (T) is more intelligent and gets more score, but the long-term fit gets a basic score, and failure in long term is worse than not awarding some short term success; indeed you need to balance the optimizer given your goal, and whether or not the short-term success has fast accumulation factor into long-term opportunities outside your measurement; sometimes earning 100€ now would be better, given you invest, than secure 10€ each month after a year has passed; where you might also include your investment plan. It might be your problem where you are unable to wait, where you program your system for rather sensory desires or easy life, and it’s hard to convince you then; also maybe you just need to survive until the next year and resolve this short-sightedness in the process; often such choices are still problematic – the reality might not contain the solution as given before, and is rather a complex dynamics than single solution you have to achieve.

• Consider: you have complete logical system, where and, or, etc are mapped to actual probabilities, or variable probabilities, and in response to any request you create a frequencer:

• Logex aggregator: this is ponegative value of the tension between local/past, or total/future solutions; for example True in the past not modified by the future might map to Position A, given you are interested in changes (Posetion would have downwards accent if asked), or Posetion (with upwards accent if asked) if you are interested whether the value arrived from the future; it can also be one or two digits, where first digit is base-2, containing the given solution, and the second digit is arriving later, containing what happened with “infinity”. For this reason only we won’t add any letters to Laegna – those solutions are topologically the same given that we really see 4-dimensional fundamental system, and while we can count more dimensions here, such that first two solutions indeed include at least one additional dimension – rather, we won’t understand more but less, if we think this has to do with fundamentals of logic or worse, of logecs.

• Goal: whether you want to get True or False. Also, perhaps you only want an aggregator: if you want false, you assign the aggregator with “not”, for example if your variable is “sad”, but target is “happy”, maybe your aggregator is “not sad” where it would fit with “sad” being “false” without setting a negative goal.

• Tensors: either a list, which affects the goal and gets tensions from here; or a math operation: for example a, b and c being tensors, “a and (b or c)” virtualizes them into single tensor with face value – you can show the optimization state – while it must involve

• T-frequencer: [O, A]; positions True and False, of this Den-frequencer (2 values not 4) mean outputs for values True and False, which will be tried.

• R-frequencer: [I, E]; positions True and False, where this is also Den but made of, are the inputs, rather outputs of T-frequencer or where the same combinations are tried.

• Ponegative value is what happens when comparing the two. The latter is thought as being smarter – it reflects the long term consequence, thus approaching the infinity by it’s one digit separating the I and O (T and R, past and future, where human will do A and O).

• From future blocks, you can only change the Ten into either “I” or “E”, having access to R- frequencer in other words.

• From past blocks, you can only change the Ten into “O” and “A”, having access to T- frequencer for that purpose.

• Tensors get the feedback: they fail or succeed. You can invent ways to have more complete bias, but logically we need to describe ours to the computer; if it got these relations, theoretically it has all the information; this means after having this defined, what follows is rather proving your values than setting the initial task – simpler, more relaxed part of programming, where you can get useful feedback as much as your machine is able to support you by all it’s means; if you don’t have the definition, you rather work alone. So, with given Ten, Tensors are defined but not combined – combinations can be complex.

• While only the future blocks can manipulate IE, and only the past blocks can manipulate OA: where the execution is sequential, the information flows in two directions effectively, and while I wont describe the details (you can even have simpler version depending on the paradigm you choose): for an IE block, the last OA block is in the past, but the next OA block interacts with IE block after it. While this can be solved in numerous ways, I have

• Additionally, it’s interesting how you map a classical Logic system into umbrella of Laegna, which would react to posetives, fuzzyness in infinity, and any logical bias Logecs is designed to avoid – for example, such binary system should not be apart from life, and it could meet some ponegatives in it’s flags; for example, while there are no direct logical definitions of a lie, of a fake, of difference of not wanting or failing to get; each of such examples is made of many special cases: still, it’s easy to map to things like “is this sentence true?”, “is this better that it’s true/false?”, where with these two bits, we can do binary logic.

• Notice that if you think computer is binary, you might be not very precise: conputer is algorithmic machine rather able to emulate all kinds of discrete systems, such as Game of Life, and not restricting you to have them make any sense of binary logic; you can create completely illogical systems given how they represent their values, rather by creating the response to stimulus, abstract structures of memory and processing, and nothing is limiting you to having binary relations between your variables, such as one being false when the other is true – rather you can implement a logical system, but tell it to accept a paradox and it would do this as long as the paradox does not enter it’s circuit of decisive logical values, such as the bits by which it determinates the program given a logical fallacy where it expects logic. This is almost as true as the fact that you can photograph a surrealistic image containing something not possible by physical laws, and map it as a texture into an object in your physical simulation – it would not detect anything, nor does it want :)

• There is difference, whether a bad thing is made a little better, or a good thing is made even better.

• Between impossible and sure, between deduction and induction, there is a long list of questionable, even random values.

• In Laegna, when you do operations – multiplication, division, addition, subtraction (list 4 but count them all, like in Laegna if you say “yes or no” there is no definition that it would not point to each four; the two are not resolvable without the four) – it might be memorized, the whole process, and complex variable would contain each transformation. It’s easy to notice that the numeric value would be the result, while in the memory, you might have a variable, which is existing in complex structure and would notice the differences, for example avoiding a trap is not comparable to true freedom.

• Sometimes, digits in a number are considered as if the number is whole unit, there is no space between them. In yet lower octave whole words must be separated by infinities. In many cases, where the operation would leave no difference, and things are continuous with no breaks, the system would consider “zeroes” as existing objects, infinities in lower dimensions, and map all these dimensions; for example for 4*4 and 2*8, the answer is the same, but multiplication itself is a “zero” and the system, when asked, would trace back and notice the difference. You can do more analysis.

• Knots perfectly contain the multidimensional frequential system.

• Such number is rather self-reflexive, able to understand when, from it’s own value, it implied a different value; the complexity of polarity, especially utilizing V to pass the cycles not just linears (li-near, where li is a step on the road, li-near would mean particularly nothing to use some Laegna wisdom), so you are able to map ^T and ^R, Turing and Luring (Raring) paradoxes; in Laegna the solution set you might call Tareng and Rareng (“areng”, in Estonian, is development or acceleration in our terms; “reng” is positive “ring”; “Tu” is unknown after theorem and “Lu” is that in flat, Zen unfocused system calibrating to infinity – the number is so flat that your local situation appears in regards to infinity, into the same number space, an effect I call “Mind”).

• Such number should be able to map the multidimensional frequencer with one number, with all it’s properties, turning variables into components.

• It should be able to consider the history of a variable.

• Why it matters? While you might not want to randomly map them, given the effort: the resulting piece is a mathematical number, having the basic operations defined, and it has a number form to express it normally with a few digits; basically you are not working with them separately from your other flow of the math; rather you can add such features to your system where needed, where redesign is rather beautifying your code for visual compability than any serious refactoring, which would disable such complexity from our common circles.

• I gave you that: IOAE form positive and negative numbers. Negative numbers are made of I and O digits, and cannot contain A and E digits. Positive numbers are made of A and E, and cannot contain I and O. I gave you: if you still want all four digits, you can use simplified system, for example E at second position of the number (from right to left, as this direction matters for numbers) means area of 3, 4 for the first digit; A positions the first digit to 1, 2 – then, O must position it to -2, -1 and I must position it to -4, -3. Now, have OA – despite A ispositive, where O, in opposition, is negative, in this case the value is -2 – where O gives the last letter two positions, it will select the lower one, where A is smaller than E and OE would be -1 (notice we don’t inverse any values, where based on decimals, it’s the first thought that why OA is not -1 if you swap A and E below the line – rather, the values would not make any sense at all if they just randomly exchange their places all over the number, and you would switch back to simpler decimal system).

• While this system is simplified, it does not account for curved number spaces, such as positive and negative numbers, where negative numbers are inversed first by their

• Now, with knots: in case of , our example: consider if we are switching the space itself in various ways at different number positions, is a complex space of some kind of curvature; yet we know all mathematical properties. By this, for example, choosing the right

• I don’t want to avoid this: we have to live to the future and this means accelerative coordinate system, where this is called “D” factor where in accelerative space, the whole would be measureably bigger than the sum of it’s parts – talking about our little activities in grand accelerative space of society, little “d” factors happen within every step of us: accumulating to society, the society is accelerating, and when people might not do much more than us to achieve this effect, coming back each of them then has a little accelerative factor relative to their contribution.

• The ball, basis of Laegna system, does not fail reaching the infinity: one can think, while with the straight line it’s hard to understand where it reaches, with a ball it’s rather clear that the line would continue indefinitely, or the ball itself would fail any logic; for the line, it would fail it much later. This is rather trivial case, but you can see what I mean – the actual reason is that acceleration simply is there, by mathematical synchronicity fitting each kind of theorems which could utilize different paradigms and axiomatic systems able to check whether it’s there; indeed, each of them given it’s correct, would give a different reason, but fit the correct answer: this way, mathematical synchronicity is a deep truth, even if it takes some more steps of logic to see it’s rather impressive.

• Utilizing the Second Spatial Theorem of Infinity: for the whole number space, analyzing the examples of projective spaces, one can see that whatever value you give to digits, they are not necessarily contradictionary: for example in sequence 0.(9), would you have actual “10” instead of 9, still running it in 9-based system where 9 is the upper limit of normal system (preferrably you use uncompressed decimals if you want a perfect case, but it holds in normal system as well); when you “zoom out” to slightly accelerated space – what seemed to be a limit, just enflattening numbers to be equal, not depending whether they are big or small; just adding one infinitesimal to 0.(9) you would get 1, because one infinitesimal got removed by rounding the number itself to 1; instead, you already get infinity – with one

• With the RT transformations, which happen subzero (below threshold) and below zero (minus); you can analyze the actual number space curvature: for example, with this, you can rotate the digits; you carry the same effect above zero – and it’s quite a neutral

• Knots: in advanced case, you do them downwards comparing to subzero, and upwards comparing to above infinity curvature: integrating all this you add complexity, but the solution is more complete.

• Where you can turn the numbers, you can also have bigger and smaller numbers. Those have coordinate transformations – they map to slightly different space or curvature.

• Given all this, now you can also smoothly move them (pan), not only by one digit, but by given distance.

• Given this, and all the resulting relations such as analyzing, what happens in the real space at the same time, and how to back-map in reverse order, etc.; the computer would have extreme ability with numbers.

• Laegna numbers easily pass something like fourier transformations. Given the number, the hidden preciseness could be huge, but the visible number is still a few digits – what happens, for example, with large tensors and their even exponentially larger weight matrices.

• The number can be mapped in a way that pixels on screen are actual digits, with positions from left to right and frequencies from top to bottom. With preciseness, it’s rather trivial operation and it involves that each initial digit, visible as small number, is a square in this space; or you can stretch it to be of number shape, in which case each number digit maps to visible area in your frequential map, which is essentially the same you would see on screen of a decent music machine, where it’s either simplified or not.

• Here you can zoom in, zoom out, and pan.

• Normally, two dimensions are what you need, but there are no reasons why you should not have more dimensions.

• We are going to use this to learn AI weight matrices and other information.

• Within Laegna, a meaningful matrix has single number representation: what an AI did learn, you map to the screen. This is rather the actual value than anything invented: matrix has just this meaning, and this meaning maps to just this number – mapping all the matrices and doing the operations, you lose rather the precision, but not the essential idea.

• Within Laegna, you can prove that n-D multidimensional system is basically always mappable to 3D, except that with given amount of information, you cannot achieve a perfect shape with actual symmetries – rather, the result is distorted. The reason and appearance is the same as mapping sphere to a square – while getting all the pixels right, you get it distorted for lacking some dimension, not for lacking a basic geometrical space where such thing would happen. The same way, mathematical space exists, which maps any n-D to 3D space, where it’s not so flawless into 2D, 1D or 0D (0D does not contain coordinate space, but a single dot could connect to itself through various dimensions, so we cannot exclude that, rather by Laegna math, even minus-D would still contain some information, as we could zoom it appropriately and see that in absolutely infinite space it’s still able to map into

• Mapping such number, we see that to keep it a straight line, it would adapt the frequency and direction: for example, if 100 digit number is vibrating in certain way, and heading in certain direction, when we stretch it to 5 digit number: it would lose it’s direction in infinity, if this would be simply all the digits compressed, which is the solution we actually use. With heavier math, we still achieve the correct solution, and we are bound to replicate it intuitively: the number would look, something like having the same vibration, but 2 times where it was 50 times there in long number – to average the relations perhaps, because I don’t have many concrete numbers –, as without doing this, it would point in different direction. For example, as it’s a slice of infinite number: repeat it 50 times and you should

• Here we see: the frequential number, indeed does not lose it’s invariant frequency under normal transformations, such as basic affine transformations we probably need the most in this phase of transistion – even if I cannot make use of Tilt, I have now seen just one use case where it does not look senseless and non-real compared to rotate, resize, pan, which all look like basic things one needs :) If I have Tilt, I would like to have also clouds, fire and woman’s face as primitive mathematical shapes haha! :D Well but it’s hard to avoid the Tilt with a proper matrix.

• You define braces in a way that A(AA)A would equal to AAAA – normally, we use braces for different purpose, but this is one notation and you could find a distinct shape, color or description for your braces, where I have only 3 types initially here on my keyboard.

• If you write A(AAA, you see that you have unclosed space. This is not a syntax error, but it means that by each step, you would continue the number inside the braces. If you use normal notation, where the rest is only one digit, you would start new and new digits inside a digit, achieving a curved shape – if this is infinite effect, indeed the number is accelerating or deccelerating, representing something. In another interpretation, where as I said I don’t mean just that: you compare with programming, where for example adding { A = A + 1 }, where it’s recursive block, would create acceleration to A, where you can map those to normal values in higher space and thus, the case makes sense.

• 4 logecs truth values are equal to 4 numeric values of mathematecs.

• Even long numbers yield reasonable solutions to Logecs, which works very well with dimensions, which won’t give the whole units.

• Mathematecs can be directly used to do operations with Logecs.

• Basically for the basic math operators, they also make sense as Logecs operators as you can trivially see how multiplication, division, addition, subtraction make sense, along with other operations as these 4 are rather I, O, A and E, respectively divide, subtract, add, multiply; where U and V are averaging and something like geometric averaging, which opens upwards. Logecs operations, the same way, such as and or or, map easily to mathematical transformations.

• For Length, AAA has R=3, while A has R=1. For example, while they are equally worth: doing “A” three times must be equivalent to doing “AAA” 1 time, depending in precise calculation AAA might cost also 3 times more so that there would be no difference; in other cases AAA would benefit from things like grander plan, better prevision, or the case that you want to use R for some purpose.

• For Percentage, AAA and A have it A, while EE would have it E – AEAE is rather equal to AE, more or less. This is the direction of the number.

• Sometimes the numbers are more literal, where you read AAE as being equal to rather AE or E, and in each case counting to 2; you don’t give any special meaning to R and T

• R and T are often important: when we develop, this means accelerate into higher spaces and vibrations, we replace the name of same activity with a longer number which fits our typical activities. We can consider that rich, who is eating, might enjoy additional qualities related to poor, who is eating; but we might think otherwise – similar question appears, if eating is E, with numbers E, AE, AAE.

• We can map position to pixel coordinate, value to it’s color.

• We can map position to physical coordinate, value to it’s state.

• Usually, we find correlating R and T properties of systems we study.

• Indeed, we can turn T into space or R into value, such as writing down the coordinates

• A: Single digit number is referred mostly by base-1, where the number of “A”’s you write is

• AA: Two digit numbers represent either position OA, -1 and 1, where the first digit is

• AAA: three digits are usually referring: first digit is negative, -1, followed by positive digits

• AAAA: IOAE could be used either to denote values from -2 to 2, or values from 1 to 4,

• Normally: we assume U at the middle or beginning of the word, and count with normal

• This way, EE and EEEE would be very special for example: in signed space and simplified

• IOAE – the first digits, being italic, are at negative positions.

• AEIO – the last digits, being bold, are at positions Í and Ó, at the higher octave, and thus are

• AEIOVVV – V, bold and italic, is at the exterior.

• Actual position of O and A can be seen like moving 0.5 digits left or right – O is one digit left compared to A. This can involve proper settings for this to make any sense (it might not change the numeric value, but refer to the fact that by this value, a neutral digit such as having each digit “1”, would then be able to express it with position only, where several digits at the same position can create the numbers – it’s a map of the T=R property, where in this way we basically have a little bit of the situation of having only R, which can simplify imagination and calculations, or understanding of number philosophy, even if it’s hard to instantly find a particular easy example).

• I and E, in this context, might have 4 digit difference. In other settings, they move the whole number one digit left or right, where the digit is supposed to map the L value – while L value is very small, but fractally, it gives a second octave into such manner.

• I = -2

• O = -1

• A = 1

• E = 2

• The face value, as viewed from direction of infinity, would rather be equal to it’s local value.

• It’s visible that O and A, while being normally more important locally than I and E, are less important – farther – when looking from infinity; where they have the same numeric values, they do not have the same strength, but rather they are far away.

• Thus, to write the exterior value, we rearrange the numbers: OIEA, where I and E are central, O and A are secondary: the numeric value would be wrong, but not the case that while IE are local, visible values from infinity, OA would be very far – thus becoming rather the limits. Here, what applies is similar to 18 encoding: it has two zeroes at the middle, where zero between 48 (6·7, where · is averaging unlike *, which multiplies) is accelerative zero; in case of OIEA the case is that beween O and A, there is deccelerative zero, but between I and E there is the local zero. Indeed, for 6 we have VOIEAU or OIVEAU, unsigned and signed case. This is the closest to map eX coordinates of exceeta of V.

• With the complex value, each possible direction is rotated: rotating any more would already come back, so by discrete analysis within given number scope of discrete digits, this is 180 degrees, but not in normal number space, but rather transcendental or perhaps transformative space: also the higher-dimensional properties and fractal properties, in left-right, up-down, but also in-out directions, which are all opposite.

• Complexity of nurmal numbers, such as O in base-2 or IO in base-4, are not so heavily rotated but rather the rotation is visible in 1 dimension, and it rather fits the linear scale. Complex axe itself does account with the ZY reversal from coordinate system of X, which disappears as you zoom out.

• Either each value is mapped to given R or T, which is often used for diagonal (infinity) values. Each two Dens refer to one Ten.

• Values can be divided to two groups, with two values in both. Value of R denotes, to which group the digit belongs. For any given two groups, there are two complementary groups: where T denotes belonging to one of such groups, the value is complete with two Dens referring to one Ten.

• 00 – I

• 01 – O

• 10 – A

• 11 - E

• The basis for Laegna Computer System, particularly Laegna Programming Environment.

• The basis of Laegna Number System, as it’s supposed to be seen by Computer Scientist.

• For binary integers, for example for 16 bit signed integer, we can assume we get some kind

• For floats: they contain similar kind of binary integer, where you can map something; they

• There is no zero.

• Each number is a whole number: A, for example, is in range from 0 to 1, where O is in range

• Digits after the comma / dot are thus in such position: for A, Aa! means 0 and Ae! means 1,

• There is U, and for base-4 there is also V; for base-2 U and V are integrated just like O and I

• U is either of zero width, invisible number whose actual values are in lower octave – it has

• Otherwise, U is as wide as any other number, and for example Au! = A, Ai! = -0.5, Ue! = 0.5

• It’s simplistic and rather easy to program, where I removed any kind of irregularities (and they are full of them) for this computational effort; in computers we use absolutely normalized and standardized numbers for low-level programming and internal system; while it’s supposed to enable calculations to implement high-level numbers and even language.

• It’s meant to be basic effort to train an AI. It needs to generate listings, cards etc. once we are ready: but herein, I want to create the basic tools – things such as teaching different ways of wording, different ways of representing, and making the AI get used with different conditions of them is a longer process.

• I take the following assumption: given this set of numbers, computer would learn the basic logic of Laegna numbers. Actual numbers might be different, but based on this logic and the generalizations it should be able to use them.

• You have a list of unsigned digits each time you run it.

• Digit’s value is from 0 to 1 or from 0 to 3 depending on the format, where U and V flags can be set; if both are set, a special character appears – yet to find how to properly print something similar to Laegna character, but this does not matter much in programming this.

• It does not use accents nor capitalize, and there are only full numbers; this is not hard to fix but perhaps not needed in the first place right now, I don’t know whether you need any.

• What you can do with this:

• Use the x and y numbers: x is the real, y is the imaginary component.

• Create decimal mappings for base 2 and base 4.

• Complex number is not necessarily base 4 or 16, but rather it’s two axes of base 2 or base 4 – given this, once you have 2 and 4 systems, you simply use two axes of the complex number.

import math
import numpy as np
import mpmath as mp

base16 = ["GFEH", "CBAD", "QPOR", "KIJL"]

class Digit:
    def __init__(self, fmt):
        self.fmt = fmt
        self.x = np.random.randint(0, fmt.f)
        self.y = np.random.randint(0, fmt.f)
        if np.random.randint(1, fmt.f * 4) == 1:
            self.ux = np.random.randint(0, 2) == 1
            self.uy = np.random.randint(0, 2) == 1
        else:
            self.ux = 0
            self.uy = 0

    def __str__(self):
        # Base 2
        if self.fmt.l:
            if self.ux and self.uy: return "Ü"
            if self.ux: return "U"
            if self.uy: return "Ẅ"
        if not self.fmt.l:
            if self.ux and self.uy: return "?"
            if self.ux: return "0"
            if self.uy: return "9"
        if self.fmt.f == 2 and (self.fmt.w):
            if self.fmt.l:
                if self.x == 1: l = "A"
                if self.x == 0: l = "O"
                if self.fmt.d == True:
                    if self.y == 1: l += "A"
                    if self.y == 0: l += "O"
                return l
            if not self.fmt.l:
                if self.x == 1: l = "2"
                if self.x == 0: l = "1"
                if self.fmt.d == True:
                    if self.y == 1: l += "4"
                    if self.y == 0: l += "3"
                return l
        if self.fmt.f == 2:
            if self.fmt.l:
                if self.x == 1 and self.y == 1: return "T"
                if self.x == 0 and self.y == 1: return "S"
                if self.x == 1 and self.y == 0: return "N"
                if self.x == 0 and self.y == 0: return "M"
            if not self.fmt.l:
                if self.x == 1 and self.y == 1: return "4"
                if self.x == 0 and self.y == 1: return "3"
                if self.x == 1 and self.y == 0: return "2"
                if self.x == 0 and self.y == 0: return "1"
        if self.fmt.f == 4 and (self.fmt.w == False or self.fmt.w):
            if self.fmt.l:
                if self.x == 3: l = "E"
                if self.x == 2: l = "A"
                if self.x == 1: l = "O"
                if self.x == 0: l = "I"
                if self.fmt.d == 2:
                    if self.y == 3: l += "R"
                    if self.y == 2: l += "O"
                    if self.y == 1: l += "P"
                    if self.y == 0: l += "Q"
                return l
            if not self.fmt.l:
                if self.x == 3: l = "4"
                if self.x == 2: l = "3"
                if self.x == 1: l = "2"
                if self.x == 0: l = "1"
                if self.fmt.d == 2:
                    if self.y == 3: l += "8"
                    if self.y == 2: l += "7"
                    if self.y == 1: l += "6"
                    if self.y == 0: l += "5"
                return l
        if self.fmt.f == 4 and self.fmt.d == True:
            return base16[self.x][self.y]

        return "(" + str(self.x) + ", " + str(self.y) + ")"

class Digital:
    def __init__(self):
        self.setf(np.random.randint(1, 3) * 2)
        self.setd(np.random.randint(1, 3))
        self.setl(np.random.randint(1, 3) == 1)
        self.setw(np.random.randint(1, 3) == 1)
        self.generate()

    # Set the frequency; for example 2 is base-2, 4 is base-4
    def setf(self, f):
        print("f: ", f)
        self.f = f
    
    # Set the dimension; 1=real and 2=complex number
    def setd(self, d):
        print("d: ", d)
        self.d = d
    
    # Switch between Laegna and Decimal representation; True if Laegna
    def setl(self, l):
        print("l: ", l)
        self.l = l
    
    # True if digit is RT double-character, false otherwise
    def setw(self, w):
        print("w: ", w)
        self.w = w

    def __str__(self):
        ex = ""
        for n in self.number:
            ex += str(n)
        return ex

    # Randomly generate a number
    def generate(self):
        length = np.random.randint(1, 101)
        self.number = []
        for a in range(0, length):
            self.number.append(Digit(self))


num = Digital()
print(str(num))