"n=m+1" notes and a word on the Arrow Paper

[RE01 Rice Brian T. EM2]

earlier comments on arrow types:
<<
type restrictions in Arrow:
this is a very strange combination, since Arrow doesn't restrict anything
implicitly.  i did this half-intentionally, but i am beginning to be
comfortable with the results.  you really have to _tell_ the system that you
want to stick with a context (or any part thereof).  (you can even give the
system _rules_ about contexts, and reflect on them.)  the reason is that
there simply are no errors to make, only new contexts (sometimes a hell of a
lot and sometimes undesired).  in this way, i've learned not to think about
errors, but instead to try and focus on the desired information state of the
system.  it's an interesting view on information sharing, since in the new
way of looking at things, a cleaner (more well understood) division between
contexts is desirable.  that's because the shift between contexts is the
focus, and it has to work even if you remodel your view(s) of the system.
this provides an ideal system for translating information (i.e. meaning)
between two independent domains.
>>

the following is an attempt to elaborate and to clarify:

i want the system to exist at a level that is "sub-structural" (i know that
the word is wrong, but it fits well) to the ideas of language and logic.  it
is obvious that languages offer constant standards of abstract meaning:
that's the purpose of a language and the purpose of a standard.  the
_limitation_ of this purpose is that some algebra for creating new languages
and standards from the old ones is presently lacking.  the Arrow system
allows us to circumvent these limitations by assuming no "wrongness" about
anything.  in other words, there is no implicit meaning.  instead, there
merely what is _constructed_.  the way that a user or agent _forces_ the
system to focus on a single context (or equivalence class thereof) is to
specify that very thing (model-level reflectively).  it's as though the user
specifies information about what paths through the space of context that an
agent may take.  since the system knows of the user in only an indirect
manner, i.e. by assuming that the user acts as an agent and making
reasonable assumptions about that agent based on user input, then this
manner of specifying an agent's behavior allows the system to define
inter-system interface (as well as user-interface).

this means that the notions of "read-only" or "primitive" or "constant" have
only a _relative_ meaning to the Arrow system.  i'm going to assume for now
that this relativism is according to ontology, not frame or context.
"violating" the permissions of a read-only variable is no longer "wrong",
but instead causes a context update which the system should encapsulate.
however, all system updates cause context to change, so that changing
constants should merely be an issue of interface to an information system.

About the Paper:

all of this seems like "primo" Tunes material, and is almost ready for
inclusion into the final copy of the paper.  i'm considering allowing the
paper to "balloon" to about 60 pages in size, drastically reducing the
density of the work, and elaborating with examples and drawings.  this will
have to form the central exposition of the theory of the system, and as such
should form the core of derivative work.  of course, more about the theory
of the system should come to light as we continue, so that it should not be
a "reference" about the subject.  this leads me to wonder about what to
title the thing.  any suggestions from the peanut gallery?
also, since the paper is as such unsuitable for conference presentation
(being relatively dense and centralized), i'm going to write some quick
summaries (roughly 10 pages per paper) for various conferences.  i intend to
use these to introduce my ideas at conferences and universities if possible.
obviously, some introduction work for category theory and arrow logic and
the basics of meta-programming has to be integrated or well-referenced as
well.  i'll be working on this, soon.