Miser Project: Interpretation, Representation, Computation, and Manifestation

2019-11-06 Update: This blog is obsolete and no longer being maintained here.  These Miser Project Posts are now maintained and continued at  Orcmid’s Lair, the reboot.   The authoritative version of this page is now at

“When a Mathematical Reasoning can be had it’s as great a folly to make use of any other, as to grope for a thing in the dark, when you have a Candle standing by you.”
— John Arbuthnot, Of the Laws of Chance, 1692.

Miser Project conception starts from reasoning with and in certain mathematical structures.  That foundation applies mathematical thinking in establishing a model of computation and subsequent reasoning about programs and their dependable employment for practical purposes.  It is not necessary to digest all of the mathematics in order to develop and use the eventual software.  It is expected that provided there is trustworthy assurance of suitable quality, an objective of the mathematical route: someone has done it checked the math and verified the software in a transparent and trustworthy undertaking. and that undertaking is transparent and trustworthy.  

I strongly recommend the wider and practical context presented in Edward Ashford Lee’s recent book, Plato and the Nerd.  For the Miser Project, “theory” andcontext” are often used in place of Lee’s use of “model” and “paradigm.”   The Miser Project use of “model” is reserved for a mathematical- logic situation around interpretations of theories, a flavor of modeling (or theory-building) that exposes the marvelous utility of computers as instruments of human purpose and experience that Lee addresses.  The notion of ontological commitment is put forth as an informal alternative to paradigm when stepping into a particular perspective is undertaken intentionally and with self-awareness of the manifest context.

The Eugenia Cheng book, The Art of Logic: How to Make Sense in a World that Doesn’t looks critically into affairs of the world from a mathematician’s perspective.  More profound than the narrow application of mathematics in the Miser Project conception of computing, Cheng’s video on “How to Think Like a Mathematician” reveals some connections with the structures portrayed in boole.txt and the as representations and interpretations related to ‹ob›.

In the course of the Miser Project and demonstration of computational power and limitations,  some specialized concepts are depended on appealed to.  They are elaborated here in this post.

2019-11-04 Penultimate Draft: Some major adjustments and stitching in notions of ontological commitment prior to digging into the ‹ob› computational model direction.

2019-04-02 Intermediate Refinements: Additional diagrams and adjustments to smooth the narrative, reflecting suggestions by colleague William L. Anderson

2019-02-11 Initial Public Draft: Lengthy article navigating some concepts that will arise continuously in narration of the computational model and its representation in computational processes.  For reference and review as background to further articles.


      1. Hark! Is That a Theory I See Before Me?
      2. ‹ob› Primitive Functions
      3. Narrowing ‹ob› for Computational Interpretation
      4. Representing Data as Obs
      5. Representing Functions in ‹ob›’s Abstract World


  1. Recap: Computation-Model Stage-Setting
  2. Structure, Interpretation, Representation, Computation, and Manifestation
  3. Review: More About Structure
  4. Concerning Representational Ambiguity
  5. Choreography of Computation
  6. Manifestation and Tacit Awareness
  7. Ontological Commitment: Layered Abstraction

1. Recap: Computation-Model Stage-Setting

We have not escaped from mathematical entities so far in this series of articles, apart from one programming-language mock-up of an ‹ob› computational interpretation.

At this point, these articles address ‹ob› = 〈Ob,Of,Ot〉having a domain of discourse, Ob, that is a flavor of abstract data structure, strictly on theoretical terms.   With regard to computational interpretation, effective-computability is then taken as a condition on deductions that are available given a particular mathematical representation of a function or predicate. The transition from an effectively-computable representation in any structure to an operational computational process of any kind is suggested, with interpretation in ‹ob› as the path to demonstration. 

Interpretation of other structures and their effectively-computable primitives via  representations in ‹ob› sets the stage for  valid computational interpretation satisfying in the ‹ob› computational model. That is, if we are satisfied about the ‹ob› computational model, then we have an indirect means for enactment of computations with respect to other structures that are successfully interpreted in ‹ob›Such transition from other/higher levels to ones tied to the lower-level computational model demonstrates applicability of computational interpretation.

It is posited that the interpretation-in-‹ob› approach is sufficient for computational representation of the same effectively-calculable mathematical functions as any other recognized model of computation.  Demonstration of such universality (i.e., Church-Turing computability)  and common limitations of that universality is one Miser Project objective: making this aspect of theoretical computing accessible in practical, demonstrable, and understandable terms for computing practitioners and other interested parties.

The  ‹ob› model of computation, although very simple, is a sufficient foundation for computational-interpretation by stored-program operations that manifest layers of abstraction.  By stored-program is meant taking obs themselves as scripts for operations on obs taken as operands.  Such scripts can direct derivation of obs to be taken as further scripts, illustrating how computer programs (e.g., compilers) are used to generate (compile)  further computer programs from descriptions in their data (e.g., programming-language texts), extending the practical reach of computer applications.

Narration of the ‹ob› model of computation is the subject of the next series of blog articles.  The model is founded on two function representations: one by obap.ap(p, x) and one by obap.eval(e).  The operands, p, x, and e, are obs.  Given definite obs for operands, any determined result is a definite ob. 

Dependable manifestation of the computational model in implemented operations of a physical digital computer rests on empirical determination that the computer’s performance yields valid computation-model interpretations.  All of that will be explored.

2. Structure, Interpretation, Representation, Computation,  Manifestation, and Ontological Commitment

Some informal notions are adapted and restricted in the context of the Miser Project. These specialized concepts assist in capturing the essence of computation and its practical application.  This framing is not the only perspective.  It is offered as one useful way to appreciate computation by digital computer procedures.  Briefly, in rough progression.

  • Structure
    mathematical characterization of theoretical entities in terms of domains, primitive notions, and applied logical theories
  • Interpretation
    • mathematical: arrangements by which one mathematical structure is modelled in another using a mathematically-demonstrated correspondence
    • linguistical: interpretation of a text in a (standard) semantic domain, including computation-model interpretation of programming-language texts
    • empirical: engineering of mechanized operations confirmed to satisfy a model of computation;  realized computational interpretation
    • social/scientific: identifying objects in physical/social reality as evocative of theoretical entities, and sometimes vice versa; taking such determinations as pertaining to relationships in contingent reality
    • typically, standing in some structure and projecting its fundamental entities on some other theoretical structure or experience of nature that satisfies the original in some (contingent) manner.
  • Representation
    • mathematical: formulation of mathematical functions in a given structure’s theory language, effectively determining the nature of the functions as theoretical entities; notionally, mathematically-equivalent formulations of the same function can be taken as having the same functional interpretation representing the same function.
    • conceptual: the entities and functions of one structure that serve as interpretations (representatives) for those of another, thereby representing that other structure; ideally, the represented individuals entities are readily discerned upon inspection of (computationally) derived representations representatives. (presentations are traceable back to the intended interpreted entities in a particular context)
    • reflective typically: a representation may provide multiple entities representatives that are equivalent as valid interpretations of a single of the same entity in another structure; in general, representatives are not exclusive to some particular representation, context being required to ascertain the entity the representative is an intended interpretation for (e.g., the propositional algebra simulation by ob.p01.bp in contrast with the subsumed ob.NE.bp interpretation many ways that every single ob is representative in interpretations of Boolean Algebra elements ob of ‹bp› as in boole.txt).
  • Computation
    • conceptual: performance of (algorithmic) procedure p such that representation of some entity x, the operand/data, is transformed into a representation of y satisfying specified functional relationship y = f( x )
    • informal: the result of a computation, spoken of as the represented entity (e.g., “the square-root of x”, “the estimated fastest route from city A to city B today”, or, “interactive achievement of the end-game in Tomb Raider”)
  • Manifestation
    • general: perceptual object of attention recognized in as evocative (manifesting) some other object or activity
    • operational: act of producing/presenting objects or activities taken as to be so evocative
    • interactive: with computer systems, the appearance evoked in the representation of computational results/operation on some medium (e.g., the perceived images on the surface of a computer-operated graphical display)
    • tacit: objects perceived as being manipulated via interaction with a computer system operating in keeping with manifestation fidelity, (e.g., the conceptual document simulated via word-processing software)

  • Ontological Commitment
    • linguistical: speaking of (theoretical/conceptual/notional) abstract entities as if they exist apart from manifestation in language (e.g., unicorns, numbers, the obs of the mathematical structure ‹ob›)
    • pragmatic: granting being to manifest entities (what a manifestation is said to be of) and the means of manifestation (what the manifestation is without considering it as a representation), while avoiding category error: confusion of the entity manifest with a manifestation of it, notwithstanding the practical fidelity by which the manifestation is sustained
    • tacit: granting existence to non-perceivable entities that arise exclusively in language — can only be talked about — whatever the agreement and behavior concerning their reality; such commitments can constrain/oppose others.

3. Review: More About Structure

Expositions of mathematical structures such as ‹ob› = 〈Ob,Of,Ot〉circumscribe particular theoretical entities in a mathematical-logic framework.  The general pattern is ‹s› = 〈Sd,Sf,St〉.

    • Sd signify the domain of discourse, the collection of entities all of a single kind that are the subject of variables, such as x, y, z, in expressions of the structure (with universal quantification, such as with ∀xyz, usually implicit)
    • Sf signify all of the functions and predicates with operands and function yields in Sd.  Individual functions become know by their representation using St.
    • St consist of the expressions that establish primitive notions, axioms, and function representations using a mathematical system of logic.  The subject matter is always Sd and explicitly-represented elements of Sf.  Certain functions and predicates may be taken as axiomatic, with all others expressible in terms of those.

For the Miser Project, St is typically an application of First-Order Logic, usually with = (FOL=).   This is the case of ‹ob›.

Distinguishing mathematical structures in this manner allows examination of multiple structures and connections among them.  To be explicit about a structure being appealed to in a given discussion, prefixed names such as ob.c, ob.NIL, bp.top, bvn.comp, and ob.bvx.cf provide clarity in identifying the “host” structure, entities of that structure’s domain, and the entities being interpreted  as particular representations there, and the specific means of representationSo far, in addition to ‹ob›, the Boolean Algebra structure ‹ba› and its kin ‹bp›, ‹bn›, and ‹bvn› have been explored along with various representations in each other and in ‹ob›.   The curious representation, ob.bvx, of any Boolean Algebra on a denumerable domain will invite further attention in the computational interpretation of number theory.

Structures evoke theoretical entities.  There is no inherent suggestion of material or natural existence.  Rather, the Sd and Sf arise entirely in language St and live entirely in mathematics, so to speak.  Whatever conceptual notions one might harbor about the subject of a structure, consideration and discussion of the properties of such entities is confined to what can be reconciled entirely via expression and deduction in applied-logic theory St, along with any informal statements (meta-conditions) that restrict/inform the constructions and valid deductions.  There is no necessity of ontological commitment to such theoretical entities, although it creeps into our speaking of them nonetheless; it is a matter of linguistical economy.

4. Interpretation: Variations on a Theme

Matters of interpretation arise in varied forms with respect to the Miser Project.

Mathematically, “interpretation” is used with regard to a correspondence between one structure, ‹A›, and another, ‹B›.  Typically, there are four parts:

    • Match each element of  ‹A›’s domain of discourse with a distinct member of ‹B›’s domain.  Given x in ‹A›, signify its interpretation in ‹B› by Ix.
    • Represent functions and predicates in ‹B› that are interpreted as representations of corresponding identified as corresponding interpretations of the primitives of ‹A›. 
    • If the theory of ‹A› is an application of FOL=, represent interpretx = y” of ‹A›  with ‹B›  predicate b.I.a.is-eq(Ix, Iy), or simply  Ix =I Iy.
                   b.I.a.is-eq(Ix, Iy) ⇔ Ix = Iy
      in Bt of ‹B›, the interpretation is said to be an implementation of  ‹A› in ‹B›; otherwise, it is said to be a simulation of  ‹A› in ‹B›.  The use of I (in bold or script) is made specific in terms of ‹B› representations when it is necessary to distinguish among multiple interpretations of ‹A› in ‹B
    • The interpretation is valid when all deductions in structure ‹A› are mirrored by deduction of the corresponding interpretation in structure ‹B›.

Diagram illustrating the interpretation of x and y of ‹A›  as Ix and Iy in ‹B› such that when y = a.f(x) in ‹A›, b.g(Iy) in  ‹B› determines Iy.  Part of the interpretation is demonstrating b.g as representing a.f and also determining a correspondence of "=" in  ‹A› with an equivalence relation in  ‹B›, also suggested in the diagramValid interpretation of ‹A› in ‹B› need not capture all features and entities of ‹B›.   Validity achievement only signifies successful interpretation of ‹A›.

An intended interpretation of a structure might be invalid.  In that case, the offered interpretation may be defective or the structures ‹A› and/or ‹B› ill-suited to the intended purpose.  Resolution of the matter is external (meta) to the structures themselves.

The diagrammatic use of arrows, above, is suggestive of constructions in mathematical category theory.   That is inessential here; informal use of interpretation, including for non-mathematical purposes, is sufficient for computation-model formulation.  Consideration of rigorous category-theoretical approaches is deferred.

Texts or other concrete forms of expression satisfying a formal grammar can have specified interpretations as entities in a structure having computational interpretation.  That form of interpretation will be demonstrated with the parsing of expressions that are interpreted in terms of some construction, such as ‹ob› computation-model operations.

Interpretations are also made between entities of mathematical structures and domains of non-mathematical character, such as observations in nature, predictions of scientific theories, and many practical and artistic situations.  Acceptability is an empirical matter and depends on the particular circumstances and disciplines, such as (always-provisional) scientific confirmation at some scale of appearance/fidelity.

Representation and manifestation are often intertwined with interpretation.

4. Concerning Representational Equivalence Ambiguity

Mathematical representation of functions has been illustrated with examples for ‹ob› and also for functions that serve as the interpretation-in-‹ob› of functions in other structures, such as those prefixed ob.p01.bp and ob.bvx.   It is generally the case that there are many representations of a single function, based on the principle of extensional equivalence: when f( x ) = g( x ) for all x, f and g as defined represent the same function.  In these cases, the equivalence is rather sideways, signifying interpretation as the same entity amidst all the functions of the same structure.

“Representation” is used in one other sense here with respect to conditions on the structure ‹B› in which interpretation of structure ‹A› is established.  Representation is akin to establishment of a portion of ‹B› that encompasses the interpretation of ‹A› but without restriction to uniqueness of representatives (although uniqueness is not ruled out).  Many entities, the representatives, of the representation of ‹A› in ‹B› may be taken as equivalent interpretations of  interpreted as the same entity in ‹A›, including the designated (characteristic or canonical) interpretation of that entity in ‹B›.  In this manner Equivalent representatives reflect back to a distinct entity of ‹A and any of them can be regarded as if interpretations of that entity in ‹B

Representation in this manner is not arbitrary; validity of representation hinges on preservation of interpretation validity among all substitutions of equivalent representatives.   Valid representations are entirely interpretation preserving. 

An intended representation is entirely in ‹B› and, generally, the same entities and ‹B›-represented functions are not excluded from employment in any number of other representations, whether in respect to ‹A› or some other structure

For example, in boole.txt, the (section 2.3) the ob.NE.bp representation of ‹bp› in ‹ob› is strict with respect to interpretation of the ‹bp› domain entities ⊥ and ⊤, along with corresponding function representations of the ‹bp› primitive notions (axiomatic functions).  In contrast, the (section 2.5) ob.p01.bp representation preserves the ob.NE.bp interpretation while having every ob represent one of  ‹bp› ⊥ and or ⊤.  The ob.p01.bp functions corresponding to ‹bp› primitive notions properly simulate ‹bp›. the interpretation.   The function ob.p01.bp.comp( x ) and agreement on canonical form are revealing in respect to  interpretation ob.NE.bp consistency and interpretation preservation as canonical in of the ob.p01.bp representation.

The boole.txt (section 3.4) representations ob.bvx of ‹ba› demonstrate that the same ob can serve in many representations.  It is not intrinsically-apparent which representation (whether ob.po1.bp, ob.bvx, or something else entirely) is intended.  When particular canonical forms are observed, it is more suggestive, yet not conclusive.   (Nevertheless, gifted accomplished computer-software maintainers are excellent at inference of the purpose of program aspects and identifying consistent repairs for representation breakdowns.  That’s based on domain knowledge and the context in which the software is applied as well as not merely cues in the code.)

It is valuable to express derived obs in a form that signifies what they are intended representatives for. what they represent other than merely obs as themselves, in specific situations.   Such discrimination of representations and related cases involving tracking of interactive-operation states and ephemeral entities are beyond the  ‹ob› model; they’ll be investigated once the “pure” ‹ob› computational model has been explored.  For now it is noteworthy that obs themselves do not reveal intended representations and that serves computational representation quite well as a in the computational-model foundation formulation.

5. Choreography of Computation

Computational processes are abstract beings that inhabit computers. …
A computational process … cannot be seen or touched.  It is not composed of matter at all.  However, it is very real.
   — Building Abstractions with Computers, Chapter 1 in
       “Structure and Interpretation of Computer Programs,” ed.2

Mathematical structures can be thought of as static: “standing still.”  There is a domain of discourse, such as Ob, and (functional) relationships; deductions can remain to be established.  Just the same, nothing moves.  It is as if it is all there in the first place (whether or not there’s any actual “there” there).

“Computational interpretation” has been insinuated as the movement from the mathematical stability of a structure such as ‹ob› to some mechanical process that is carried out, different than the deductions and qualification as effectively-computable, yet consistent with that computability.  Something moves, something processes.

Although computational procedures can be animated in a manner that allows the process’s stages to be observed, that is not so easy in writing about it.   And that’s not so great in an elaborate computation with representations far removed from the nature of the (familiar) entities being simulated.   We need an useful depiction that somehow suggests the essence of computational processes.

Golden Geek article on "Computation as Performance, Part 1: Engine OperationThe depiction of a computational mechanism in operation will be illustrated with a diagrammatic pattern, whether animated or not.  The rotating gear and flash of power is a pattern for depicting computational performance put into operation action.  This could be a human performance, although our focus is on digital computers and their computational procedures enacted with them.

depicting the input and output encoding of data to the computational engineConsider that the performing machine operates on some (relatively) tangible form of input to be processed, yielding production of an output result that depends on nothing else than the input and the performance of the machine.  Here the I, M, and O signify the particular input format, mechanism, and output format.  The subscripted ein and eout refer to specific instances of an encoded input encoding and an encoded output encoding.

Modfication of the computational process diagram to show matching/coupling of the input and output formats and the formats that the machine interprets and derivesIt is valuable in this diagrammatic approach to have input and output formats need to couple properly with the nature of the computing mechanism and its performance.  Conformance of the input-output formats with provisions of the mechanism are signified by sockets that couple the input-output with the respective aspects of the mechanism symbol.  In this simple input-processing-output diagramming, it is a condition that the specification of the mechanical-operation process have the input and output characterized in the same terms — levels of abstraction — as and the input and output formats are be described in the same terms – a consistent level of abstraction.

The abastraction levels at which the Input, Machine, and Output reside is contrasted with the interpretations that have been arranged to be preserved with the choice of machine and representations in the Input and Output formatsThe idea of encoding is critical in grasping what the computation amounts to and also how we consider the use of the computation by representing (encoding) entities of interest.

At the level of the device, M, the M?:I→O symbolism is short-hand for the function by which every input, ein has a determined output eout in accordance with an assumed procedure’s performance at that level. This is itself likely to be an abstraction above the physical mechanism, whatever its form.  The M?:I→O procedure has a description to which the machine’s operation exhibits fidelity in the sense that procedure’s conclusion predicts the output of the machine for a given input.  Although the description of the procedure is static, this diagram signifies it being carried out mechanically.

In making use of the device/computation, above, there is also potentially a superior level of abstraction.  Consider interpretation of taking some ein as representations of values, x, of some kind X, with interpretation of the derived eout as representing values, y, of kind Y. With respect to those interpretations representations, the input and the derived output are taken as satisfying the functional relationship symbolized as F:X→YThat is, the procedure enacted by the device is reliable for satisfaction of that functional relationship between its input and its output.  The ein qualifies as a representation of a chosen x. The diagrams feature interpretation over representation, and draw the arrows as interpretations from the representations because it is the interpretation that is considered the intention for selection of a (representative) encoding.

To operate computations on the pattern above, an user must select a machine that provides a suitable M and its M?:I→O operation, then derive inputs that represent chosen members of X in order to achieve an output that is representative of the correct result in Y

If M is programmable in some manner, there is more variety of choice for intended usage.   For example, computational interpretation of obap.eval( e ) allows representation of expressions that can be considered to express F and X together in satisfying F:X→Y with the computed output. 

In this example the computational process, so construed, is that of an ob calculator. 

In this particular example, we have hand-waved the existence of a mechanical procedure that, when completed on valid input ein, yields an ob (representation) that satisfies

eout = obap.eval (ein )

At this level, we are indifferent to how that is accomplished via the mechanical procedure, simply relying on the fact that it is.  What are fixed for this purpose are an ontological commitment to the procedure manifesting obap.eval, so that we can then rely on the representation and satisfaction of F:X→Y.  Consider that we are granting existence to both levels and assuming validity of the connection between them reflected in the interpretations.  This act rules out other interpretations in the context of the depicted computation.

Variations on this pattern arise as Miser Project conceptualization progresses.  The key feature is distinguishing what a computation is (such as the eval procedure and the chosen input) versus what a computation is for (purposive use) and how that figures in representation validity and powerful layering of abstractions/representations.  The gaps between what the computations are versus what they are used for will increase along with greater utility, usability and invisibility of the machinery.

This painstaking diagrammatic depiction of an algorithmic computational process establishes the essential ideas of the connection between mechanical procedures and the computational interpretation of mathematical structures.  It will be extended for streamlined use in the coordination of multiple computational processes.  Establishment of the mechanical procedures and their faithful engineering will also be addressed.

6. Manifestation and Tacit Awareness

There is a point with computers where the experience of using the computer is recognized as manifestation of something that is evoked by the exhibition of computational-processing activity. 

Enlarged extract that admits sense and also individual word forms, letter formsIt is easier to see how we manifest something in looking at something rather static, such as words on a page.  In reading, the automatic tendency is to discern a sense of the text without much examination word-by-word,  unless this is not your language or there are other circumstances that bring attention to the individual words. 

Manifestation-2019-02-11-1221-bigWordThat is different than looking at individual words in isolation and then the individual letters and then the marks on which the letters are built. 

Consider that when we focus on the sense that occurs to us, that is the object of focal attention/awareness.  Subordinate attention/awareness is on observation of the substrate, the individual words and perhaps the sense of those in isolation. 

Manifestation-2019-02-11-1232-tipWWhen the sense is stripped away completely, at a level so subordinate that there is no suggested sense tacit recognition (as in the enlarged tip of an electronic a visual rendition of “w”), we can discern how at the level of the electronic device’s operation, the manifestation of letters, words, and sentences – statements – is achieved by something entirely subordinate.  In this case, the manifestation has been engineered by organization of  such that miniscule electronically-generated features to manifest are organized to present the text that is in-turn evocative of is chosen to carry a communication.

When text is in your natural language and you are practiced at reading it, there is difficulty in not it takes effort to avoid automatically grasping some sense of the text.  It is easy to conclude that behave as if meaning is found on the page, separate from us.  Effort is required to strip away the focal and bring awareness to the subordinate; the tacit reaction is reading the text, even for a single word.  It is valuable, in for understanding how computers are so marvelous, to appreciate who is making that leap and how affordance of that is engineered.

Having examined the three images, above, and understanding the text here, how automatic is it to identify the third, fragmentary image, as “W”?”  Put another way, don’t think of “W” there.   It could, after all, be a fragment of “Y” or “X”.  It could also depict a section of a girder, of a strut, or of some other material object. 

Finally, suppose, instead, that the text images above were replaced with Japanese calligraphy and how difficult it would be for a Japanese-illiterate reader to recognize anything but unintelligible markings at all levels of magnification.  An odd case could be made with Egyptian hieroglyphics where there are recognizable figures yet without tacit meaning as communications available to most of us. 

The user is presented a visual manifestation of the document being edited and used, yet the format for computer-to-computer interchange is unintelligible as that document, requiring software and some reliable document model interpreted either wayTacit recognition is important in how manifestations are evoked with so much fidelity that the manifestation entity is perceived as being manipulated and preserved by computer interaction.  The accomplishment is a wonder of engineering of engineered subordinate processes to achieve such fidelity without interference (except when it doesn’t).  This applies in almost every use of electronic digital devices, whether for audio or video, text, or images.  Its origin goes back to telegraphy and before that, printing, and before that, writing, and before that, maybe cave paintings and, of course, speech.

In the example of electronic documents and modern word-processing software, the levels of representation and interpretation that are navigated are typical.  The interactive manifestation is unrecognizable in the isolated file format that is used for saving and interchanging a representation of the document, successful manifestation depending entirely on the interoperable availability of computer software on different computers. Computer software enacts some form of internal document model by which the interchange format and the manipulatable manifestation are coordinated.  The process does not intrude on perception of the manifest document and the author/user perception of the conceptual document and how it might appear in print or some other fixed medium.

Even simplified word-processing models are beyond the immediate reach of the ‹ob› model of computation.  There will be appeals and demonstrations of manifestation, starting at lower levels of computer operation before higher-level ones are considered.  The idea is to use such simplifications to gain a grasp on what is happening underneath the marvelous practical computers available to us.

One case of tacit (mis-)understanding will arise early.  It is easy, for computer programmers and others,  to recognize a formula that has some mathematical appearance as expression of a computation; this mistaken attribution of mathematics as being about computation is encouraged by the borrowing of mathematical notation for programming-language purposes.   Since ‹ob› and the associated model of computation are unfamiliar in a programming context, that confusion is avoidable for a time.  With familiarity using the Miser Project coding notation (oFrugal) for computation of obs, tacit understanding will likely kick in and we’ll need to keep that harmless.  

7. Ontological Commitment: Layered Abstractions

The elevator of ontological commitment does not stop between floors.
   — anon.  The Wit and Wisdom of Twitter.

In considering the ways that computers are employed to manifest layers of abstract entities, and interpretations of other entities in those, it is useful to identify and assert ontological commitments

In use of “manifestation” with respect to interactions with a computer, it is important to distinguish the (subordinate) form that is exhibited to us from the (theoretical) entity that is taken to be (focally) manifest.   The degree to which we can successfully behave as if the theoretical entities are somehow present, as “there,” involves an ontological commitment on our part; we grant being to the (theoretical) entities and fidelity to the manifestations.  The engineering of computer systems and their software is successful to the degree that orchestration of intended manifestation supports such commitment without confusion.

Consider that particular representations (in ‹ob›  or of ‹ob›, or in other structures) might become so familiar that a tacit interpretation is manifest immediately.  This can be a case of tacit ontological commitment, whether warranted or not.

An useful variety of ontological commitment is with the diagrammatical illustration of an  obap.eval algorithm carried out by a computational mechanism (section 5, above).  One can trust in the achievement of an obap.eval algorithm and fix that level for faithful representation in service of a higher level of abstraction.  In this sense, there can be focus on the two levels without regard for potential different ones, intermediary levels, and especially subordinate ones.   The fidelity of the lower-level manifestation of ‹ob› is a premise in the valid representation of the higher level.

The danger of misguided ontological commitment is with regard to category mistakes.  A common example is the confusion of computational representations with objects in our reality (such as persons, other animate entities, and organizations of such entities). 

Exploring the Miser Project model can seem far removed from questions of the social benefit and purposive use of computers and problems of inappropriate ontological commitments.  There will be simple cases that provide miniature demonstration of such hazards.  Mainly, there will be tolerance of benign ontological commitment, especially the fixing of levels of abstraction and the representation of one in the other.

Onward to the oMiser computational model.

Posted in Miser Project | Tagged , , , | Leave a comment

Miser Project: Representing Functions in ‹ob›’s Abstract World

2019-11-06 Update: This blog is obsolete and no longer being maintained here.  These Miser Project Posts are now maintained and continued at  Orcmid’s Lair, the reboot.   The authoritative version of this page is now at

2019-01-02 Update: Corrects ob.p01.bp representation of x ⊆ y and simplifies ob.p01.bp.is-eq(x,y) in b00le.txt section 2.5.

2018-12-12 Update: The Boolean Algebra ob.bvx representations are adjusted to employ short-circuits and the ob.bvx.bvn interpretation improved.  Some things I just can’t let go by.

2018-12-10 Update: Representation of Boolean Algebra ob.bvx is simplified to make interpretation of ‹bvn› more direct and properly extensible.

2018-12-07 Update: Revamp the development of ob.bvx for interpretation of all Boolean Algebra structures via inter-interpretation, exposing more about the connection of mathematical structures and computational ones, and also exposing the differences.

The structure ‹ob› = 〈Ob,Of,Ot〉is a mathematical, logical-theory conception that has  computational interpretation.  Software implementation for such an interpretation has been demonstrated.   So far, this is just for a depiction of some distinguished individuals (ob.NIL and lindies) and all the constructions possible over those.  The distinction of additional individuals is open-ended. 

There are also canonical forms for all of the distinguished obs. This has obs be definite, however mathematically abstract.  It also has obs be finitely-expressible, even though there is no bound on the domain, Ob.

Representation of data, where obs are taken as encodings of data, thereby being interpretations of some other conception, has been suggested as a prospect for ‹ob›.  Now we turn to representation of functions and then representation of some structures other than ‹ob› .  The interpretations involved are mathematical in nature, not computational however suggestive they might be. 

The separation (and useful connection) between mathematical characterizations and computational ones becomes more clear when we consider reasoning about functions and their representations in effectively-computable form, first the Of in ‹ob› and then representations and interpretations of other structures among each other and in ‹ob›. 


  1. Hark! Is That a Theory I See Before Me?
  2. ‹ob› Primitive Functions
  3. Narrowing ‹ob› for Computational Interpretation
  4. Representing Data as Obs

The Abstraction of Functions

In structure ‹ob› = 〈Ob,Of,Ot〉, the characterization of functions in Of is by introduction of definitions using the theory language, Ot, just as there are mathematical expressions of the primitive notions.   Characterization in this manner demonstrates that a primitive function or any other function is in Ot.  

The way that a function f( x1, x2, .., xn ) is successfully represented by an effectively-computable representation in Ot (or any other structure on the same principles as employed for ‹ob› here)  is with a small number of logical statements such that,

  • there is a finite number of statements of finite length in the characterization.
  • For definite operands, x1, x2, .., xn, the definitions pertaining to f( x1, x2, .., xn ) lead to deduction, in a finite number of steps, to at most one definite result, y = f( x1, x2, .., xn ).
  • It can be the case that there is no definite result for some operands, xi.
    • When there is a definite result for all definite operands, x1, x2, .., xn, f is said to be a total function.  It is defined on all obs.
    • When there is not a definite result for all definite operands, x1, x2, .., xn, f is said to be a partial function that is undefined for those operands.
    • It is not always possible to determine, from the offered characterization, whether a function is total or not.

Given two distinct representations in this manner, seemingly for function f and for function g,

  • If f( x1, x2, .., xn ) = g( x1, x2, .., xn ) is deducible for all definite x, where each have definite result, we say that the same function is represented.
  • There is no counterpart of canonical forms for functions.  Determination that two representations are for the same function requires a mathematical proof.
  • Determination that two representations are not for the same function is often by directly exhibiting operands x1, x2, .., xn, for which f( x1, x2, .., xn ) ≠ g( x1, x2, .., xn )

The prospect of partial functions is unfortunate, with total functions much more easily dealt with.  Nevertheless, there will be cases where partial functions are convenient and important cases where they are unavoidable.

Establishment of identities is commonplace in algebra, trigonometry, introductory calculus, and other areas of early mathematical education and practice.  Identities serve to address practical questions, involve rather direct forms of proof, and can be used to find attractive computational interpretations.

These notions in the context of ‹ob› and the Miser Project become more familiar on exploration of examples.

The Blast Function

In our structure ‹ob› = 〈Ob,Of,Ot〉there is a function in Of that can be represented, using Ot, in the following fashion.

  • Blast1.  ob.is-singleton( x )  ⇒ blast( x ) = x
  • Blast2. ¬ ob.is-singleton( x )  ⇒ blast( x ) = blast(ob.b( x ))

By reference to the definition of primitive notions given earlier, we can summarize

  • blast( x ) is the singleton that is at the end of a chain of successive ob.b( x ) compositions, ob.b( … (ob.b( x )) … ), keeping in mind that for any singleton,
          ob.b( x ) = x.
  • blast( x ) is total — defined for every possible definite ob, x.
  • The name “blast” was chosen to signify the determination of the ob that is at the first ob.b that makes no difference, the last ob.b in the chain.

Let ob t1 = a1 :: (a2 :: b2) :: .NIL (using the CFob canonical form for ob t1)
where a1, a2, and b2 are lindies, distinct individuals.

Then blast( t1 ) = blast( ob.b( t1 ) ) = blast( ob.b( (a2 :: b2) :: .NIL) ) = blast(.NIL) = .NIL, and the equational progression is typical for streamlining the progression of deductions.  At each step, exactly one of Blast1 and Blast2 apply.

The Mirror Function 

  • Mirror1. ob.is-singleton( x )  ⇒ mirror( x ) = x
  • Mirror2. ¬ ob.is-singleton( x
         ⇒ mirror( x ) = ob.c(mirror(ob.b( x )), mirror(ob.a( x )) )

Here mirror( x ) is a form of mirror-image of the ob x.  Using ob t1 from above,

ob-2018-10-28-0909-mirrormirror( t1 )
        = ob.c(mirror((a2 :: b2) :: .NIL), mirror(a1)) )
        = ob.c(mirror(.NIL), mirror(a2 :: b2)) :: a1
        = (ob.c(.NIL, ob.c(mirror(b2), mirror(a2))) :: a1
        = ( (.NIL :: (b2 :: a2 ) ) :: a1

where these forms of identities are typical of derivations of the results for definite operands.  With experience, mixing of CFob canonical form notation in Ot expressions, as done here, is useful for readability.

The statements Mirror1-Mirror2 are by way of definition and constitute representation of the function that is characterized in this manner.  That is sufficient demonstration that there is such a function in Ot Of, since Ot Of is declared to include all functions on ob operands with results in Ob.

There is no inherent sense in which the mirror( x ) function has been represented correctly.  It is what it is.  I declare that representation via Mirror1-Mirror2 satisfies my intention for the function.  The decision to leave all singletons, including enclosures, intact is mine.  The use of singletons in the same manner as individuals will be common as an idiom in the crafting of functions on obs.

For mirror( x ) to provide a satisfactory mirror-image of an ob with respect to its pairings, it must satisfy the natural requirement that mirror( mirror( x ) ) = x.  That can be proven.

        ob.is-singleton( x )                                                                          base case
           ⇒ mirror( mirror( x ) ) = mirror( x ) = x
        mirror(mirror( x )) = x ∧ mirror(mirror( y )) = y                     induction step
           ⇒ mirror( mirror( ob.c(x, y) ) )
                    = mirror( ob.c(mirror( y ), mirror( x )) )
                    = ob.c( mirror(mirror( x )), mirror(mirror ( y ) )
                    = ob.c(x, y)                                                     
        mirror(mirror( x )) = x                                                                   by structural induction

This proof is by structural induction.   By design, the definition of ‹ob› primitive notions together with the partial-ordering relation ¶ satisfy the requirements for applicability of structural-induction.

  1. The single base case consists of all singletons and that is straightforward.
  2. The induction step is by showing that when the two components of a pair satisfy the condition, so does the pair.
  3. There being no other cases to cover, the conclusion follows by structural induction. 

The important consequence of having a proof, different from a demonstrative example, is that we establish the condition for all possible operands by mathematical means.   Among experts, a proof might not be exhibited for this simple case, based on the understanding that the proof is easily constructed.  Here, the objective is to illustrate the nature, purpose, and benefit of the mathematical approach and more detail is provided.

On Equivalent Function Representations

  • Alast1.  ob.is-singleton( x )  ⇒ alast( x ) = x
  • Alast2. ¬ ob.is-singleton( x )  ⇒ alast( x ) = alast(ob.a( x ))
  • Blink1. blink( x ) = alast(mirror( x ))

Here, alast( x ) is the ob.a counterpart of blast( x ).   blink( x ) is the same as blast( x ) and, however  obvious that is on inspection alone, that can also be proved by deduction.

        ob.is-singleton( x )                                                                              base case
            ⇒ blink ( x ) = alast(mirror( x )) = alast( x ) = x = blast( x )
        alast(mirror( y )) = blast( y )                                                            induction step
            ⇒ blink(ob.c( x, y)) = alast( mirror( ob.c( x, y ) ) )
                    = alast( ob.c( mirror( y ), mirror( x ) ) )
                    = alast( mirror( y ) )
                    = blast( y )
        blink( x ) = blast( x )                                                                             structural induction

We have demonstrated that blink and blast, as defined above, are representations of the same function in the Of of ‹ob› = 〈Ob,Of,Ot〉. 

It is commonplace to say that the functions blink and blast are equivalent.   To continue rigorous speaking of the abstractness of mathematical entities it will be said, instead, that the function representations are equivalent insofar as the same function is determined.   Absent canonical forms for expression of functions in Of, assuming more about equivalent function representations is inappropriate although one might have a preference for representations that are expressive and simpler.  The demonstration of equivalence also favors substitution of the simpler representation for the more complicated one.

When it comes to computational interpretations, on the other hand, there are only the function representations to work from, and derived computational interpretations may have material differences.   For example, one might prefer blast( x )  over blink( x ), operationally (but maybe not if y = mirror( x ) is already “in-hand” and blast( x ) is desired, so alast( y ) is then appealing).

Representing Other Structures: Boolean Algebras

Having data represented via encoding as obs was introduced previously.   Now we look at how one arrives at functions on such obs that honor the intended data representation.  We’ll start for the case where the representation is of some discrete structure other than ‹ob› and for which there already is a mathematical characterization.

Consider a specified abstract structure, ‹S› for which an interpretation in ‹ob› is desired.  What must be preserved by an interpretation of structure ‹S› in ‹ob› that will be amenable to computational-interpretation in the ‹ob› model of computation, are the essential functions of ‹S› represented in an effectively-computable form.

Boolean Algebras are mathematical structures that are interesting for computational purposes; they provide handy examples that demonstrate layering of representations and interpretations.


A characteristic of Boolean Algebras is that they apply over a variety of domains of discourse (i.e., other/related structures), yet the essential mathematical pattern of a Boolean algebra is exhibited in every case, typically in more than one way.


The axioms pertain to abstract, theoretical entities.  We can establish an effectively-computable representation directly by exhibiting function representations that can be confirmed to satisfy the axiomatic specification.

‹bp›: The Prototypical Boolean Algebra


Accomplishing effective-computability in ‹bp› given distinguished ⊥ and ⊤ offers a straight-forward interpretation in ‹ob›.   Just select two obs and corresponding representation of functions.


Restriction of the ob.NE.bp interpretation of ‹bp› in ‹ob› to two distinct ob elements is awkward for computational-interpretation; it leaves undefined what would happen, in a computational model based on ‹ob›, when the restriction to those two operands is violated.  A remedy is offered with interpretation ob.p01.bp.


The basic technique of identifying domain elements across structures and then matching representations of primitive notions is illustrated with the ob.p01.bp interpretation of ‹bp› in ‹ob›. Careful identification of the interpretation ‹bp› in ‹ob› is akin to the approach used in demonstrating computational interpretation of ‹ob› in an SML/NJ abstract data type signature.

‹ba›: General Boolean Algebra Representation

In what follows, the general case of Boolean Algebras on finite domains is addressed.  The treatment is more elaborate than for ‹bp›, involving the interpretation of other structures and arriving at interpretations in ‹ob› at the end.   Care is taken to identify the stages and transition from one to the next.

It is a remarkable characteristic of Boolean Algebras that many have interpretations in each other.  In consequence, there need be only a few representations of Boolean Algebras that suffice as interpretations of all the others; they will be effectively computable thereby, as well. 

Here the outcome is a single ‹ob› representation, ob.bnx ob.bvx, that provides an interpretation for all finite Boolean Algebra cases.  The justification is essentially mathematical.  ob.bnx ob.bvx does not make for a one-size-fits-all computational interpretation however; large-scale situations require more-elaborate computational interpretations.

We start with consideration of concrete representations: ‹bn› structures.


There is a handy means of representation of all subsets of a finite set of distinct elements.  Although not a concrete representation in itself, each representation under the scheme is isomorphic to corresponding concrete representations and thereby an entire family of Boolean Algebras.


The representation of ‹bvn› Boolean operators is abbreviated above, with the sequences all having the same length, n,  and operations extended onto corresponding pairs of list-operand elements.  The general pattern is to be understood as applying for every n

The isomorphism of ‹bvn› with any concrete Boolean Algebra involving a set of n elements is straightforward.


Given a ‹bvnn-tuple, X, the indicator function Iai( X ) determines whether ai is a member of the corresponding (concrete) subset.

ob.bvx: One Interpretation to Hold Them All

By finding interpretation of any ‹bvn› in ‹ob›, we have represented the corresponding concrete Boolean algebra, ‹bn›, individually.  The representation ob.bvx, below, is a single formulation that provides interpretations of any ‹bn›  (and thereby, all of them) and hence all of the finite Boolean Algebras via isomorphism. 

The ob.bvx representations are a bit more convoluted than the preceding ones, such as ob.p01.bp, in order to accommodate the necessary variability of interpretations without fixing n.  The trade-off is in having to develop and confirm the representation but once, rather than separately for each ‹bvn›.


Among the features of interpretation in ob.bnx, there is a canonical form that can be used in expressing individual vectors in a compact variable-length form.


There are a few nuances to tidy up, along with considering how to tie back from ob.bvx to any ‹bvn› and thereby all of finite ‹ba› via isomorphism.


This article ends with some reflections and references to some supporting material.




  1. Interpretation, Representation, Computation, and Manifestation
    Reprise and account for specialized concepts in Miser Project, setting up for representation of the computation model
Posted in Miser Project, Uncategorized | Tagged , , , , , | 3 Comments

Miser Project: Representing Data as Obs

2019-11-06 Update: This blog is obsolete and no longer being maintained here.  These Miser Project Posts are now maintained and continued at  Orcmid’s Lair, the reboot.   The authoritative version of this page is now at

2018-10-18 Update: Strengthening the notion that obs can be data representations, via encoding, with such representations preserved by computational-interpretation of the obs.  Expressing canonical form is now aligned with the updated introduction in Denumerability and Effectiveness

2018-10-20 Update: Smoothing the narrative on data representation along with additional consistent use of “canonical form.”

2018-10-30 Update: Cover some loose ends about computational-interpretation of functional-notation in the OB.sig.sml selection.

The Miser Project conception is composed of a mathematical formulation along with demonstration of computational interpretations that satisfy the formulation via careful engineering.

The foundation of the conception is the mathematical structure ‹ob› = 〈Ob,Of,Ot〉that circumscribes the domain Ob with its primitive functions and an useful supply of individuals to establish mathematical counterparts of computational data.

Here continues the advance toward mathematical formulation of a theory of computation by considering the (computational) interpretation of obs as data.


  1. Hark! Is That a Theory I See Before Me?
  2. ‹ob› Primitive Functions
  3. Narrowing ‹ob› for Computational Interpretation

Standing in Abstraction

It is useful to entertain the notion that the ‹ob› = 〈Ob,Of,Ot〉universe of discourse consists of intangible, abstract entities: the obs (in Ob) and the (abstract) functions/predicates on obs (treated informally and jointly in Of).   Those entities have no material/concrete existence and any abstract “existence” is entirely given by ‹ob› through the logical theory, Ot.  Consider that the entities (so-called) arise entirely in language with their essential nature given by the formulation of ‹ob› expressed in the preceding installments.  Having attention on particular obs (and particular functions and predicates on them) is simply a way of speaking and not any kind of separation from ‹ob›.  

This way of looking at the abstract nature of  ‹ob›  emphasizes that one cannot infer anything about the mathematical entities that cannot be deduced via Ot, the explicit logical-theory formulation of ‹ob›.  In particular, however closely a concrete computational interpretation manifests – gives the appearance of – ‹ob›-ness, it is important to not confuse engineered artifacts and processes with the abstractions.  Recognition of the difference is important in comprehension of how apparent layering of abstractions is achieved by computational means and software engineering.

This separation between the abstract and the apparently-operational is illustrated by the conscription of obs for interpretation as data representations.

Demonstrating Computational Interpretation

A demonstration computational interpretation of ‹ob› using the programming language SML/NJ has been prepared as an SML/NJ Abstract Data Type.  Possible computational interpretations are confined behind an SML/NJ signature declaration that limits what can be exercised of the computational interpretation and through which manifestation is achieved.  

The SML/NJ signature declaration is insufficient by itself.  The additional requirements for valid computational interpretations are specified in narrative comments.


The use of SML/NJ is incidental and extremely useful because of the ease with which this kind of computational interpretation can be demonstrated.   Other programming languages and methodologies will also be used.  Using this particular signature with SML/NJ and not entertaining equivalent SML/NJ alternatives is simply by convention for the SML/NJ demonstration of oMiser’s computational model.  

To nail down this demonstration of computational interpretation, the signature is combined with definition of an SML/NJ structure that completes establishment of the valid interpretation. 


Verifying validity of the interpretation depends upon knowledge of the SML/NJ language as it is applied here and upon correct operation of the SML/NJ software and the computer used.

The condition of validity is that for any deduction concerning canonical forms in Ot, the corresponding computational procedure in the interpretation is aligned by yielding the corresponding interpretation of the deduced consequence.

Even when everything is correct, it can be impacted by operational malfunctions and by resource exhaustion.   To this extent, the interpretation is contingent and empirical.  It is an accomplishment of engineering and not logic, despite the remarkable fidelity of valid interpretations in practice. 

It should be clear that the establishment of interpretation validity is, in this case, dependent on inspection of the SML/NJ signature and structure and arriving at empirical agreement on their validity as a computational interpretation.  In this instance, there is a prima facie case, absent any contradictory evidence.

One subject of the Miser Project is demonstration of  validation support using mechanical deductive procedures that are themselves verified to be sound.   Understanding how that can be achieved will depend, at bottom, on a successful empirical foundation, such as that offered at the oMiser level.   It is important to confine the foundation to something whose empirical validity is readily verifiable before bootstrapping to higher levels.   The SML/NJ demonstration is exemplary in that respect.

Concerning Data Representation

Canonical forms can be taken as interpretations of data via an encoding – some arrangement of an ob that corresponds to a defined encoding of data.  We say the understood encoding is an interpretation of the (abstracted) data with the happy consequence that a suitably-restricted computational interpretation of the obs will preserve an interpretation as a particular representation of data. 

  • That an ob has the form of a defined encoding does not imply that it is intended to be understood as such a representation ; however, when an ob fails to satisfy a defined encoding, one can conclude the ob is not such a representation.
  • Whether operations on obs having the form of a defined encoding preserve the obs being such such an interpretation as data depend on how the operations honor data-interpretation-preserving restraints. 
  • One way to assure that a data-interpretation is valid is by establishing functions that encapsulate the interpretation, not unlike how the interpretation of ‹ob› is accomplished via the general-purpose language, SML/NJ, using signature and structure agreements to encapsulate a computational interpretation of ‹ob›.

By way of example, one data interpretation could be as representation of numbers.  

  • Let ob.NIL represent number 0,
  • ob.e(ob.NIL) represent number 1,
  • ob.e(ob.e(ob.NIL))) represent number 2, and so on.  

That’s mathematically adequate; it’s rather clumsy as a way of recording numeric data for any general practical purpose although we will see such elementary forms of counting in simple applications of oMiser.

A more suitable interpretation might be as a representation of numbers in a binary notation.  Let ob.NIL represent the digit 0 and let ob.e(ob.NIL) represent the digit 1, the two binary bits.  Then use

  • ob.NIL as number 0,
  • ob.e(ob.NIL) as number 1,
  • ob.c(ob.NIL, ob.e(ob.NIL)) as number 2,
  • ob.c(ob.e(ob.NIL), ob.e(ob.NIL)) as number 3, and
  • ob.c(ob.NIL, ob.c(ob.NIL, ob.e(ob.NIL))) as number 4, and so on.

Here the binary representation proceeds 0, 1, 01, 11, 001, … the reverse of the usual way that binary numbers are written.  That’s still an encoding; one must look elsewhere for preference of one encoding over another.

There are many ways that encodings can be established in this manner.  Knowing what is being represented and the rule of encoding is not inherent to the obs.  Additional information on the intended interpretation is required. 

It is intentional that the preceding examples be unfamiliar, exaggerating the difference between intended data and data interpretation in ‹ob›.  This is akin to the accomplishment of data representations in digital computers where the representations of data all devolve to organizations of and operations on binary bits.

Do the Lindy Hop

Although it is inescapable that additional information is required to know the intended representation for an ob’s interpretation as data, there is a simple measure to gain greater expressiveness in encodings. 


Lindies are a particular class of individuals adjoined to Ob in ‹ob›.  They are simply distinct individuals with no other significance.  Any intention for them and choices among them are of no significance in ‹ob›.   Their computational interpretation, in the oMiser model, is simply as interpretations of individuals distinguished by their specific character strings.  Their intended significance in an encoding situation is similarly not addressed by ‹ob›.  Lindies are freely available to improve the expressiveness of data representations.

Streamlined Notation

Interpreting individual obs as data is accomplished on individual canonical forms, no matter how those obs might be formulated on some general pattern.   The straightforward expression of those canonical forms is aided using a specialized notation.

  • A primitive individual, with name of form ending in .NAME, such as ob.NIL, is expressed as simply .NAME (e.g., .NIL).
  • A lindy, designated by Ʃ’s’, is expressed simply s.
  • ob.e( x ) is expressed ‵ ( x ), where the parentheses can be omitted when x is not a pair.
  • ob.c( x, y) is expressed ( x ) :: ( y ) , where the parentheses can be omitted when x is not a pair and where the parentheses on ( y ) are always optional.
  • In this notation, :: associates to the right, so abc :: .NIL :: ‵ GHI expresses the same ob as abc :: (.NIL :: ‵ GHI), which expresses ob.c(Ʃ’abc’, ob.c(ob.NIL, ob.e(Ʃ’GHI’) ) ).

When all optional parentheses are removed, this notation provides a direct counterpart of canonical forms which are more compact and, with practice, more understandable.  This equivalent canonical form is identified CFob.

Here is the CFob expression for an ob that might be intended as a small dictionary, with all of the terms being lindies.
       (English::en) :: (Русский::ru) :: (日本語::ja) :: (Français::fr) :: ‵ default

The previous examples of encodings can be streamlined using CFob expressions:

  • .NIL for 0, ` .NIL for 1, ` ` .NIL for 2, … etc.
  • b0 for 0, b1 for 1, b0 :: b1 for 10 (2), b1 :: b1 for 11 (3), b0 :: b0 :: b1 for 100 (4), etc., with the order of the bits in the binary-numeral representation reversed as before.  Observe that there are two levels (at least) of representation here: first as sequences of bits and secondly the interpretations of those as (decimal) numerals.

In Sight of the Objective: Models of Computation

The illustration of ob-representation of data has just scratched the surface.   It is time to consider how one reasons about functions of ‹ob› = 〈Ob,Of,Ot〉and how the are considered to be effectively calculable in general and in service of data representations.  That supports unfolding the Miser Project’s applicative model of computation, oMiser. 

Although there are many unexplained technicalities and additional steps to take, there is a glimpse of the objective in how intended data representations are achievable.

The mathematical structure ‹ob› = 〈Ob,Of,Ot〉incorporates an abstract model, to be introduced in subsequent articles, of algorithmic computation that demonstrates the nature of universal computation and also emphasizes how the stored-program model affords cascading manifestation — boot-strapping — of higher-level abstractions via software engineering.   There is a hint of that in consideration of data representation.

We forego, for now, ideas of efficiency and expressiveness in order to first capture the essential character of stored-program computation, including how data representation and representation-honoring operations are accomplished with computational interpretations of ‹ob›.


  1. Representing Functions in ‹ob›’s Abstract World
    Reasoning about functions on obs and then about interpretation of other structures by representation of functions in interpretations.
  2. Interpretation, Representation, Computation, and Manifestation
    Reprise and account for specialized concepts in Miser Project, setting up for representation of the computation model
Posted in Miser Project | Tagged , , , , , , , | 3 Comments

Miser Project: Narrowing ‹ob› for Computational Interpretation

2019-11-06 Update: This blog is obsolete and no longer being maintained here.  These Miser Project Posts are now maintained and continued at  Orcmid’s Lair, the reboot.   The authoritative version of this page is now at
2019-01-19/21 Update: Be more careful with x ¶ y, referring to it everywhere as a (strict) partial-ordering.
2018-10-17 Update: Significant adjustment of canonical form notions in the obtheory.txt on Denumerability and Effectiveness.
2018-11-02 Update: Pointing out, in the Denumerability and Effectiveness portion of obtheory.txt that the partial ordering, x ¶ y, assures availability of structural induction for deductions about functions in Of.


  1. Hark! Is That a Theory I See Before Me?
    The first-order logic with equality notation for Ot, the mathematical theory for ‹ob›
  2. ‹ob› Primitive Functions
    Mathematical characterization  of four primitive functions and allied primitive notions that establish the domain of discourse, Ob, in structure ‹ob› = 〈Ob,Of,Ot〉

Primitive Notions

All of the apparatus for characterizing the mathematical structure ‹ob› = 〈Ob,Of,Ot〉has been used, so far, to present a simple universe of discourse, Ob and essential characteristics of that universe in terms of its primitive individuals, enclosures, and pairs.

  • primitive individuals
    that are introduced simply by being uniquely-named in form ob.NAME, with ob.NIL given so far (although non-primitive individuals will be introduced by other means)
  • enclosures
    signified by terms of form ob.e( x ) where x is any ob and ob.e( x ) is the unique ob that encloses that x.
  • pairs
    signified by terms of form ob.c( x, y ) where x  and y are any obs and ob.c( x, y ) is the unique ob consisting of the pairing of the particular x and y.

Each ob is fashioned as exactly one of those (so far).  The primitive notions also provides mathematical means for discerning conditions that an ob satisfies. 

  • If z = ob.c(x, y) then x = ob.a( z) and y = ob.b( z )  and also xz and yz
  • If z = ob.e( x ) then x = ob.a( z ) and z = ob.b( z ) and also xz
  • If z is an individual then z = ob.a( z ) and z = ob.b( z ).

These conditions are sufficient to provide predicates that discriminate the flavor of any ob.

  • ob.is-pair( z ) is true if an only if neither of ob.a( z ) and ob.b( z ) are z, which simplifies to ob.b( z ) ≠ z
  • ob.is-singleton( z ) is true if and only if ¬ ob.is-pair( z ), which simplifies to ob.b( z ) = z
  • ob.is-enclosure( z ) is true if an only if ob.is-singleton( z ) and ob.a( z ) ≠ z
  • ob.is-individual( z ) is true if and only if z = ob.a( z )

Note that there is no ob, z,  for which z = ob.a( z ) with ob.b( z ) ≠ z and that will never change.

This informal description is consistent with the rigorous treatment expressed in the notation for Ot.

Informal Terminology

The function names ob.a, ob.b, ob.c, and ob.e are not particularly suggestive of anything.  In that respect, it is the theoretical characterization of them that gives their essential significance, make of it what we might.  That is intended.

In contrast, the terms individual, singleton, enclosure, and pair are suggestive of some intended significance beyond merely what there is to be gleaned from Ot alone.

It is the case that certain idiomatic purposes are reflected in the choice of those names.  It is important to appreciate that, theoretically, the chosen names are irrelevant despite their outside-of-the-mathematical-theory hinting of an intended application of ‹ob›.  There will be more of this.  It is important to keep in mind that such “intended interpretation” is more about why ‹ob› is formulated the way it is; it doesn’t qualify what the ‹ob› structure is, mathematically.  The mathematical entities involved are solely what is discernable from the characterization in Ot.

Positioning for Computational Interpretation

There is more to be said in conjunction with the primitive notions for drawing a solid connection with computation.

  • The obs are denumerable.  They can be counted and there are exactly as many of them as there are natural numbers, given by the progression 0, 1, 2, …, n, n+1, … .
  • Effective Ot characterizations of functions, F, in Of are such that deduction of F( x )  for x a given ob is tantamount to a procedure for computation of at most one particular ob y for which y = F( x ) and x is any specific ob. 
  • partial well-ordering Strict partial-ordering of the obs has structural induction available for deductions concerning the representation in Ot of functions in Of.  This has obs be finite with every ob having a finite canonical form in Ot.

To accomplish that, the textual definition of ‹ob› is extended.

obtheory.txt 0.2.6 Section 3: Denumerability and Effectiveness


  1. Representing
    Data as Obs

    Expanding on the difference between a logical mathematical
    theory and computational interpretation, noticing that obs themselves can be
    interpretations of data, that interpretation being carried over to a
    computational interpretation.  SML is used to demonstrate one operational
    interpretation in a programming language.
  2. Representing Functions in ‹ob›’s Abstract World
    Reasoning about functions on obs and then about interpretation of other structures by representation of functions in interpretations.
  3. Interpretation, Representation, Computation, and Manifestation
    Reprise and account for specialized concepts in Miser Project, setting up for representation of the computation model
Posted in Miser Project | Tagged , , , , , | Leave a comment

Miser Project: ‹ob› Primitive Functions

2019-11-06 Update: This blog is obsolete and no longer being maintained here.  These Miser Project Posts are now maintained and continued at  Orcmid’s Lair, the reboot.   The authoritative version of this page is now at


Characterizing the mathematical structure ‹ob› = 〈Ob,Of,Ot〉involves first-order-logic with equality as the project notation for expressing  an applied logic, Ot, in which Ob is the entire domain of discourse.   Predicates and functions (in Of) are also introduced by characterization in Ot.

Four distinct functions, along with equality, are sufficient to distinguish among all of the Ob obs.  It will be the case that all characterization of obs, including as transformations of other obs, will reduce to compositions of these functions and cases of equality/inequality. 

Primitive Notions Ob1-Ob7 characterized in the applied-logic theory Ot

The notions of individual, enclosure, singleton, and pair have their inspiration in the nested array work of Trenchard More and  the foundation structure of LISP by John McCarthy.  It is intentional that these structural characteristics are limited and simple.

An essential characteristic is that the primitive notions have the structure be closed and the primitives be total.  One cannot in any way “fall out” or “fall through” a primitive.  And if the operands are defined, so are the results, viewing the primitives as operations.  This tidiness will be valuable in demonstrating practical computational interpretations of the mathematical entities of ‹ob›.

The elaborate treatment of just this much is also indicative of how much one must assert to narrow the objects of discourse to ones that are suitable for underlying a model of computation.  And we are not there yet. 

At this point, it should be rather clear that mathematical treatment is rather different than construction of computer programs that embody a mathematical theory in some sense.   It is one purpose of The Miser Project to sharpen and clarify that condition.


  1. Narrowing
    ‹ob› for Computational Interpretation

    Summarizing the primitive notions
    and positioning for computational interpretation with additional restraints
  2. Representing
    Data as Obs

    Expanding on the difference between a logical mathematical
    theory and computational interpretation, noticing that obs themselves can be
    interpretations of data, that interpretation being carried over to a
    computational interpretation.  SML is used to demonstrate one operational
    interpretation in a programming language.
  3. Representing Functions in ‹ob›’s Abstract World
    Reasoning about functions on obs and then about interpretation of other structures by representation of functions in interpretations.
  4. Interpretation, Representation, Computation, and Manifestation
    Reprise and account for specialized concepts in Miser Project, setting up for representation of the computation model
Posted in Miser Project, Uncategorized | Tagged , , , , | Leave a comment

Miser Project: Hark! Is That a Theory I See Before Me?

2019-11-06 Update: This blog is obsolete and no longer being maintained here.  These Miser Project Posts are now maintained and continued at  Orcmid’s Lair, the reboot.   The authoritative version of this page is now at https://orcmid.blogspot.com/2018/07/miser-project-hark-is-that-theory-i-see.html
2019-01-18 Update:
Introduce the latest obtheory.txt prelude and notation section with corrections and improved text.
2018-10-24 Update: Corrected definition of  ¬ p in the notation. (Yikes)

Once I have a stable experimental setup at the Spanner Wingnut blog, I will systematically revive my permanent, persistent blogs.  My agitation over the restoration of blogging and the use of hexo to generate static server pages reflects my anxious desire to restore Numbering Peano, the blog devoted to The Miser Project and related theoretical topics.

Pending restoration of Numbering Peano, I had begun writing about my capstone career project on a Facebook Page and on GitHub, where there are also preliminary (mock-up) demonstrations of implementation.  Issues on the GitHub project have been used to address questions and provide preliminary documentation.

At the moment, documentation is in plain-text files on GitHub.  That may continue as an ultimately-dependable form of persistent record.   When the hexo-generated pages are reliable, that will have the additional advantage of formatting with images and, most-important, formulas.   Mathematical notation expresses the bridge between the mathematical theory and the operational computation system for Miser.  Web pages can be arranged to do a better job.

At the moment, reliance on mathematical notation is confined to text and the use of Unicode encoding of the text.   Without the notation support for blog pages, the most reliable means of presenting the plain-text form on the web is via images.

obtheory.txt 0.2.5 Section 1: The plaintext notation for expressing the theoretical structure ‹ob›

Having web pages and others, expressed in the GitHub MarkDown notation, allows for greater expressive power.  Text has, within its limitations, useful control over layout.  We’d like both, and while wrestling to have hexo-generated pages into a stable form, with support for mathematical formulas, the use of screen captures here on the Live Hideout is the workaround.


  1. ‹ob› Primitive Functions
    Mathematical characterization  of four primitive functions and allied primitive notions that establish the domain of discourse, Ob, in structure ‹ob› = 〈Ob,Of,Ot〉
  2. Narrowing ‹ob› for Computational Interpretation
    Summarizing the primitive notions and positioning for computational interpretation with additional restraints
  3. Representing Data as Obs
    Expanding on the difference between a logical mathematical theory and computational interpretation, noticing that obs themselves can be interpretations of data, that interpretation being carried over to a computational interpretation.  SML is used to demonstrate one operational interpretation in a programming language.
  4. Representing
    Functions in ‹ob›’s Abstract World

    Reasoning about functions on obs and then about interpretation of other structures by representation of function in interpretations.
  5. Interpretation, Representation, Computation, and Manifestation
    Reprise and account for specialized concepts in Miser Project, setting up for representation of the computation model
Posted in Blog Development, Golden Geek, Hexo, Miser Project, Numbering Peano, Spanner Wingnut, Toolcraft | Tagged , , , , | Leave a comment

Returning to the Moon: Fire Suppression

I have relied on RSS feeds for all of my blogs, including this one, and collecting blog posts of others.

It was satisfying to enable  an RSS feed on the experimental hexo-generated blog now at Spanner Wingnut’s Muddleware Lab.

As part of the PC repaving mentioned the other day, it dawned on me that I have no RSS feed reader installed any longer, and I have no idea if I preserved the history of the discontinued FeedDemon Pro software that I had kept limping along for years. 

I had it in my head that I had failed to backup the FeedDemon database someplace separate from my system drive.  Either way, I chose to reinstall FeedDemon so that I could at least see recent blogs and, especially, confirm the Spanner Wingnut blog hexo-generated RSS feed.

FeedDemon installed with an empty database, and I did find one on my D:\ drive, the one unaffected by my reformatting and reinstall on my system drive.  It took me a bit to realize that this is all called “cache” and the FeedDemon File | Manage Cache menu item allows me to switch to the previously-operated cache. 

Restored FeedDemon restores history and finds recent posts

The current RSS content from Spanner Wingnut is also found, and the plaintext is correct, though not with the exact styles.   On linking to a post, the known Internet Explorer rendering failure is exhibited.

FeedDemon uses Internet Explorer for its internal web browser, exhibiting the same problems when Internet Explorer is used directly.

There’s no escaping this issue, and here’s a case where I can’t control what is used for embedded viewing of blog posts.

I thought I might learn something by viewing the oldest Spanner Wingnut post through the feed.  Not a chance.   Hexo regenerates all pages when it regenerates any of them, and past evidence of something different is eradicated.

I will blunder along.  It is becoming pressing to have the experimental blog stabilizes so that I can replicate the generation scheme for production blogs that it’s urgent to re-activate.

Posted in Blog Development, Hexo, Spanner Wingnut | Tagged | Leave a comment

Returning to the Moon: Escape Tower Incident

There have been a couple of setbacks in my efforts to restore self-hosted blogging capability.  I found a browser/server incompatibility that breaks my brain.  And then I had to do a fresh system drive and operating-system reinstall on my main, development PC.

Browser/Server Flummox

The hexo-generated Spanner Wingnut experimental blog seemed to be going great guns.

The blog appears correctly in Edge and Chrome

Apart from some simple style adjustments, the experimental blog seemed ready for customization and revitalization of my “production” blogs.

Everything works well under local testing and on the live location, using Google Chrome and Microsoft Edge.  The local server also displays properly using Internet Explorer.

The hosted web fails to be browsed properly using Internet Explorer, though.

The page display is completely ruined when using Internet Explorer to access the web-hosting site, but not the local machine server

The complete failure is with Internet Explorer only when accessing the hosted site.  That is completely baffling.

  • It is conceivably a server setting problem, perhaps something to do with MIME types of served content or even something in the formatting of CSS and JS components.
  • It is unacceptable that the site not be viewed properly with what remains the default browser for many users.
  • It appears that the image formatting is a problem, but I notice that the styles for remaining parts of the page are also disrupted.
  • There is nothing revealing when viewing the HTML served up by the hosting site.

My failure in not testing the deployed site in Internet Explorer from the beginning means I don’t know what customization changes first produced this result.

I am willing to remove the top-page image and simplify the top banner, in hopes that eliminates the difficulty. 

I am gathering myself for digging into that.  But first, … .

System-Restoration Priorities

While I was scratching my head over the browser/server failure being limited only to remote access by Internet Explorer, I managed to crater my system SSD drive.   Fortunately, I was able to use a recovery USB drive to get Windows 10 back in operation on a clean SSD.  Also fortunately, all of my data, and some installed programs, were on my D: drive, not the C: system drive.  I also had the good fortune to have code backups (GitHub) and data backups (OneDrive plus an attached USB-connected drive).  Also, many software subscriptions (Office 365, Steam, Cakewalk SONAR, etc.) make it very easy to restore software and, usually, my latest configurations and status.

I have gradually been re-installing software, starting with essential programs for everyday operation, such as Microsoft Outlook on the desktop. 

I have now successfully re-installed node.js and hexo.  The GitHub connections of my working nfoCentrale blog folders were already restored.  Now it is time to have the FTP deployment working again. 

With that last step, I can work on curing the Internet Explorer browser/server failure.

Software Engineering for Everyone

Software engineering is about having reliable processes for making dependable delivery and lifecycle support of computer software.  

There are some elements to computer-aided production and operation of blogs, and web sites generally, that pose tool-chain, workflow, and testing/analysis problems that are very unlike development of standalone PC software. 

My engineering of a dependable blogging-engine authoring mechanism requires quite a bit more software-engineering practice, simply for myself.   I need to look at how I am not creating practices that measure up to my own expectations for dependable operation.

Posted in Blog Development, Hexo, Spanner Wingnut, Toolcraft | Tagged , , , , , | Leave a comment

Returning to the Moon: Launchpad Security Penetration Exercise

There is an unexpected reward for moving source-code management of my Hexo-generated blogging to git and GitHub.  GitHub provides dependency analysis of node.js projects.  I receive an automated email about one dependency of my hexo-spanner code.

GitHub analysis of the hexo-spanner package.lock.json package reveals that UglifyJS2, depended on by Swig, has a known security vulnerability cured in a later version.

The uglify-js package is only depended on by Swig.  That places it in isolated use in confined ways under hexo.  I (will) do nothing to rely on Swig in any other manner.    I’ve dismissed the alert with explanation that the reported dependency is not exposed to the exploit.  I also created an issue on the hexo GitHub wondering if Swig can be deprecated from use in Hexo, since Swig is no longer maintained.

All in all, an amazing reward of my transposition of the Spanner Wingnut source-code management to GitHub.

Posted in Blog Development, blogs, Git, Hexo, Security Vulnerabilities, Spanner Wingnut, Toolcraft | Tagged , , , , | 21 Comments

Returning to the Moon: Tracking Network Modernization

John Stevenson has tips on bringing a hexo-authoring folder, and its themes, under Git for source control management.  I followed the first of those suggestions, although the GitHub Desktop client made the work much simpler than using Git command-line operations.

The GitHub Desktop client is used to put the local hexo-authoring folder, nfoCentrale/spanner/ under Git.   This works just fine for making local repositories that are not clones of repositories published on the internet anywhere (just yet).

When a new local repository is established, there is no association as the clone of any cloud-based repository at GitHub or elsewhere.  The first few commits establish configuration conditions on what is managed, with .gitignore and .gitattributes

First steps include adding .gitattributes and changing the .gitignore file already there, thanks to Hexo Install.   The .gitignore change has the spanner/themes sub-folder be ignored.

The landscape theme being used and customized is added into a separate local repository.

In bringing an existing folder under Git, its name must be used.  Later, the matching GitHub repository can be given a different name when the local one is published.

For each local repository, the existing material is checked-in, identifying different blocks in single commits.  Already-customized items are checked-in individually with messages that reflect their status.

When a git repository is initiated over an already-populated folder-tree, the contents show up as new uncommitted material.  These can be selectively committed to Git in a way that provides an useful initial history.

When all of the material to be tracked and change-managed is committed to one of the repositories, it is published.   Since there is no remote already, GitHub Desktop offers an opportunity to create a GitHub project. 

When the local repository has all of the pre-existing content committed, it can be published to GitHub.  The Publish action invites creation of a new GitHup repository.  The connection is automatic thereafter.

Once published, synchronization is used in the usual way for uploading the local commits to the GitHub repository.

Although the theme and the overall authoring folder are managed as separate GitHub repositories, there is no treatment as forks of any original sources.   Cherry-picking from updates to upstream sources will be reconciled when the time comes.  Similarly, if there is desire to contribute and push changes upstream, forks will be made for that purpose.

Posted in Blog Development, blogs, Golden Geek, Spanner Wingnut, Toolcraft | Tagged , , , , , | 2 Comments