fm01 proceeding - collation of relevant notes and code snippets - all stuff really
(should be divided up and put elsewhere eg. process
that again following "description as code" - that some sort of system of linkages rather than the long, flat text here could be envisaged using emacs elisp code -- hmm
**older notes: (collate all)
looking at again: same model as recently for fm01 of :
a) description as language - overlap - coding would thus just be act of description as here
thus morphing this description towards what can be executed code quoted and unquoted for our careless code walker
eg. walks code and if finds unbound variable binds to ...
quoting and unquoting can also be a somewhat arbitrary affair
b) Rules giving prompts to a growing text - prompts variations of the conditions (or categories) categories-> chunks - categories implying meta-level
c) cell-cube space (collapsing)
d) reference to mallarme spacing and text
- really question is concerned with chunking also markov chains relevant as statistical - not recombinant necessarily also idea of terminals for input-access to streams - expanded in that machines connected to 24/7 information sources
cutnpaste below :::::
34) cellular model of whole system/cluster
accepting data in all data-forms constantly
[terminals for word/text -prompt system
video/scanner for images
audio inputs
analogue sensors - this is part of an architecture/infrastructure - feeders, servers, streams]
and throughout that system processes are running to use that incoming data - spreading through/ reorganising it (internally)/ learning
and output // meaning feedback
cellular -- input -- response -- prompt
also idea of categorical and recombination
a) teleprompter giving and returning scene (scene module)
b) spacing (Mallarme') changing and evolving in cell structures
c) absolute text generation of a block of text
d) simulation of a possible mechanical machine ???
e) With spacing and text evolving as a sort of language - creation of own concepts and categories which are categorized in space/cell manner.
qualifying itself in bracketting
f) the machine is the program - any description of the machine is the programming = or rather notation (recursive) (rather than a procedure for acting on a text)
Any of written texts (eg. song - notation) being adapted towards this recursive notation :-
[document of a contained world
outside world
(dispersion) night mist, reduced city
alcohol sky - as - chemical sky
tranquilised morning
-----overlaying
interview with ]---
as generative seed for archive material - describing itself (itself as machine) a set of operations(?) or relationships for the process.
Q of operation (orbital...) vs relationship ---- operation as relationship.
not an operation acting on a text but a generative operation OF a text/notation
pattern which is not that of a tree structure --- (or could be recursive tree structure - going across all levels of nodes and through all links up and down - q. of a path - according to links and processes) --- recursive --- path as a pattern
machine of choked communication
g)
Idea of modules - that modules are operative and textual -
eg. category of the 'cut'
subjects itself and other categories
but is itself also content
no seperation of content and function. [outputable data/function] - description/function/data as equivalent - describes itself -outputs itself - so output module recurses itself and other modules print their own (non)functionality as output and transparency
self-development of its own simple rules (rather than straight-through process or system)
modules -- sentences
flipover to other side of word
--
module --
sentence --
word -- cross-over across structure - module--to--word process (seed)
recurrent word-idea
??
modules=word (persona)
words linked together by grammatical structure (before the idea)
(method of expansion across the tree or groups)
h) As of script containing its own rules
- (alphabetical)letter to book
| |
micro | macro |
| |
eye V studio V
|| [cell -------projection/universe]
turning point
[turning point/turning around of cubic room
of wall-inside space and wall-undefined outside space] == procedure of inside/outside
]
outside space of forest dripping undefined in the churchyard - a funeral in grey leaks of sky
storm leaks of sky
/// it being a film list= eye
film chemistry of 24hr cycle of light and dark
camera obscura [sunlit space/world space for living/theatre space/film-set]
frames per second
microcosm and projection
studio ---> concentric spaces
Question of syntax when comes to the word.
i) modules -- equivalence under|
| in |---------text meaning
| of | instruction
modules = [input] data
[display] system
[archive] (system = text)
[buffer]=ongoing transfer of material
from input and archive against each other
is that where the cellular process takes place?
modules operate recursively in equivalence == seen
input/display/archive/buffer = seen = non-locations = module equivalence to -
equivalence subdividing itself - (not) visible (behind).
j) category = process
(data) type--| === poetic category
|
type/process crossing itself
| | |
--->----|--|
|---<----|
diagram = (of) data flow
(as) image
= cell itself
/// and now process/streams replace idea of cell(category)/module/buffer/archive motion of streams and held-ness of streams (pooled streams - stuck in certain machineries or resolving into temporary mechanisms or levels) replaces archive/buffer etc.
how to think of processes as streams ... streams as processes
31) functions = modules
eg.
a) display modules - display as text/ image/ sound [OUT]
b) input modules - text/ sound/ video/ image [IN]
c) prompt modules --> display/ input
d) process modules -->buffer modules --> display/ storage
e) (input -->) storage modules [DATA] --> process
core modules [process modules == storage modules] == script == categorical ---> base level [light +dark] --- binary - pattern ---> sound/image ---> growth word module
(growth word module from binary patterns imposed on text)
32) (cellular) diagram = data flow
^ |
| |
process <--------------
j)
39) on divide meaningful/ non-meaningful
| Data
v |process
input from ttys
as being meaningful data regarding possible
classification of amount of past input data -video/audio/text/pattern
as regards low-memory input of audio/video
and that such classification operating on certain
keywords (expanding)
is akin to operating system commands.
k)
42) Expansion of categories - category link (specified by meaning) or word link (incidences of the word link across matrices).
Expansion of textual material towards absolute generation and multiplication via methods of:
a) cross-module multiple linking
b) markov chain and other recombiners/splitters of text
c) overwork/elaborate towards the descriptive
d) word linking --> cell multiplication
e) header = meaning links of word synonyms or sub-categories of lists of words with same meaning - expansion of field of ideas.
f) cross-cut text - folded.
these methods used across each other - subjected to each other in possible cross-cut fragments.
43) array with depths to store mutations of itelf and past/present/future to a depth and the overlaid patterns -- a journey through that depth
arrays as elements of arrays + huge superimposed and mirroring linkages (that one structure can form to become the entire networked system in simplicity and also in a blossoming of multiplicatory deep/parallel paths)
44) >grown words---|
^ |
-----------------
user input (of files/data) --> arrays
|
v
->process
| | [own commands]
| v
-- arrays
---------------
|
|
V
OUTPUT live/stored---> for further use
45) Invention of a meta-language // itself-v
mirror//storage
that can operate on/as itself as language
not of commands
but modular and extendible. / growable and outwards tending.
**gdapp model:
1] nodal model isn't really implemented well - clunky vm model which should be re-written for lisp code (mobile though - abstracted network functionalities) :::
vm vs. multiple interpreter model - or mobile multiple interpreter streams on a vm substrate - leaking microcode which can expand/branch out
--> from cliki:
1) cell structure - offset, length, lively, registers on top of vm +data (list of cells, cur_cell + list of channels -> functions, (in/out / destroy), void *data.
-> map node connections/ remote node copied to local node / node functions and node microcode
2) linkage - strength/flow/barrier/leakage - promiscuity
how difficult to implement in latest gdapp. leakages of functionality also
3) mobile nodes carry data/microcode chunks for insertion (vm/macros etc)
4) cell contains - data/code .. macros/interpreter
5) parallel node execution model (n-ary tree [ n n-ary tree can be represented using a recursive list of the following form:
( root subtree1 ... subtreen ) ]
without top-down flow or organisation)
6) display-itself .. display internal and linkage node(s) structure - and code ...
7) node model from ap (registers etc. in cell-space also) - linear cell-space expanded by linkage - viewings/models as arbitrary - ie. multiple viewpoints
8) garbage collection - promiscuous creation of nodes and grouping autopoeisis
9) os model also (pipes, I/O, bus - process/threads/clone/fork + space model - inhabitation/leakage what is cellular model?
------------------
levels/trajectory | nodes/chunks/streams | V interpreter
node has trajectory and accumulates functions - exchange of functions (which build mechanisms) with other nodes- node/layer/mechanism/reflexive
// what are primitives, means of combination and abstraction
layers of abstraction are accessible in the language (see mapforms code walker) or with continuations produce self-aware language or with interpreters or other code walkers - see erunticlab code
exposure - quoting and unquoting
abstractions of levels -> trajectories streams - in process
net/I-O attachment
_____________________
HOW to proceed with fm01::
1) gdapp model follows process model in On Lisp - further + see notes above
2) examination of other such environments
a)in fm01lisp dir:
common music - cm. algorithmic composition
/bin/cm.sh -e emacs . cm-2.4.2 fixed
notion of event here
cm runs as scheduling - see also functions syscmd and cm-call
(defun cm-call (keyfn &rest args) (apply (find-symbol (string keyfn) :cm) args))
:cm = use of keywords = keyword arguments accepted by a function
find-symbol -symbol in package cm
clm - common lisp music (more signal processing) clm -> run macro and definstrument
run.lisp very long = code walker
note also for clm:
"To force the 'run' macro to be fully expanded, anything using 'definstrument' has to be compiled, not just interpreted. I'll add something to the documentation about this since it has tripped several other people."
compile-file
so anything using macros must be compiled? no! but why in this instance? must be something in the expansion
like what?
and is compiled as interpreted?
b) framer and media streams ( mark davis) built on framer distributed object database (where is a lisp implementation?) + ken haase
c) idic thing - based on gps - see norvig
3) cl-sdl - all working under cmucl but need work through sdl-mix stuff for audio -low-level stuff - also network transparency would fit here - is more important to define abstractions
4) site work through for ideas
**cliki notes:
a) our [[environment) consists of relation to-be-devised/defined of [[streams), mechanisms and level?s
streams->event?s
environments entered in mechanisms
streams encountered with mechanisms
where is event? where is interpretation?
b) environment of trajectories, macros-functions, relations, levels, scenes, scripts, machine-nodes
from environment to language
environment of trajectorial machinic nodes
c) question of mobile/multiple environments and streams - macros also
d) barrier, combine, embed, scene, describe, foregrounding, backgrounding, return (think such a list exists elsewhere?)
- that these do not operate on a block but as trajectory, recombinant, relation and level
- is not about what is there (surrounding) - there for what could be interpreted as instruction
for scene? - intersection, concentric, scene-description, frame
exposure, inside-out node
trajectory - arc, circular, intersection, concentration
trajectorial organisation - categories as levels, contexts - levels of scene, trajectories and node depend on node as level etc.
embed = of material and relation to concentric
material of script. observation and what has been already written, filmed
time-line - happened, happening, will happen
so not really a list of functions - language not as functional - language as relational - functions as groupings or grammatical overlap of theoretical lisp language w ith our script? - (note applies to start on textual fm01 but applies perhaps to all versions)
language defines relations and trajectories of node and language operations dictated by such relations - which can always be turned inside out
e) what drives the mechanisms:
self-consideration in-of our language - abstraction which is exposure in back-foreground relation
"parallel film conceit"
list mechanisms, classify and code as macros or as functions:
back-foreground
list from language: functions/notions from script?
barrier, combine, embed, scene, describe, foregrounding, backgrounding, return - that these do not operate on a block but as trajectory, recombinant, relation and level
- is not about what is there (surrounding) - there for what could be interpreted as instruction
for scene? - intersection, concentric, scene-description, frame
exposure, inside-out node
trajectory - arc, circular, intersection, concentration
trajectorial organisation - categories as levels, contexts - levels of scene, trajectories and node depend on node as level etc.
embed = of material and relation to concentric
material of script. observation and what has been already written, filmed
time-line - happened, happening, will happen
f) post-nodes model for diagrammatic (time-based - also see structure and interpretation of computer programs) language without functions
multiple parallel interpretative streams of data/code///of embeds - own language terms in definitions
language is that which can handle streams in context of script? as language
stream is by-product to-be-interrogated-from-the-console or to be seen
streams can temporarily form constructions, mechanisms
fragment streams co-alesce; word stream, data stream, code stream
;; is it too simplistic say that type is embedded, as marker, in stream ;; and streams can change this ;; or total equivalance - equivalance, investigation and interrogation (evaluation)
;; word stream etc is just q of chunking and levels and also of quote/unquote
see also
<a href="http://mitpress.mit.edu/sicp/full-text/sicp/book/node69.html">sicp</a>
g)
vectorisation of script and image - as image and in script across combinatorial senses of pages, scenes, shots and also within image and scene (eg. concentric studio spa ces and clues=trajectories)
as well as being embedded in components script? also defines trajectory (networked and across nodes) of/for software components
instructions?( tokens? (to use such a word?) dependent on context - but offering the same functionality across all flattened levels of what could be seen as high and low levels - of pixels and major trajectories
(some functions dependent on context = environment - env? )
trajectory of node-particle possesses speed and crosses levels as dictated
node is particle, relation and change of space of that particle
that one could start to define particle oriented programming (as opposed to OOP) - that trajectory does include networked trajectories or processor trajectories but is m ore of abstraction-level trajectories
node-diagram - how trajectory is specified within the language
trajectory solely concerned with a cross-level manouevering (internal/external) of contexts
h)
this now seems to be main repository for notes/recent ideas sept-oct 2004 relating to textual lisp implementation
making evident of word-background/that-which-is-written within script as it stands - towards what-will-be filmed but without discarding the script
background material such as how it was written - how it is to be filmed
within such a landscape -relation the issue of vectorisation or trajectory is important
script is only code in code node so down to interpreter - levels of scripting and interpreter itself
background/script (film script) stands in same relation to film (filmed) as program to execution - background as revelation of code and script rewriting film rewriting script
to make a start::
a) (hand ?) parsing script into functional lisp code<br> b) evaluation of code<br> c) print<br>
eg. functions such as foreground and background which enact on code/script
so a start would be to code this top level (as read, eval, print) and examine commands in script and fill this in for the text stream version
scene as node which can change/merge/enact upon other nodes/scenes
functional data/code/scene nodes collaborate/ change each other - for example image analysis nodes/compression nodes
need identify core elements of fm01 for coding:
script as node, node as mobile, node as cross-level functional and able to negotiate, coerce and encompass trajectories of nodes, node as interpreter and interpreted ongoing, node as exchange with nodes and collaboration hmm...
node as its own storage also - is itself
bcn notes july 2004
1) node characteristics summarised as: mobile, data/code to be interpreted, interpretative, describing and traversing trajectories, operative-performative-collaborative, node as script, cross-level functional
2) q of mallarme node, broodthaers node describing such operations
3) further:- back-foreground relation as q of interpretation (and context=environment) ability to alter-construct node trajectories
4) nodes define a language whichcan be shared or argued over - misconceived
5) base [[interpreter) for mobile nodes - difference compiler-interpreter - that compiler could translate code into vm code
6) [[fm01)=description of a language
+
a mechanism (transport and access)
language is described by the script
7) script defined in terms of mechanisms (in different sense to above( - film machine-script machine
node as this mechanism which functions in/or constructing/constructs language
8) q of language mechanism data access - is this data local?, is a node incoming and how is its [[trajectory) described
can we abstract this trajectory?
bcn notes aug 2004::
1)serial simulation of multiple parallel interpreters (see [connection machine]? )
construction of a simulated parallel trajectorial set of interpreters
that we throw interpreter question into back-foreground relation question - also compiler-language question
2) from Paul Graham (Common Lisp CLOS chapter : "instead of code operating only on inert masses of data, data itslef is told how to behave ... program is implicit in interactions of new data 'objects' "
3) see On Lisp - chapter 19 - embedded query language, 21 - multiple processes and 22+ non-determinism and embedded prolog all useful
4) *** fm01 is not software/process, it is a language
thus compiled/interpreted (to be performed/to be shot - performing/shooting)
fm01 is an abstraction lisp (or any language) is an abstraction
q of mapping one abstraction over the other
wrong to think of fm01 as process (eg. parse this, do this) or as procedural rather is like OO model or message passing
read-eval-print loop is same throughout generattion of material as side effect or knowing exposure
what are characteristics of this abstraction ?
a) highly distributed (does this necesarily imply messages - or communication between processes or nodes - how aligns with trajectory model ?
node -> code.interpretation.stream.context.mechanism
see [symmetric lisp]? - Gelernter
mechanism as language or implemented in language?
b) stream?s rather than containers
c) mobile - with trajectory
d) tokens ??
e) background-foreground abstraction script (to be filmed/as filmed) + how is written and filmed how that which is to be filmed is described
that abstractions should come from the script - that they are presented
f) cross-level functionality - that we should be able to operate across levels with difference/no difference - operators are/not tied to context
across levels such as first order items such as node, scene, trajectory
g) thus context/environment/locality
h) no functions/processes
- see query language and prolog as above for examples mapping abstraction over lisp
i) mechanisms
j) leakage (event driven?)
k) geometry
l) exposure
m) self-consideration
in some sense a diagrammatic language
pseudo-ops such as embed and notions such as trajectory are useful
how to define these further?
trajectory - relates to levels of non-containers - give up on nodes idea
embed - relates to scene and the concentric
post split, croatia notes
1) identification of what we can use from lisp we know of so far:
macro characteristics inc splicing in macros, read-macros, quote and unquote - symbol-literal, eval, use of closures 2) interp-embed examples - norvig - PG - nodes as interpreters
interpreter - norvig p756 chap 22 + chap 11 embed - PG p269 CL + last chapters of On Lisp 19,21,22+
interpreter implies environment?
3) symmetric lisp - alpha forms as sole abstraction alpha forms = name spaces and may have associated code when evaluated create object and execute code in that context
Q. how nodes/streams refer-to/message/instantiate other nodes.
with textual side effects
-------------------------
that fm01 would be embedded with node as concurrent co-interpretative elements
node as interpreter - functional, machinic script thing - see mechanism
multiple concurrent interpreters
Q interpreter for what? do we seperate code-interp nodes or within node space co-operative nodal interpreters
--- interpreter/interpreted - fore-back is such a relation code/executed - could be used with read-macro for / and [ --> to be implied here - interpreter/[code/data stream intepreted by trajectorial nodes]/environment
or post-nodal:
script is language/software for concurrent trajectorial interpreters which consist of interpreted/interpreting functionalities/mechanisms
script is interpreter/interpreted to be/has been
script instantiates multiple interpreters for its own language
so :
an embedded language with multiple trajectorial interpreter instances
trajectorial interpreter instances which are bound with and instanced by script elements - stream script elements changing as inward and outward by-products
trajectory solely concerned with a cross-level manouevering (internal/external) of contexts
Q what is environment for the interpreter?
is the closure - language [env]-[node/interp]-[traj/level]
---------------------------
node is a function (what of post-node view tho?) function is a node which converses with other function/nodes/closures - embeds function/nodes and operates further leaking function/nodes
eg. embed node/function is run by other node as part of its own mechanism but in shift of fore/back and symbol-no-symbol is hard to see such operations - also as we see embed may be implemented with body splice of macro? ,@
Q how trajectories and parallelism implemented - as language models not as functions of a program
Q what does function operate on?
its other quoted/spliced/unquoted code/data body - no seperations,no operation on but with
------------------------------ functions creating levels functions across levels actors traversing levels
notation for and[not [ both
for: both context - no-context level (non)equivalence -----------------------------
language expanded with new mechanisms/constructs
barrier could be macro control structure
barrier would also make use of embed to implement barriers across levels + concentric functionality which can play with levels
todo - describe each function and how relates to levels, others
Q what are levels:
node, fore, background, scene, trajectory are on one/differing levels
levels-context-environment
describe is a particular instance
exposure->embed, barrier relation [here this and this itself should be the language]
own terms of description
chain of levels
Q what is implemented as function and as macros
false/fake death as major aspect -language for fake-faked death
5) macros and further On Lisp
macros for chunking and time stuff such as barrier and happened/will-happen
6) streams and overview of sicp
**sicp overview
computation and time - see below
computer language as formal medium for expressing ideas about methodology
study of the structure of knowledge from an imperative point of view
//chapters
**abstractions with procedures - procedures as general methods - procedures as returned values
**abstractions with data - compound data - sequences as conventional interfaces - example of a picture language -
**modularity, objects and state -> modeling physical systems ie. basing structure of program on structure of system being modelled. [ in this instance - levels and mechanisms and a reflexivity of modeled system modeled on software - scripting overlaying itself] trajectorial model, particles and also quantum/holographic models
one view here is of objects other is streams of information flow (such as in signal-processing system)
environment model of evaluation - frames also interesting
p273 - simulator for digital circuits - event-driven simulation
concurrency - making serializers
streams are delayed lists -> stream procedures
**metalinguistic abstraction
building new langauge - new means of combination and abstraction metacircularity evaluators and lazy evaluation nondeterministic computing query system and language
**computing with register machines other side of coin - below lisp
argues that examined successive models of evaluation from substition, environment, metacircular - now describing step-by-step operations of traditional computer
language for describing register machines
register-machine simulator assembler evaluator compiler
______________________________________________ latest notes referring to some of above:
1) can envisage operations from the console manipulating/interrogating trajectorial streams and their interactions with mechanisms using descriptive language - description mapped to language mapped to lisp.
self-aware language which can refer to levels -continuations
(see: On Lisp continuations and use for scheduling processes and also see here cint.lisp)
2) language assists simulation of spacetime - ie. trajectories and collissions
(see simulation quantum computing in lisp - qgame.lisp)
-spacetime -spacetime within computation system
(see sicp on this:
in preface - central role dealing with time in computational models - state, concurrency, lazy evaluation and non-deterministic programming
"by introducing assignment we are forced to admit time into our computational models" - assignment = moments in time when values change - evaluation dependant on time of evaluation
modeling with computers -> concurrency
)
- q of a mapping - also serial/parallel - cells/particles/quantum stuff (see black hole computing)
3) PG Common Lisp markov code p 140 -
if symbol is evaluated though but must be quoted
(defparameter *words* (make-hash-table :size 10000))
(defconstant maxword 100)
(defun read-text (pathname) (with-open-file (s pathname :direction :input) (let ((buffer (make-string maxword)) (pos 0)) (do ((c (read-char s nil :eof) (read-char s nil :eof))) ((eql c :eof)) (if (or (alpha-char-p c) (char= c #\')) (progn (setf (aref buffer pos) c) (incf pos)) (progn (unless (zerop pos) (see (intern (string-downcase (subseq buffer 0 pos)))) (setf pos 0)) (let ((p (punc c))) (if p (see p)))))))))
(defun punc (c) (case c (#\. '|.|) (#\, '|,|) (#\; '|;|) (#\! '|!|) (#\? '|?|) ))
(let ((prev `|.|)) (defun see (symb) (let ((pair (assoc symb (gethash prev *words*)))) (if (null pair) (push (cons symb 1) (gethash prev *words*)) (incf (cdr pair)))) (setf prev symb)))
(defun generate-text (n &optional (prev '|.|)) (if (zerop n) (terpri) ;; prints newline (let ((next (random-next prev))) (format t "~A " next) (generate-text (1- n) next))))
(defun random-next (prev) (let* ((choices (gethash prev *words*)) (i (random (reduce #'+ choices :key #'cdr)))) (dolist (pair choices) (if (minusp (decf i (cdr pair))) (return (car pair))))))
4) take reader and analysis code here - macros or mechanisms for quote-unquote , process stuff using continuations and try and work out something - also using interpreter from norvig (but need to work out environments for streams/nodes or mechanisms maybe ->
see norvig - environment is association list (then closed over) or for global is property list
in lisp-in-lisp example is also association list
in embedded language OOP example from PG:CL. objects are represented as hash tables with properties stored as entries accessed through gethash
since functions are also data objects we can store them as properties too
to invoke a given method os an object - funcall property of that name:
eg:
(funcall (gethash 'move obj) obj 10)
or using smalltalk style message passing syntax:
(defun tell (obj message &rest args) (apply (gethash message obj) obj args))
and then (tell obj 'move 10)
what we take from lisp (from cliki:lisp):
1) quote-unquote - `( , ) eg. (defun describe-path (path) `(there is a ,(second path) going ,(first path) from here.))
2) macros -
example from www.lisperati.com:
which could be used for quote unquote:
(defmacro defspel (&rest rest) `(defmacro ,@rest))
Ok, now that they're enabled, let's cast our first spell, called walk:
(defspel walk (direction) `(walk-direction ',direction))
so instead of (walk-direction 'west) just (walk west)
but could just do
defmacro instead of defspel of course
3) read-macros
4) possibly eval
when can it be used - to implement a top level - new form is entering lisp that we have not seen before
5) recursion
6) closures - node/interp as closure - in norvig p756 example for a scheme interpreter the scheme closure is in the lisp code #'(lambda (&rest args) ...
7) code as data - functions return functions - constructor functions. symbol-functions ambivalence - node as mechanism, node as function, node as closure node-maker function returns a node which is a function with environment closure
how we can capture unbound variables?
---markov code ---PG process/continuations code ---Norvig interpreter/other interp code ---maybe look at GPS
5) design thus of a flexible framework for streams/nodes/mechinisms/levels and forms of code/data within such a framework
6) adding crash stuff here:
within history of universe as computation 2 points providing information:
a)los alamos as birth of model applied to universe - computation - input of information theory, entropy and new theory of computation within simulation atomic blah (now)
b) subsequent theory of universe as computer (quantum physics) with 10 megaton h bomb as ultimate contemporary computer
inverse time-line possibly of gravity's rainbow compressing that history
crash text to investigate:
[that paper could be written as software - as functionalities/mechanisms such as node or compression or chunking]
7) map description->language->lisp
8) frames - see norvig p493
****9) script notes:
firstly:
non-mapping of specificities
is director such a thing? or chinese restaurant
or these are made generic
to map script onto notation on either side language
fm01 not of grammars - or congealed in grammars perhaps -empty only filmic grammar or cliche of some 1940s sherlock holmes films - particularly dressed to kill or the woman in green
**notes towards possible mechanisms/constructions [to be expanded]:
1st book:
cubing operations logic of scene and of category
categories are such as of awakenings. question of relation of categories and meta characteristic here
openings listed - re-beginnings -- repetition
film mechanism inwards rewind planetary mechanism inside out - director's insides - script inside out describes its own mechanisms
film mechanism -> frame
theme - plot - character -script and curlback of these on themselves - character in/out - events
expansion outwards
line running through - sequence - film streams parallel and exchange of time lines - simulataneous or editor chequerboard. lines tied to character or ...
film factory of such mechanisms
city-at-night mechanism, studio mechanism, now-space mechanism of tape recorder, cabaret device, exposure device, now-film mechanism is a compression
film factory of revealed mechanisms - fragmented shuffling and scenic multiplication - script mechanisms, love mechanisms, investigator mechanisms - could be further elaborated as observer mechanisms
reconstruction - insertion compression - delusion
[again notes as language mapped over lisp: read-macro for a dash - or -> parallel activity of lisp work, script/conceptual work till merge more and more]
film machine notes:
text generation-organisation of modules. Film-machine as a fiction (possibly) connected also to the Centre (investigative (detective), psychoanalytical (and also bearing the cold air of a day spent clearing the leaves for a bonfire by the fallen glasshouse), concentric (link cubic rooms here) and also Centre is lodging place of film-machine - MYSTERY of whether the film-machine exists at all or whether it is (within this story) just an ill-conceived possibility made evident with poor technology of spinning disks and film-loop - whether it is just a mock-up (like the cardboard glitter of an opium den theatre) invested with false powers. It is thus a fiction within a fiction but all the same the poetic expression of a modular ongoing script and its possibilities - and expression also of a lack of an outside to a script which can reduce itself as the world to a grain of sand, to a room with all the possibilities of its future absolute diversity expressed by a work of art - that possible future diversity expressed as the coming-forth in fast time of the ongoing script as a chain of absolute fixed words. on that border of reduction and coming forth (as a device - just as the smallest element of the script becomes the overarching principle).
that the device or mechanism can be a written text which writes in its own procedures, devices but these are not to be seen, explained but there in what seems like the reconfiguring of the text - writing as if to be reconfigured eternally - or writing so that it can be in its sense reconfigured eternally - the mechanism can be like the spaces in the text of Mallarme'. writing open to all its variants which are not random but described in the text - rules contained in the poetry of the writing and in its repetitions - idea
(early notes and a format for intelligence - (writing as if to be reconfigured eternally - or writing so that it can be in its sense reconfigured eternally - the mechanism can be like the spaces in the text of Mallarme'- spaces of the text open to probability in (that) the text spaced such (is) not really being set out absolutely in probability of ordered syntax but is open to new combinations - new systems of syntax or of intelligence in a promised AI machine which is yet to come.)) FILM-MACHINE of a modern symphony - music and film action of a lonely street - emergence and re-emergence of characters through the body of the city knife night
rather than trying to place a scene - to give it a narrative frame, the only frame should be a bodily-scene - film-frame bleeding out chemistry out at the edges. no line.
Three characters only facing the camera. Suggestions for scene in "Impossible Film" booklet: eg: (( Projection from bathroom to telling (containing white nights, cube of white bathroom containing 'to be said')((commentary: location both physical and mental contains an interlocking scene)) ---- speech (to) scene told (eg. banquet) or not
DEPICTION / and on and on )).
- commentary: suggests rotation of scene telling in bathroom (domestic - beauty there) with scene told of banquet - DG - as told in chapter 11 with question of its depiction - equivalence in representation of both scenes.
EQUIVALENCE IN REPRESENTATION (modes of rep) rather than in narrative.
FILM MACHINE - scenes as sunsets, as banal risings and mornings in the moment, exercises, routines, poetic scenes, films-scenes-exercises, shots, zooms, cut-exercises, rehearsal failings - bodily film-machine all these things being the elements.
self-consciousness choke mechanism
9) J. R. Meehan, "The Metanovel: Writing Stories by Computer," Yale University Department of Computer Science, technical report 74, 1976.
10) streams delineate chunks of code/data but perhaps chunks is too static = have-happened and also code/data split whereas should be more question of simultaneous interpretation of data nature as ...
11) crash: carriage - de quincey -> steam engine entropy -> information theory entropy -> los alamos h bomb and h bomb as ultimate computer (no information loss) maybe crash as h bomb explosion
types of crash is important: a) segmentation fault -
A segmentation fault occurs when your program tries to access memory locations that haven't been allocated for the program's use.
application crash
b) system crash - freeze (functionality) - exposure - blue screen (fatal exception)
interruption in OS or application functionality - exposure - cynicism - delight in that exposure
crash/extrusion-revelation and in-turn on fissure of decidability
crash of a reality-bound OS
to map crash -> fm01
12) compression and decompression - non-relation of script->film
13) interfaces not objects
14) re-arrival of notion of cross-matrices and possible weightings a la cur -
chunking multi-channel matrices for data - word, sound, video - as in latest cur chunking operations at higher level of an arbitrarily (or not so) assigned block
or maybe pd coded chunking component or extension so we can plug together with fft or whatever and with ap pipes - readymade pluggable architecture - but want own lisp environment so need solve question of multiple textual/data outputs
want complete new OS layer (on Movitz?) - streams model and our other abstractions implemented (though Unix pipes is close)
question is of design/abstractions and implementation stream in and out nodes - lisp at low-level common lisp music examples perhaps
re-looking at embed question - but not so convinced of embed lisp in c as answer
though may be worth looking at librep as used by sawfish (wm) and jade (editor)
python has good stuff (pickle and apply) and functional style but without macros
question of low-level work with Lisp - SICP may have examples
15) mobile code at higher level which embodies abstractions - macros shared with some indication of usage - but question of this vs. flattening of code - that if code-chunk markers are placed in streams - or all code approach - data as code so data can be interpreted with instructions which act as markers
mobile code and interpreter attachments - input and output mechanisms in lisp to achieve simultaneous prompt attachment to access environment and evaluate input alongsude continued ascii data output (where this stream is directed - a technical issue of tapping in - sockets or shared memory model - or new higher abstraction)
-> system-OS for multiple streams - complete environment for our abstractions what libraries to implement such a layer - yes, a vm or emulate imaginary machine a la usim (see below)
examples. eg. lisp machine - how I/O handled in that instance
multiple streams addressed to re-configurable devices - again q of C with embedded interpreter arises
16) crash research:
kittler? zuse article - calculating space welt am draht - see later notes -> 13th floor. miscarried edge of a simulation/replaceability of observers everett - many worlds theory
**17) past research on qish: The Qish system should be able to introspection. This means inspecting continuations (e.g. frames on the call stack).
revisit this. also eurisko and what artm is upto
see also usim:
a simple hack designed to emulate the CADR microprocessor hardware. A CADR is a second generation MIT lisp machine. A good description can be found in "A.I. Memo 528" from the MIT AI Labs entitled, "CADR"
18) fm01 proceedings:
a) compress these notes towards a definition b) process-node model - also paper on lemonodor of without-process c) examples inc. framer (in C) and met Nigel Morgan - symbolic composer environment d) embed question
19) welt am draht notes:
a) simulation - mirror - how is seen - what do you see? death of / insertion - insertion and not one as other simulation
b) all such versions as themselves film
that it is not really about computation (though necessary as conduit or whatever - reflexivity of history computation -> simulation/simulacron-3 notion - human-machine )
thus fm01
within a film simulacron-3 is possible - as generating film and in non-observer/all-observer flatness of film
c) individual->universe simulation of universe - single person/observer
kopf as simulation machinery - again reflexive here
multiple stream ouptuts of fm01 channeled OS channeling/piping
d) universe computes itself - levels of abstraction and question of position of OS within this - universal OS-interface
e) film->script relation
kafka's castle - waiting for the script-backward mallarme - script-project-forward - behind the script projecting
f) in simulacron-3 implied truth (or nestled implied truths a la cronenberg ??)
truth operator and truth markers
20) from above crash->fm01:
a) truth operator/marker b) overlap and observer process/machinery
21) other approach than complete OS . more oriented towards a mockup:
if what interested in is data/code then writing/reading to/from FIFOs (for use by C code - sound app, display or to output devices or use by PD whatever and perhaps with further OSC interface (see artm) and of course all manner of promiscuous input devices is perhaps answer - though must first attach all listening fifos for this to work is ok)
sample code in test2 is for q simple use. (note - how can multiple processes access same FIFO ?? - or just processes pipe to multiple fifos which can form a matrix)
22) crash as a question of interface - OS=interface if a higher level interface crashes we need some hook in at a lower level - need to find another interfacxe to the OS also Q of abstraction - crash is an issue of abstraction to some extent
23) neural model of connectivity and clustering - parallel groupings - mechanisms form and re-form - model of interaction between processes which can be related to frames as in both norvig -> p493 (object with slots) and in SICP - (3.2 - environment is a sequence of frames, each frame is a table of bindings - see more notes)
frame and relation to chunk
from model outlined above, with processes (PG- On Lisp) and reflexive use of continuations + streams (non-deterministic scheme in SICP p411 parallel branches migrated - choices-branches explored and backtracked on failure - p427 execution procedures and continuations) - also with multiple interpretative processes and some kind of message passing (again see PG) -> towards fm01 (also multiple streams -> FIFOs and maybe use this in a LISP SHELL - which would be emacs i guess - to research) - and then use this mobile, stream language with no time of execution fixed as start for fm01 abstractions [primitives, means of combination, means of abstraction]
also from sicp - mechanisms - our notion of mechanisms could be viewed as procedural representation - 2.4 and 4.2.3 = message passing implementation
- is just about performaing fm01->lisp abstraction mapping over all of this
see also Robert Strandh - what stuff does he do? + recent Gracle thing of his - no hierarchy and threads sharing address space rather than processes with seperate space
24) in note form - that as j says in l'homme machine
mechanomorphism - the seeing of humanity in the light of whatever machine dominates contemporary life - in 1750 with http://www.cscs.umich.edu/~crshalizi/LaMe ttrie/Machine La Mettrie "L'Homme Machine" it was the clock - and in the 60's a watered down vision of man machine symbiosis was put forward by <a href="http://me dg.lcs.mit.edu/people/psz/Licklider.html">Licklider</a> as a means for controlling complexity - typically nowadays we call a computers storage of data a "memory", and HCI's impose functionalist models on the user as an idealism, fine tuned and executed (and conceptually stalled) as the user is effectively incorporated into its models<br>
but is further than seeing humanity - is ontology - what is is seen in terms of computer - nothing new - universe as mechanism, mechanical clock but what is new now is notion of crash - of interface - itself and not itself as outline in welt am draht and rest (ignore matrix for aesthetic reasons - also matrix shares with 13th floor - yet another descendant of Galouye's simulacron-3 - shares bland revelataion, hitting an edge of the simulation - beyond that edge truth - 2 realities - illusion and reality - in contrast welt am draht - world on a wire - 2 part fassbinder tv series overlapping of interior welt simulation with making simulation, being outside - mapped interior kopfschmerz of two holdings - constructing and constructed overlap -> crash
scope thought but lost>>>
25) ap work >
a) re-examine mirroring functions b) parallel ap instances - using coarse grained instruction set for manipulation of ap data sets/chunks c) lisp style instructions and recursion in parse tree - a la koza so is blocks of functional code d) thus port of ap to lisp - how one could proceed with this?
//////2005+
26) fm01 -> processes, environment frames and interpreters -
some kind of code stepper which can catch unbound stuff and also implement reflexivity - code nodes/streams and stepper functions/mechanisms work together/communicate
or reflexive continuations. exchange of continuations
awareness of levels and cut - code/film itself
one aspect is abstraction other is pure infrastructure
if we pretend that such infrastructure exists for mobility of environments, streams and mechanisms
documenting own code itself - outputting own code as proceeds wrapping itself
27) A universal dovetailer is a program that systematically lists and executes all possible programs for a universal computer such as a Turing machine. Here are some Internet links related to dovetailers
---------- 28)
**post-crash notes centring around crash.lisp excerpted here
question is whether functions are evaluated by our own interpreter
- should be multiple interpreter processes running. each node is a process which is running its own code (code runs in/on lisp implementation or if we collide with an interpreter node than is run by interpreter
we are working entirely
;;note that can set up structure with eg: (defstruct proc pri state wait) ;; then do ;; (make-proc :state #'(lambda ... ;; :pri ,pri )) - from paul graham process example
(defstruct node trajectory state wait code x y z)
node should also be carrying data such as environment (for interpreter) and continuation
(defun calculate-trajectory (node-space) ;; recurse through node-space ;; doing: (node-collide (node closest node(node node-space))));; but node-space must be full space not recursed space
(defun node-collide(nodea nodeb) ;; are any/both interpreter nodes ;; node code-join-interpret and new trajectory )
;; working with processes - proc-state but how do we refer and pass around processes - or work solely with list of processes - well process must have a name we can access...
processes=nodes
;; other basics ;; embed, break, cut, expose, reverse + see fm01 for more
here are some basic processes - they operate on processes and return processes?
(defun embed (process) ;; place process inside - find process from list of processes and then place as list inside itself - or use *cont* ")
(defun dovetail (process) ;; place two processes next to each other )
(defun break (); all functions operating on processes//processes=continuations
(defun repeat ()
repetition of data - or in other forms a repetition which ensures the safe arrival of that data (within a layered protocol - layered in terms of abstraction) - how long to wait for such a repetition to become evident - to distinguish a meaningful mess age from noise(protocol/ halting problem) )
;;note welt-am-draht as key process on a fulcrum point yes-no binary // also fulcrum point of noise/information 01 ;; this process makes use of mallarme and kafka scripting and spacing ;; somewhere is gravity_rainbow trajectory - v2
(defun time-reverse (process)
))
(defun many-worlded (process) ;; must have something to do with continuation (progn (spawn (embed process))))
(defun spawn (embed process) (progn (program spwn () (fork (process) 99)) spwn)
(defun make-interface (observer level_of_abstraction continuation)
;;(defun interface.... abstraction level->continuations
(defun self-refer(object) ;; print properties of the object-structure
(defun crash (&optional interfaced) (progn (set-fulcrum (halting_problem (decidability))) (embed (many_worlded (crash (make-interface)))) ;; does it return a process?
(defun godel-proof ;; why not? (princ "generating all possible papers
gp-ud universal dovetailer> marchal
everything-list
* <-- Thread --> * <-- Date --> * Find
Re: Revised Computing Randomness & the UD
Marchal Sat, 21 Apr 2001 10:21:12 -0700
Hi Hal,
>These are some of the things I want to explore as a result of formulating >my question re the UD. > >To start: > >1) Are you saying that the UD contains all other computations as data?
No. The UD is a program without data. It generates and executes all computations. It "dovetails", i.e. it executes all programs by little pieces, so it does not stuck itself in a non stopping computation.
>... But for sake of covering all bases I thought > "compute" = "prove" was established by Turing.
The work of Post, Church, and Turing (and others) shows the contrary. It shows the abyssal difference between provability and computability. Godel realises that his own incompleteness protect Church thesis and gives to the notion of computability a miraculous absolute nature. At the same time it shows that provability is always relative to a choosen formal system. That is what makes the Universal Dovetailer really universal. It computes everything computable, but is does not makes proof. If you look at it as a theorem prover, most formal description of the UD will give a not really powerful theory.
>3) If in order to work the UD contains all other computations >as data then the UD is a highly complex program. ...
I wrote one in LISP. It makes more or less 100 lines. You can write very little one in PROLOG. It is not a highly complex program. But, please, the computations are not the data, they are the output.
>Random strings are complex and I thought "all Theorems" was a very low >complexity object. Or is it random?
It depends how you code it. "All theorems" is an ambiguous expression. Never use the word "theorem" without mentionning the theory. "All computations" is not ambiguous (it does not depend on the formal system in use). In some sense Chaintin OMEGA number codes all computations in a terrible compressed way. It is "random". But then there exists nice natural way to encode all computation in a non random, but deep (in Bennett sense) manner.
>4) Why not run a highly parallel computer rather than a UD? [That is rather >like a part of my model.]
First, the meaning of quasi-geometrical word like "parallel" are among the things I want explain. I cannot take such meaning for granted. Actually, with some terrestrial sense for parallel, it will not change a thing in the limit (see the UDA argument which explain why).
Also, The UD has a property I never mentionned, it generates by itself an infinity of variant of itself which on almost all inputs (almost all = all with a finite number of exceptions) is "quasi-infinitely" more quick. The UD is self-speedable. But that is not interesting, for the UD does not need to go quickly. Conscience and matter are inside view of UD*, the complete (infinite) work of the UD; belonging to Plato's heavens.
>5) My meaning for "knowing" is at first order like proving. Chaitin is >actually talking about the complexity of the FAS's theorem checker as the >complexity of the FAS. The theorem checker "knows" all theorems of the >FAS. If a proof is an elegant proof by default then the theorem checker >also knows this proof or it would not know how to check the output for >theorem hood. It can prove this proof is elegant because there is no other >choice.
OK. But be careful. In my work knowing is quite different of proving. The modalities are not the same. This will be discussed in my explanation to George Levy. In fact I will define at some point "knowing p" by proving p and p is true. knowing and proving will appear equivalent only for the guardian angel, but the consistent machine cannot know that, nor prove it!
Bruno
You could have chosen the empty program as well. I suggest you write a real UD :). That is : you choose a universal machine, and you write an explicit generator of all the possible execution of your universal machines. (= about 10 lines in PROLOG, 100 lines in LISP, 1000 lines in FORTRAN). If you are courageous, you can write a dovetailer on the solutions of the Dewitt-Wheeler equations ! Note that a UD is (recursively) equivalent to a program which almost compute OMEGA Chaitin number."))
(defun overlay (overlaid) ;; made use of in de-quincey compression process and burroughs cut
(defun de-quincey-compression (subject-to) ;; make use of overlay
(defun los-alamos-compression (subject-to) ;; starts with de-quincey expansion which envelops the journey (progn (de-quincey-expansion (subject-to)) (time-line ...;; produces and enacts on itself own reversal
(defun burroughs-cut (subject-to) ;;make use of overlay ;; yielding of processes (princ "description of machine able to switch from record to playback without stopping the machine.
instructions/post-description: I recorded a few minutes in all three rooms. I recorded the toilet flushing and the shower running. I recorded the water running in the kitchen sink, the rattle of dishes and the opening and closing and hum of the refrigerator. I recorded on the balcony. Now I lay down on the bed and read some selections from The Magus into the recorder.
I will explain how these recordings are made. I want an hour of Spetsai, an hour of places where my M.P has been and the sounds he has heard. But not in sequence. I don't start at the beginning of the tape and record to the end. I spin the tape back and forth, cutting in at random so The Magus may be cut off in the middle of a word ...") )
(defun de-quincey-expansion (subject-to) )
(program write-crash-paper () (fork (path) 99) )
---------------------------------------
29) question of multiple interpreter processes (convert process-continuation code to step in parallel through such processes) - and attached or unattached environments
also worth noting as examples:
a) chaitin omega/lisp code (and bruno marchal dovetailer stuff in crash dir)
b) Erunticlab alife thing which makes use of a code stepper so that animals/ga things can execute code with pseudo parallelism - defines functions in lisp and registers these with stepper - functions combined and used by animal codelets (eg. go_forward function). look at interface to stepper
c) clm - run macro again in run.lisp
30) code in nodes and code that can also attach/generate trajectories