Neither Master nor Slave Be

I just encountered “GitHub to replace master with main starting in October: What developers need to do now.”

It should be clear this use of the term Master has nothing to do with there being Git branches named “slave.”  The usage of “master” is akin to the recording industry and audio-visual use of the term with regard to an original/authoritative form of some kind.

We are up against a problem with words having more than one meaning in language.  Here we are leaping from the use of master-slave terminology in technology to other standalone usages of master, however those came into being. 

I don’t doubt that “master” has become a trigger and that it is an useful removal from Git[Hub] as a replacement “with terms of inclusion that cannot be misconstrued.”  I am not clear how “main” becomes a term of inclusion though.  I cannot argue that the usage is not divisive; I do wonder about the technological use of “male” and “female” as terms of art applicable to household and industrial products and how one speaks of them to hardware-store clerks.

As a practical matter of direct concern for me is mastering (see what I did there) propagation (dare I say it) of replacement terms in existing Git repositories and deep links into their on-line forms at GitHub.  I have created an issue on the matter in the repository that is of greatest concern to me.

It is helpful that GitHub will somehow “indirect” the use of Git “master” to Git “main”, at least for GitHub repositories.  I am a bit concerned about how this will be reflected in an update to the GitHub client for Windows, and how that will impact using it with non-GitHub repositories.

This situation reminds me of the problem created by browsers designed to force https protocol prefixes and then claim that web sites served only via http are insecure.  I find Blacklight more nuanced and helpful.  (Try it on https://orcmid.blogspot.com for starters.)

I hazard that such geek paternalism is rampant and may be a cure that is worse than the disease: absence of systems thinking and failure to consider end-to-end discontinuities. 

I will comply; I claim the right to grumble.

The Edges of the Box

 Discussing Inspiration versus Perspiration, at the weekend Mysterium 2020 con, Rand Miller talks about "the box" and working within it in a creative activity.  This is not about coloring in the lines, it is about accomplishing something with the resources available and the unpredictability and surprises that show up in the development.

Doing the small thing really well can be the ramp to learning/discovery and a way of bootstrapping to anything more ambitious.

Hearing that, I was reminded of my tribulations with The Miser Project and what I should do to delineate the oMiser development inside all of the thinking-out-loud Issues.

The initial box is having a sufficient proof-of-concept.  That means the SML/NJ mockup will provide a working oFrugal that allows exercise of the oMiser computational model.  The mockup is practical for demonstration of how the theoretical limits of computation are achieved.  The particular model also brings focus to how the stored-program concept affords representing numerous theoretical entities related to practical reality.  

This does not mean that oFrugal is particularly expressive.  It is essentially a calculator for deriving oMiser obs.  oFrugal and oMiser lack support for expressing representations at higher levels.  oFrugal/oMiser make that limitation almost self-evident.

But that's the box.  Having captured a variety of ideas that don't have to be addressed, I will retreat to working inside (but pushing) the edges.

Soft Landing for Clear Voice

Before the world shifted under our feet this year, I blogged about restoration of my voices across what I refer to as nfoCentrale, an amalgamation of web sites and blogs.

Lately I have turned, instead, to down-sizing and consolidation, focusing on a small number of projects that are central to my computer-science vocation.  This is a realistic move in light of my age and limited energy and enthusiasm, recognizing I have cast a net with too many unwoven holes in it.

Consolidation will be on GitHub, since it provides version control, Markdown authoring, hosting, wikis, and preservation of projects.  I expect that GitHub will endure as long as I require it, and having Git as a laboratory and preservation mechanism is ideal.

I will continue the nfoCentrale site, although more add-on domains will be surrendered; the content will remain as subdirectories of nfoCentrale.com and the catalog will reflect the altered amalgamation reality.

I also have to consider migration to a blog or two hosted on GitHub rather than Blogger.  This will provide relief from the disconnects between the current Blogger and LiveWriter; LiveWriter files are also not ideal for preservation purposes, though better than none.  I am saddened by the loss of continuity.  I will work through that in small steps. 

Situating Performance Architecture

"Without the cognitive work that people engage in with each other, all software systems eventually fail" ACM Queue January 2020

It should be no surprise that our devices and computer software train us to learn how to operate with them.  We are the adaptable participants.  At the same time, we are not aided in formulation of conceptual models and practices that afford successful interactions.  

Perhaps the way to articulate my concern about this is by reflecting on a situation that was successful.  This was years ago; it is the handiest illustration that I have personal experience of.

Performance Patterns

The diagram below is a depiction that I refer to as a Performance Architecture.  It is a diagrammatic pattern that involves scanned images being captured and organized in digital form.  I term this an RSVP pattern: Read/render, Store, View, Print/present.

Used before Design Patterns became a thing in software development, the template for components of this pattern are very simple.

Based on the notion of dataflow diagrams, the indications of flow can be taken simply as transfer of data across a definite interface from one process to another process or storage.

By itself the RSVP pattern is abstracted at a high level above a detailed implementation case.  The pattern depicts an intermediate performance-architecture level.  Going deeper exposes more internal arrangements.  The surface at which users and operators approach and interact with the (sub)systems is also suggested.  At this informal conceptual level, fidelity of operation takes two forms.  There is specified technical fidelity to specified variations that an implementation supports.  At the same time, there is subjective (light-bulb) fidelity with respect to a particular usage situation and how that is satisfied by experimentation and confirmation of operation.

Customized Application

In an actual custom application, depicted above, the RSVP pattern was divided between two operations, 4.2 and 4.3, factoring the conceptual arrangement further.  Choreography with the additional activities involves considerable manual arrangements involving physical artifacts and a worksheet that is maintained throughout the progression of operations.
  

The purpose of creating digital images was preservation of scarce physical books that were deteriorating as the result of 19th century printing using papers produced via acid-based pulp-paper processing.  The phenomenon is evident in old paperback books and also old newspapers.  The book pages become brittle, discolored, and fragile.  In order to preserve the books digitally, the book is destroyed by removing (guillotining) the binding, separating the individual pages.  It is the individual pages that are scanned without any mechanical feeding, checked for successful capture of the pages, and then added to a digital collection with additional material for organization of the images as pages of a digital book. A printed and bound replacement book is produced and checked against the original pages.

Overall Situation

Rescue of deteriorating 19th century books was part of a prototype effort conducted to determine a successful preservation approach.  The effort was tied into an overall college-campus research library system.  Although the RSVP pattern occurs informally within activity 4.0, Make Digital Preservation, integration into operation of the research library and honoring of the sensibilities of the research librarians and curators was paramount.

People are not explicitly reflected in the diagrams.  There are human activities everywhere the physical and the digital are in conjunction.  Also, fine-grained iterations are to be understood.  There were provisions for rework and also correction from errors –- blemished scanning, pages out of sequence.  There also was a need for training of operators and supervision of operation.  Computer Center operations were relied upon for IT support. 

Although highly-tacit, the diagrams of this kind often serve as touch-stones for the participants to orient themselves with regard to their contributions and the overall enterprise.  It also reflects the constraints on subordinate procedures and what their architecture must serve in the higher level depiction.

This situating provided global context for agreement among the technical team providing the digital RSVP portions and the personnel of the library.  The entire undertaking was through a successful prototype codevelopment.  The digitally-preserved books are now part of an extensive set of digital collections made available on the World Wide Web.

There was important technology dependence.  Adequate preservation required high-quality flatbed scanning of book pages that was protective of the fragile pages.  High resolution xerographic printing of indelibly-fixed toners on archival papers was accomplished using an original Xerox DocuTech Network Publisher fed from a Unix server.

The configuration information is rather barren in the absence of the architectural patterns and the situating external architecture.  We get a view of what the system configuration is, but not what it is for.  And this is the most-replaceable component in the overall performance architecture.

At the intermediate and upward into the external architecture, there is a diagrammatic means for shared understanding and evolution of variations, improvements and extensions.  There is significant acknowledgment of tacit understanding, and a place for confirmation of consistency among those understandings between producers and those who adopt and employ the resulting system.

This case study is meant to be suggestive about preservation of end-to-end and user-situated understanding by sketches of this sort.  Whatever the form employed, distinguishing the levels and capturing the context in which built components must fit is important for understanding of the developers and those the development serves.  

nfoCentrale: Longing for Clear Voices

I have had several blogs.  Some of their dormant states are linked on the sidebar here.  My inattention to maintenance of consistent voices on particular themes has led to fracture and confusion (for myself at least) with respect to my Internet presences.

A feature I miss is having separate blogs focused on roughly-consistent themes.  There has been 10 years of neglect since I was flummoxed by breaking-for-me changes in how Blogger worked. Now there is fragmentation of voice to reconcile. 

• Numbering Peano for the Miser Project, with theoretical and implementation facing matters now also addressed on the GitHub project, GitHub-hosted documentation, and perhaps a Miser Project Wiki.  Project issues are also used as a form of dialog on topics.  Discounting the Facebook presence, my pent-up need to provide a blog narration started with Orcmid’s Live Hideout (on Wordpress) and migration of posts under a label here.  That’s not satisfying, and I might migrate one more time with revival of Numbering Peano.  What a scatter-brain that orcmid is.
    
• Professor von Clueless, where I prefer to consolidate geeky developer materials and also tie ins related to nfoWorks, nfoWare , and the GitHub nfoTools (and a few others), all oriented to beginner/enthusiast/developer matters.  The separate nfoWorks diary is also languishing, with its focus on interoperability and electronic documents.
    
• nfoCentrale, the web-site anchor and its now decrepit status blog and the Spanner Wingnut experimental blog (and its predecessors) for confirming blog setups and templates prior to attempting changes to another “production” blog.
    
• Orcmid’s Lair, this respawning of a previous incarnation that is also the sequel to Orcmid’s Live Hideout, itself an imperfect image-losing migration from a blog originally hosted on Windows Live when there was such a thing.  There is a great of material on the Live Hideout blog, going back to 2007.  It was meant to be just an experiment, not Orcmid’s Lair accumulated offerings du jour.

What a mish-mash!

Some of this has to deal with me being so easily distracted and pursuing of new shiny things. “Squirrel!”.  At the same time, there is also confirmation that life-cycle of vendor (i.e., MIcrosoft) products and the continuing-use dependency of end-users are wildly different. 

So many blogs are dormant since 2010 because I failed to come up with appealing replacements.  Self-hosting of Movable Type on nfoCentrale.com and node.js development of hexo-based blogs didn’t pan out and they managed to have little deployment apart from experimentation on Spanner WIngnut. 

Here I am, having traveled full-circle, using Blogger and free blogspot,com hosting.  This restoration of Orcmid’s Lair (and continuation of Orcmid’s Live Hideout) is just one step. 

I remain wary and cautious, faced with tending this octopus’s garden of mine and achievement of some manageable consistency.

Suspicious Numerals in the Forest of Representations

In speaking of representational ambiguity as it arises in connection with the Miser Project, I realize that such ambiguities should not be surprising.   Representation ambiguities are plentiful in the daily lives of those reading this post.  They arise casually but suffer when incorporated in computer-processed data.

Here’s a value that is relevant in my world: 800-00-0271.  It has the form of a United States Social Security Number (SSN).  It might be one, if it’s established that it was so-assigned to someone by the US Social Security administration, and if that is the intended usage.

Calling something a Social Security Number because it has the pattern of one is different than claiming it is the SSN of an identified person.  In working around computers, we need to be more careful in distinguishing what a data element might be intended to designate and the simple data form used absent any context.

So far, the “800” is not used in SSNs, and it is used where I see it on the assumption that will never change. 

Something that 800-00-0271 can be is a Student ID Number appearing on a transcript from Regents College of the University of the State of New York.  I attest that I am that student. 

US educational institutions have tended to rely on actual SSNs of students as identifiers for student records and other purposes.  In the State of New York, at the time I registered, the State requested SSNs but did not require them. It was considered illegal to compel SSN for that purpose at that time.  I declined and was provided with a unique identifier having the same form.  It has SSN form because the Student ID Number in their systems are mostly SSNs and have that format.  The “800” part is not found in any actual SSN (so far) and that ID number is safely comingled in the college’s records and databases indexed by their Student ID numbers, ones which are most-often also SSNs.

Another case arose recently, with the date of February 2, 2020 being represented as 02-02-2020.  The question is, considering that as representative of a date, is the form mm-dd-yyyy or dd-mm-yyyy?  It can be either, and the form does not reveal the answer.  In this case, it doesn’t matter.  Both forms are satisfied and can be taken to reference to the same date (with agreement about the same calendar).  The differences are apparent when different dates are recorded in different international contexts.  Both forms have been used in the USA in the past.

It might be easier now to understand the International Standard preference for recording dates in form yyyy-mm-dd.  Although only about as well received in the USA as the metric system, this form does tend to be used in the internals of data systems.  If we mean that to be a date somewhere on the planet, the time zone becomes relevant and without it, the expanded form 2020-02-02T02:02 is still representationally ambiguous, assuming of course, that this is intended to represent a local-time date somewhere on the planet.  Then, what about Daylight Time?  In Australia?

[added 2020-02-09T11:03] The “T11:03” here resolves another representational ambiguity.  It is in 24-hour time.  So there need be no concern whether it is AM or PM (T23:03).

[added 2020-02-09T10:53] Although it took a few years too many for Microsoft Outlook to deal with local times and time zones, it now does so and I can record on my calendar a trip starting in one local time (departure) and ending in a different local time (arrival) on the same or different date.  I can also record times from two time zones along a day-calendar page.  I use s pair of UTC and whatever the local time zone I awoke in on a particular day.  The tricky part comes with Daylight switch-overs and the fact that the daylight time status of a date in the past is not retained.  Recurring items can get a little wonky.

[added 2020-02-09T19:10Z] (with the “Z” for Zulu signifying UTC) One case I hadn’t figured out how to manage in all of this is for timestamps on my public web sites.  I author pages on a local machine and file timestamps are in my local time, the way that has always been presented on the Windows file system.  When I FTP changed pages to the public site, they get a different time stamp.  So I can have my FTP utility check and only upload newer pages than those there, I have to specify a time-offset so FTP gets it right.  I fumble this far too often, and passing in and out of Daylight time messes me up even more.  I would love to just use UTC in this context and have not figured out how to accomplish it.  Hmmm.  Maybe if I fudge the clock on the local web-site development server?

Miser Project: Interpretation, Representation, Computation, and Manifestation

“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.  There's expectation of trustworthy assurance of suitable quality: someone has checked the math and verified the software in a transparent and trustworthy undertaking.
   
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” and “context” 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 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 appealed to.  They are elaborated in this post.

2019-11-05 Clean Draft on Blogger.  This post series is migrated from Orcmid's Live Hideout and cleaned up and continued here on the Blogger reincarnation of Orcmid's Lair.  There has been some smoothing in the illustration of concepts, correcting section numbering also.
2019-11-04 Penultimate Draft: Some major adjustments and stitching in notions of ontological commitment prior to digging into the ‹ob› computational model details.
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.

Preliminaries

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

Content

1. Recap: Computation-Model Stage-Setting
2. Structure, Interpretation, Representation, Computation, and Manifestation
3. Review: More About Structure
4. Interpretation: Variations on a Theme
5. Concerning Representational Ambiguity
6. Choreography of Computation
7. Manifestation and Tacit Awareness
8. 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.

Interpretation of other structures and their effectively-computable primitives via  representations in ‹ob› sets the stage for  valid computational interpretation 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›.

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  can be taken as 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 entities are readily discerned upon inspection of (computationally) derived representatives.
• typically: a representation may provide multiple representatives 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 many ways that every single ob is representative in interpretations of Boolean Algebra elements 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 as evocative (manifesting) some other object or activity
• operational: act of producing/presenting objects or activities taken 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 ∀x∀y∀z, 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, the particular representations there, and the specific means of representation.  So 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 primitives of ‹A›. 
• If the theory of ‹A› is an application of FOL=, represent “x = y” of ‹A›  with ‹B›  predicate b.I.a.is-eq(Ix, Iy), or simply  Ix =I Iy.
  When
               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›.

Valid 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 ‹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.
  

5. Concerning Representational 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 the same entity in ‹A›, including the designated (characteristic or canonical) interpretation of that entity in ‹B›.  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 (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› ⊥ or ⊤.  The ob.p01.bp functions corresponding to ‹bp› primitive notions properly simulate ‹bp›.   The function ob.p01.bp.comp( x ) and agreement on canonical form are revealing in respect to  interpretation ob.NE.bp as canonical in 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  suggestive, not conclusive.   (Nevertheless, 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 not merely cues in the code.)

It is valuable to express derived obs in a form that signifies what they are intended representatives for.  For now it is noteworthy that obs themselves do not reveal intended representations and that serves computational representation quite well in the computational-model formulation.
 

6. 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.

The 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 action.  This could be a human performance, although our focus is on digital computers and computational procedures enacted with them.

Consider 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 e_in and e_out refer to specific instances of an encoded input and an encoded output.

It is valuable in this diagrammatic approach to have input and output formats 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 and the input and output formats be described in the same terms – a consistent level of abstraction.

The 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, e_in has a determined output e_out 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 potentially a superior level of abstraction.  Consider taking some e_in as representations of values, x, of some kind X, the derived e_out as representing values, y, of kind Y. With respect to those representations, the input and the derived output are taken as satisfying a functional relationship symbolized as F:X→Y.

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.

Although the e_in and e_out are representatives of respective X and Y entities, the utility of the computation (and this kind of diagramming) hinges on discerning those entities that are so interpretable. Having engineered such a setup, observation of its satisfaction hinges on confirming interpretation that individual e_in and e_out are interpretable as appropriate X and Y entities.  Relative to the intended purpose of the arrangement, I and O can be viewed as data structures, a level of abstraction below that of X, Y, and F.

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 represent F and X together in satisfying F:X→Y with the computed output.

In this abbreviated example the computational process, so construed, is that of an ob calculator whose input is itself expressed as an ob. 

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

e_out = obap.eval (e_in )

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 is having a 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. There will be more levels than this compressed case in depicting practical cases of the ‹ob› model of 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.
 

7. 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.

    It 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.

That 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.

When the sense is stripped away completely, at a level so subordinate that there is no tacit recognition (as in the enlarged tip of a rendition of “w”), we can discern how 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 miniscule electronically-generated features to manifest text that is in-turn evocative of a communication.

When text is in natural language you are practiced at reading, it takes effort to avoid automatically grasping some sense of the text.  It is easy to 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, for understanding how computers are so marvelous, to appreciate who is making that leap and how well 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.

Tacit recognition is important in how manifestations are evoked with so much fidelity that the manifest entity is perceived as being manipulated and preserved by computer interaction.  The accomplishment is a wonder 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.

In discussion choreography of computation (section 6), cases of manifestation can be discerned in the rather simple diagrammatic indication of what a computation is versus what it is for, in terms of functional relationships.
 

8. 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 (without any metaphysical claims, however).

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 6, 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›, in that case, 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 and objects in our reality (such as persons, other animate entities, and organizations of such entities).  Such representations may have some relationship with those entities, but they must not be confused with them.

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.

As the ‹ob› computational model and its oMiser (and oFrugal) implementations are presented, there will be more detailed treatment of computational choreography, manifestation, and a sprinkling of ontological commitment.

Onward.

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

2019-11-12 Editing: Repair reflow where formulas are mangled.  Other touch-ups.
2019-11-05 Update: Complete separation from the WordPress version.
2019-11-03 Update: Touch-ups with initial migration to Blogger
2019-01-02 Update: Corrects ob.p01.bp representation of x ⊆ y and simplifies ob.p01.bp.is-eq(x,y) in boole.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 while 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›. 

Preliminaries

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

1. 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 the primitive functions and many other functions are in Of.

The way that a function f( x₁, x₂, .., x_n ) 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, x₁, x₂, .., x_n, the definitions pertaining to
           f( x₁, x₂, .., x_n )
  lead to deduction, in a finite number of steps, to at most one definite result,
       y = f( x₁, x₂, .., x_n ).
• It can be the case that there is no definite result for some operands, x_i.
• When there is a definite result for all definite operands, x₁, x₂, .., x_n, f is said to be a total function.  It is defined on all obs.
• When there is no definite result for all definite operands,
  x₁, x₂, .., x_n, 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( x₁, x₂, .., x_n ) = g( x₁, x₂, .., x_n ) is deducible for all definite x, where each have definite result, we say that the same function is represented.
• We expect no counterpart of canonical forms for functions.  Determination that two representations are for the same function involves a mathematical proof.
• Determination that two representations are not for the same function is often by directly exhibiting operands x₁, x₂, .., x_n, for which
          f( x₁, x₂, .., x_n ) ≠ g( x₁, x₂, .., x_n )

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.

1.1 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.

1.2 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,

mirror( 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 Of, since Of is declared to include all functions on ob operands with results in Ob.  This is by definition of
    ‹ob› = 〈Ob,Of,Ot〉.

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. Here, 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.

1.3 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
             ⇒ bink(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.   In rigorous speaking of the abstractness of mathematical entities it will be preferable, instead, to say 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.  Demonstrations of equivalence also favor substitution of simpler representations for 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, making aLast( y ) more appealing).

2. 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 is thereby 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 are confirmed to satisfy the axiomatic specification.

2.1 ‹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.

2.2 ‹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.bvx, that provides an interpretation for all finite Boolean Algebra cases.  The justification is essentially mathematical; 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 what are termed concrete Boolean Algebra 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 ‹bvn› n-tuple, X, the indicator function Ia_i( X ) determines whether a_i is a member of the corresponding (concrete) subset.

2.4 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.bvx, there is a canonical form that can be used in expressing individual vectors in a sometimes-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.

Continuation

1. Interpretation, Representation, Computation, and Manifestation
   Reprise and account for specialized concepts in Miser Project, setting up for representation of the computation model