PLANET OF THE LOST SET THEORY
( ANIMATED INFORMATION )
An essay on the (logic) functions of process, object, relative sets;
a study of declarative programming through dynamic logic.
operations and function are based on OO & set theory.. error handling is based on game theory and music theory



 



""Now when you pick a pawpaw
Or a prickly pear
And you prick a raw paw
Next time beware

Don't pick the prickly pear by the paw
When you pick a pear
Try to use the claw

But you don't need to use the claw
When you pick a pear of the big pawpaw

Have I given you a clue ?""
 
((Ties web page loops together using multipul choice interactive forms in direct correspondence to a hierarchy based on cycles in fundamental logic symmetries.(( forming animated software circuits and web page generated Macros)) Each page has a time variable and is within a nested routine creating subroutines within nested Macros.



2, 3, 5, 7...A program in a functional language consists of a set of (possibly recursive) function definitions and an expression whose value is output as the program's result. Functional languages are one kind of declarative language. They are based on the typed lambda-calculus with constants. There are no side-effects to expression evaluation so an expression (e.g. a function applied to certain arguments) will always evaluate to the same value (if its evaluation terminates). Furthermore, an expression can always be replaced by its value without changing the overall result (referential transparency). The order of evaluation of subexpressions is determined by the language's evaluation strategy. In a strict (call-by-value) language this will specify that arguments are evaluated before applying a function whereas in a non-strict (call-by-name) language arguments are passed unevaluated. Programs written in a functional language are generally compact and elegant, but have tended, until recently, to run slowly and require a lot of memory. Examples of functional languages are Clean, FP, Haskell, Hope, LML, Miranda and SML. Many other languages such as Lisp have a subset which is purely functional but also contain non-functional constructs. See also lazy evaluation, reduction.

A general term for a relational language or a functional language, as opposed to an imperative language. Imperative (or procedural) languages specify explicit sequences of steps to follow to produce a result, while declarative languages describe relationships between variables in terms of functions or inference rules and the language executor (interpreter or compiler) applies some fixed algorithm to these relations to produce a result. The most common examples of declarative languages are logic programming languages such as Prolog and functional languages like Haskell.

A production system consists of a collection of productions (rules), a working memory of facts and an algorithm known as forward chaining for producing new facts from old. A rule becomes eligible to "fire" when its conditions match some set of elements currently in working memory. A conflict resolution strategy determines which of several eligible rules (the conflict set) fires next. A condition is a list of symbols which represent constants, which must be matched exactly; variables which bind to the thing they match and "<> symbol" which matches a field not equal to symbol. Examples are OPS5, CLIPS, flex

A programming language for rule-based production systems. A rule consists of pre-condition(s) and a resulting action. The system checks its working memory to see if there are rules whose pre-conditions are satisfied, if so, the action in one selected satisfied rule is executed.



OR, AND, IF, ELSE :   -   +   =   x    :    no   yes   true   false

In mathematics, a function is a relation such that each element of a set is associated with a unique element of another (possibly the same) set. The concept of a function is fundamental to virtually every branch of mathematics and every quantitative science. The terms function, mapping, map, transformation and operator are usually used synonymously.

Intuitively, a function is a "rule" that assigns a unique output to each given input. Here are some examples of functions:

Each person has a favorite colour (red, orange, yellow, green, cyan, blue, indigo, or violet). The colour is a function of the person. For example, John has favorite colour red, while Kim has favorite colour violet. Here, the input is the person, and the output is one of the 8 colours.

Some children are selling lemonade in the summer. The number of lemonades they sell is a function of the temperature outside. For example, if it is 85 degrees outside, they sell 10 lemonades, but if it is 95 degrees outside, they sell 25 lemonades. Here, the input is the temperature, and the output is the number of lemonades they sell.

A stone is dropped from different stories of a tall building. The time it takes the stone to reach the ground is a function of the storey. For example, the stone takes 2 seconds to fall from the second storey, but only 4 seconds to fall from the 10th storey. Here, the input is the storey, and the output is the number of seconds.

The "rule" defining a function can be specified by a formula, a relationship, or simply a table listing the outputs against inputs. The most important feature of a function is that it is deterministic, always producing the same output from the same input. In this way, a function may be thought of as a "machine" or a "black box", converting a valid input into a unique output. The input is often called the argument of the function, and the output the value of the function.

A very common type of function occurs when the argument and the function value are both numbers, the functional relationship is expressed by a formula, and the value of the function is obtained by direct substitution of the argument into the formula. Consider for example

f(x) = x2

which assigns to any number x its square.

A straightforward generalization is to allow functions depending on several arguments. For instance,

g(x,y) = xy

is a function which takes two numbers x and y and assigns to them their product, xy. It might seem that this is not really a function as we described above, because this "rule" depends on two inputs. However, if we think of the two inputs together as a single pair (x, y), then we can interpret g as a function -- the argument is the ordered pair (x, y), and the function value is xy. In the sciences, we often encounter functions that are not given by (known) formulas. Consider for instance the temperature distribution on earth over time: this is a function which takes location and time as arguments and gives as output the temperature at that location at that time.

We have seen that the intuitive notion of function is not limited to computations using single numbers and not even limited to computations; the mathematical notion of function is still more general and is not limited to situations involving numbers. Rather, a function links a "domain" (set of inputs) to a "codomain" (set of possible outputs) in such a way that every element of the domain is associated to precisely one element of the codomain. Functions are abstractly defined as certain relations, as will be seen below. Because of this generality, the function concept is fundamental to virtually every branch of mathematics.

FUNCTIONS ARE PROCESS RELATIVE TO SETS: SETS ARE OBJECT RELATIVE TO FUNCTIONS    GO -- THEN (I/O)    The Axiom of Choice (AC)

Set Theory studies properties of sets, abstract objects that pervade the whole of modern mathematics. The language of set theory, in its simplicity, is sufficiently universal to formalize all mathematical concepts and thus set theory, along with Predicate Calculus,(..functions) constitutes the true Foundations of Mathematics.

In practice, set theory is used as if it described a particular (mathematical) reality, and provides the semantics for formal logic.

Set Theory, with its emphasis on consistency and independence proofs, provides a gauge for measuring the consistency strength of various mathematical statements.

2x
/  |  \
2pi    phi    sq/2
<-->/ \<-->
<------->



Q
Volts, Amps, Watts,



P
Tempeture, Pressure, Volume,



One of the most important concepts embodied in the abstractions offered by 1st generation languages was the separation of a program into two distinct parts. The description of the data contained within the program was known as the declarative part, and the program logic that controlled the execution of the program and manipulation of the data was known as the imperative part.





Object-oriented Programming (OOP), the origins of which can be traced back to Simula 67 [Birtwistle73]. An object is an encapsulation of some data, along with a set of operations that operate on that data. Operations are invoked externally by sending messages to the object [Blair91]. Thus, each object is an abstraction that both encapsulates and acts upon its logic and data respectively. This allows a programmer to view their system as being composed of conceptually separate entities, or objects. The OOP abstraction also builds on the previously discussed advances in modularity, data abstraction and information hiding, by including facilities for software reuse [Ghezzi98]. Newly created objects in the system are not implemented from scratch, rather they may inherit pre-existing behaviour from a parent object, and implement only the required new behaviour.



functional and logic programming languages are an important contribution to our computing landscape. Both are declarative languages and are characterised as being independent of the underlying hardware upon which they are executed; they are abstractions that are not influenced by the von Neumann architecture. However, to achieve this independence efficiency has been sacrificed [Wilson93]. This, and the fundamental change of programming mindset required for those accustomed to the imperative style has been detrimental to their widespread acceptance and deployment outside of the artificial intelligence and expert systems communities.



functional and logic programming languages. Functional languages use as their basis the theory of mathematical functions, and they differ greatly from imperative languages as they do not support the concept of variable assignment. Assignment causes a change in value to an existing variable, whereas the application of a function causes a new value to be returned. This has important implications for the problem of concurrency, since in an imperative language it is possible to refer to a variable or object that has been reassigned without your knowledge. In a functional language, a function may be called at any time, and will always return the same value for a given parameter [Hudak89]. Further, since variables cannot be altered by assignment, the order in which a program’s statements are written and evaluated does not matter; they can be evaluated in many different orders. Thus, programs can be modified as data and data structures can be executed as programs. The key concept in functional programming is to treat functions as value, and vice versa [Watt96].



Declarative programming is an approach to computer programming that takes a different approach from traditional imperative programming in Fortran, C++ or Java. Whereas imperative programming gives the computer a list of instructions to execute in a particular order, declarative programming describes to the computer a set of conditions and lets the computer program figure(function) out how to satisfy them( set of conditions). Declarative programming includes both functional programming and logic programming.





Client/Server is a particular paradigm for distributing a system, where the server is a manager of one or more resources and a client is a user of that resource. The paradigm was used extensively in the 1970’s to structure operating system level process interaction [Simon96] [Walsh85], and is still in extensive use today. One of the best contemporary examples being the World Wide Web [Berners-Lee92]. · The syntax for calling a local or remote procedure is identical · The location of a resource is transparent to the programmer and user · Communication is synchronous, and engenders the client/server paradigm The early 1980’s saw many breakthroughs in the distributed systems arena. Some
The notion of mobile computation at a higher level of abstraction was first suggested in “Objectworld” [Tsichritzis85], a hypothetical computing environment geared towards information dissemination in which all objects could be mobile. This, and the ideas embodied in migratory systems have spawned a new field of research that is investigating similar solutions but on a much larger scale and at a higher level of abstraction. This field has many names, amongst them mobile code systems, mobile object systems, active networks and mobile agents. For the remainder of this thesis, we use the terms interchangeably unless explicitly stated otherwise. Unfortunately, there is still no consensus among the mobility research community as to what exactly each term refers to, or a standard definition for each to which everyone subscribes. Therefore, in this thesis we define a mobile agent as: “a software agent that is able to autonomously migrate from one host to another in a computer network.”
 Programming is location aware – mobile agent systems provide an abstraction in which the notion of location is available to the programmer and the constituent components of the system. · Mobility is a choice – migration is controlled by the programmer or at runtime by the agent, instead of being triggered transparently by the system.
mobile agent systems will be characterised as enabling distributed systems by supporting local interaction and mobile logic and data.
Their true advantage however, comes from being able to migrate and continue functioning in a heterogeneous network of systems. This advantage is implementation dependent and has greatly influenced the way in which mobile agent systems are created. To enable heterogeneous execution it is usual for these frameworks to be written in some type of script or bytecode that can subsequently be interpreted, usually by a dedicated executing environment.



Better modularity alone is the key to the power of functional languages.
AS IN M3K; progs as ((associative pearls) mini's) 'twin film' strings'', composing albums @ and dissks @@
In AI patterns of gentic algorithms ( ie..Recorded )


But you didn't think we'd stop there, did you? No, no my blue friend,



Dynamically (logic) Insert and Update Values In a MySQL (functional) Database Using OOP ( even better modularity).. We will make a class that goes out and looks for the values for us and builds a SQL statement on the fly. All we have to do is make sure the column names in the database (OBJECT/FUNCTION SET(DIRECTORY)) correspond with the field names (FUNCTION/OBJECT SET(PAGE)) in the HTML form (or M3K page).. there is a one to one corrospondence with each tree limb ($) (& twig (*)) and each apple (object/event state).
(The apple knows it's own seeds...by last & first names)

CREATING THE CYBERNITIC CIRCUT
(Defining and refreshing the directory..trees, rivers, seeds, rain)




READ CODE InSIDE This Source Document....(view source)........>



link to first statement presentation


M3K modularity is the key to successful cybernetic programming. Languages which aim to improve productivity must support modular programming well. But new scope rules and mechanisms for separate compilation are not enough - modularity means more than modules. Our ability to decompose a problem into parts depends directly on our ability to glue solutions together. To assist modular programming, a language must provide good glue. Functional programming languages provide two new kinds of glue - higher-order functions and lazy evaluation. Using these glues one can modularise programs in new and exciting ways, and we’ve shown many examples of this. Smaller and more general modules can be re-used more widely, easing subsequent programming. This explains why functional programs are so much smaller and easier to write than conventional ones. It also provides a target for functional programmers to aim at. If any part of a program is messy or complicated, the programmer should attempt to modularise it and to generalise the parts. He should expect to use higher-order functions and lazy evaluation as his tools for doing this.



Sanchis attempts to bring the theory of sets closer to practice by limiting all set references to sets that can be constructed from other sets, and all set properties to properties that can be constructed from other set properties. In particular, this means that in the definitions of sets and properties, all quantification is restricted to members of specified sets.

A side effect of Sanchis's operational approach to set theory is that it is not necessary to prove that sets exist before talking about them; existence comes automatically with the fact that all introduced sets are constructed from other sets. Of particular interest to mathematicians is the way that Sanchis makes induction and recursion primitive rules in his theory, rather than the derived rules that they are in other formulations of set theory. Given two previously defined set properties and a set operation, the set induction rule introduces a new set property by means of four axioms. The first axiom defines the new property to hold on a set Z whenever the first given property holds on Z (the base case) or the second property holds on Z and the new property holds on every member of the set obtained from Z by application of the given set operation. The other axioms introduce a related set operation and require a foundation condition: whenever a set contains a set on which the new property holds, there is a least member of the set on which the new property holds. The set recursion rule introduces a set operation that is defined in terms of a set property that has been previously introduced by the set induction rule.

Basic Set Theory

The Axiom of Choice (AC) was formulated about a century ago, and it was controversial for a few of decades after that; it may be considered the last great controversy of mathematics. It is now a basic assumption used in many parts of mathematics. In fact, assuming AC is equivalent to assuming any of these principles (and many others):

Given any two sets, one set has cardinality less than or equal to that of the other set -- i.e., one set is in one-to-one correspondence with some subset of the other. (Historical remark: It was questions like this that led to Zermelo's formulation of AC.) Any vector space over a field F has a basis -- i.e., a maximal linearly independent subset -- over that field. (Remark: If we only consider the case where F is the real line, we obtain a slightly weaker statement; it is not yet known whether this statement is also equivalent to AC.) Any product of compact topological spaces is compact. (This is now known as Tychonoff's Theorem, though Tychonoff himself only had in mind a much more specialized result that is not equivalent to the Axiom of Choice.) AC has many forms; here is one of the simplest:

Axiom of Choice. Let C be a collection of nonempty sets. Then we can choose a member from each set in that collection. In other words, there exists a function f defined on C with the property that, for each set S in the collection, f(S) is a member of S. The function f is then called a choice function.

To understand this axiom better, let's consider a few examples.

If C is the collection of all nonempty subsets of {1,2,3,...}, then we can define f quite easily: just let f(S) be the smallest member of S. If C is the collection of all intervals of real numbers with positive, finite lengths, then we can define f(S) to be the midpoint of the interval S. If C is some more general collection of subsets of the real line, we may be able to define f by using a more complicated rule. However, if C is the collection of all nonempty subsets of the real line, it is not clear how to find a suitable function f. In fact, no one has ever found a suitable function f for this collection C, and there are convincing model-theortic arguments that no one ever will. (Of course, to prove this requires a precise definition of "find," etc.) The controversy was over how to interpret the words "choose" and "exists" in the axiom: If we follow the constructivists, and "exist" means "find," then the axiom is false, since we cannot find a choice function for the nonempty subsets of the reals. However, most mathematicians give "exists" a much weaker meaning, and they consider the Axiom to be true: To define f(S), just arbitrarily "pick any member" of S. In effect, when we accept the Axiom of Choice, this means we are agreeing to the convention that we shall permit ourselves to use a choice function f in proofs, as though it "exists" in some sense, even though we cannot give an explicit example of it or an explicit algorithm for it.


1. Ordered Pairs
2. Relations
3. Functions


1. Ordered Pairs
We begin by introducing the notion of the ordered pair. If a and b are sets, then the unordered pair {a, b} is a set whose elements are exactly a and b. The “order” in which a and b are put together plays no role; {a, b} = {b, a}. For many applications, we need to pair a and b in a way making possible to “read off” which set comes “first” and which comes “second.” We denote this ordered pair of a and b by (a, b); a is the first coordinate of the pair (a, b), b is the second coordinate.

As any object of our study, the ordered pair has to be a set. It should be defined in such a way that two ordered pairs are equal if and only if their first coordinates are equal and their second coordinates are equal. This guarantees in particular that (a, b) (b,a) if a b.

Definition. (a, b) = {{a}, {a, b}}. If a b, (a, b) has two elements, a singleton {a} and an unordered pair {a, b}. We find the first coordinate by looking at the element of {a}. The second coordinate is then the other element of {a, b}. If a = b, then (a, a) = {{a}, {a,a}} = {{a}} has only one element. In any case, it seems obvious that both coordinates can be uniquely “read off” from the set (a, b). We make this statement precise in the following theorem.

Theorem. (a, b) = (a, b) if and only if a = a and b = b.

Proof. If a = a and b = b, then, of course, (a, b) = {{a}, {a, b}} = {{a}, {a, b}} = (a,b). The other implication is more intricate. Let us assume that {{a}, {a, b}} = {{a }, {a, b }}. If a b, {a} = {a} and {a, b} = {a , b}. So, first, a = a and then {a, b} = {a, b} implies b = b. If a = b, {{a}, {a, a}} = {{a}}. So {a} = {a}, {a} = {a,b }, and we get a = a = b, so a = a and b = b holds in this case, too. With ordered pairs at our disposal, we can define ordered triples

(a, b, c) = ((a, b), c), ordered quadruples (a, b, c, d) = ((a, b, c), d), and so on. Also, we define ordered “one-tuples" (a) = a. 2. Relations
A binary relation is determined by specifying all ordered pairs of objects in that relation; it does not matter by what property the set of these ordered pairs is described. We are led to the following definition.

Definition. A set R is a binary relation if all elements of R are ordered pairs, i.e., if for any z R there exist x and y such that z = (x, y). It is customary to write xRy instead of (x, y) R. We say that x is in relation R with y if xRy holds.

The set of all x which are in relation R with some y is called the domain of R and denoted by “dom R.” So dom R = {x | there exists y such that xRy}. dom R is the set of all first coordinates of ordered pairs in R.

The set of all y such that, for some x, x is in relation R with y is called the range of R, denoted by “ran R.” So ran R = {y | there exists x such that xRy}.

3. Functions
Function, as understood in mathematics, is a procedure, a rule, assigning to any object a from the domain of the function a unique object b, the value of the function at a. A function, therefore, represents a special type of relation, a relation where every object a from the domain is related to precisely one object in the range, namely, to the value of the function at a.

Definition. A binary relation F is called a function (or mapping, correspondence) if aFb1 and aFb2 imply b1 = b2 for any a, b1, and b2. In other words, a binary relation F is a function if and only if for every a from dom F there is exactly one b such that aFb. This unique b is called the value of F at a and is denoted F(a) or Fa. [F(a) is not defined if a dom F.] If F is a function with dom F = A and ran F B, it is customary to use the notations F : A B, , , a A for the function F. The range of the function F can then be denoted {F(a) | a A} or {Fa}a A. The Axiom of Extensionality can be applied to functions as follows.

Lemma. Let F and G be functions. F = G if and only if dom F = dom G and F(x) = G(x) for all x dom F. A function f is called one-to-one or injective if a1 dom f, a2 dom f, and a1 a2 implies f(a1) f(a2). In other words if a1 dom f, a 2 dom f, and f(a1) = f(a2), then a1 = a2.

There are four main directions of current research in set theory, all intertwined and all aiming at the ultimate goal of the theory: to describe the structure of the mathematical universe. They are: inner models,(objects) independence proofs,(functions) large cardinals,(objects) and descriptive set theory(functions). As you can see these can be reduced to 2 relevant sections defined by process object relativity.

Thus the 'function, object', relationship defines the absolute set, because there can exist no declared set independent of the functions, object, declared set, which is proved by Godel.




"One thing I absolutly love: The ads are just GIF images with a standard HTML link. That means they’ll work anywhere, even forums and emails, and on mobile phones, and certainly they’ll work in my blog posts, something Google AdSense referral ads don’t. Google uses SCRIPT tags, very annoying, and Microsoft has gone a simpler, and thus more compatible route."