Luận án tiến sĩ: NummSquared 2006A0 Explained, including a new well-founded functional foundation for logic, mathematics and computer science

Type theory is a goodfoundation for logic, mathematics and computer science, except that, by making bothtypes and functions fundamental, it is more complex than either set theory or the

NUMMSQUARED OVERVIEW AND COMPARISON

UNTYPED LAMBDA CALCULUS AND IMPROVEMENTS

The untyped lambda calculus (see [6, section 2]) suffers from non-terminating reductions Letting ‘f be (lambda x (x x)), consider (‘f ‘f), which reduces to itself.

The untyped lambda calculus, when enhanced with negation for logical purposes, encounters Russell’s paradox, as illustrated by the expression ‘R = (lambda x (not (x x))), which leads to the contradictory result of (‘R ‘R) reducing to (not (‘R ‘R)) Consequently, (‘R ‘R) cannot be classified as true or false Additionally, incorporating implication into the untyped lambda calculus gives rise to Curry’s paradox.

In 1932, Church introduced the untyped lambda calculus, followed by his type theory in 1940 in response to paradoxes Meanwhile, Russell uncovered his paradox in 1902 within Frege’s predicate calculus, which utilized Frege’s course-of-values notation akin to lambda notation, along with Basic Law V and the Rule of Substitution This combination led to a situation where there were more functions than distinct objects To address this paradox, Russell proposed his theory of types in 1903 In summary, the developments in Frege’s predicate calculus and Russell’s theory of types are pivotal in the evolution of mathematical logic.

An improvement on the untyped lambda calculus in [2, section 2.2] resolves Rus- sell’s paradox, but some propositions are neither true nor false.

Gilmores NaDSyL addresses Russell's paradox by establishing that formulas can be classified as either true or false However, the overall set of formulas remains undecidable, and there is no internal predicate that corresponds to this set of formulas.

Grue's map theory enhances untyped lambda calculus by integrating ZFC set theory, while generally rejecting the principle of excluded middle However, it acknowledges that excluded middle holds true in a significant specific scenario.

The article discusses a programming language that encompasses untyped lambda terms and set-theoretic functions It highlights that untyped lambda terms can be confined to specific set domains, allowing them to serve as arguments for set-theoretic functions.

Despite various enhancements to the untyped lambda calculus, non-terminating reductions remain unresolved Each improvement, with the exception of Howe, features a logic that is partially non-classical Notably, in NaDSyL, this non-classicality manifests as the undecidability of the formula set Conversely, Howe's programming language, while not a logic in itself, serves to provide semantics for Nuprl.

SET THEORY, VON NEUMANNANDJONES

Zermelo's resolution of Russell's paradox in Frege's predicate calculus, further developed by Fraenkel, led to the formulation of ZF set theory, which constructs sets from existing ones Unlike Frege's approach, ZF avoids paradoxes without utilizing types, instead employing the axiom of replacement for more limited abstraction When combined with the axiom of choice, ZF is referred to as ZFC Additionally, the axiom of regularity in ZF ensures that membership relations are well-founded, confirming the foundational nature of ZF set theory.

The axiomatization of functions by von Neumann is closely related to ZFC and has been adapted into the von Neumann-Bernays-Gédel (NBG) set theory As set theory serves as the standard foundation for mathematics, von Neumann's work was modified to facilitate comparisons with other set theories However, computer science focuses on computable functions, and many set theories, including ZFC and NBG, lack rules for function call reduction and set membership reduction, highlighting a distinction between the conventions of set theory in first-order logic and the theory of functions in computer science.

Von Neumann's axiomatization, while lacking reduction rules, shares conceptual similarities with combinatory logic and the untyped lambda calculus However, unlike von Neumann's framework, which serves as a solid foundation for logic and mathematics, combinatory logic and the untyped lambda calculus face challenges such as Russell's paradox when negation and excluded middle are introduced, and Curry’s paradox when augmented by implication Interestingly, the predominant foundations for computer science derive from the untyped lambda calculus and its typed variations that address these paradoxes, rather than von Neumann's axiomatization, which is more aligned with classical set theory.

Table 2.1: Von Neumann's axiomatization and combinatory logic roughly compared

Jones introduced Pure Functions as an axiomatization of functions connected to ZFC, utilizing the formal language HOL enhanced with ZFC Despite its foundational approach, Pure Functions does not include rules of reduction.

Farmer introduced "STMM: A Set Theory for Mechanized Mathematics," which is grounded in NBG and emphasizes sets as the core concept rather than functions Nonetheless, STMM incorporates lambda notation for functions and includes notation for function calls.

NummSquared emphasizes the primacy of functions, similar to the untyped lambda calculus and Pure Functions, where functions serve as the core concept This approach aligns with type theory and von Neumann's axiomatization, reinforcing the idea that functions are foundational in the framework of NummSquared.

Unlike set or type theory, NummSquared does not make sets or types fundamental.

In von Neumann's axiomatization, a specific object symbolizes false, serving as the default result of a function A function can be utilized as an argument only if its outcomes rarely deviate from false This raises practical concerns, as the criterion for determining when a function can be used as an argument is not computable.

In von Neumann's axiomatization, certain functions cannot serve as arguments or results Pure Functions include external functions, which resemble Higher-Order Logic (HOL) functions By restricting an external function to the domain of an internal function, it is possible to derive an internal function.

NummSquared, akin to von Neumann and Pure Functions, differentiates between small and large functions Both categories are defined in relation to all small functions, consistently yielding small functions as their output.

In NummSquared, for simplicity, only large functions appear directly in Numm- Squared programs, which differs from von Neumann and Pure Functions.

In NummSquared, a large function ‘f can be Curried The partial call to to ‘fis a small function, and is restricted using the domain of a small function.

Neither von Neumann nor Jones attempt to make functions computable.

NummSquared enhances von Neumann's axiomatization and Pure Functions by incorporating reduction and proof, utilizing HOLS proofs at the metalevel due to its definition within HOL It employs coercion to establish small functions across all small functions while ensuring computability, forming the foundation for reduction Additionally, NummSquared facilitates reflection, further advancing its capabilities.

* NummSquared has an interpreter, NsGo (work in progress), so the language can be practically used.

ZF and NBG are both well-founded systems, particularly when the axiom of regularity is considered In the context of Pure Functions, membership within the field of a Pure Function establishes a well-founded relation, confirming that Pure Functions themselves are well-founded.

An important subset of map theory (called the classical maps) is well-founded - see

The range of classical maps is constructed from existing maps, with the complexity of the inductive hypothesis reflecting the intricacies of the domain rather than relying on fixed assumptions In contrast, NummSquared is grounded similarly to Pure Functions, where the membership of a non-null small function is a well-founded relation among small functions NummSquared small functions are defined across all small functions to minimize constraints, utilizing a computable coercion to extend the definition of a function beyond its domain This coercion shares similarities with the restriction of untyped lambda terms to set domains, but differs in that NummSquared coercion is automatic and does not necessitate proof of type equality, as seen in Observational Type Theory.

The well-foundedness of NummSquared strengthens the connection between NummSquared and set theory.

In NummSquared, a combination is a large function that combines one or more large functions (somewhat similar in concept to the functional forms of Backus’s FP

- see [5, section 11.1]) Like FRB NummSquared is variable-free Combinations make variables unnecessary (Of course, variable syntactic sugar for NummSquared would be possible.)

NummSquared does not utilize function calls, which can lead to the perception that variable-free languages are challenging to read; however, this is largely dependent on the user's familiarity with the notation Despite being variable-free, NummSquared employs lambda calculus function call notation for its large and small composition combinations, resembling lambda calculus syntax but without variables Additionally, NummSquared incorporates local tuple accessors as an alternative to argument variables.

Programmers frequently seek to enhance a programming language's syntax, and while macro languages offer this capability, they often fall short in providing the desirable features of the original language A more effective alternative is reflection, which allows programs written in a language 'L' to manipulate other programs within the same language, thereby enabling greater flexibility and functionality.

According to [19, section 7], a language like NummSquared, which has terminating reduction, is unable to express its own interpreter There are several approaches to address Hoare’s incomputability result One common method involves the use of macro languages for syntactic manipulations, which do not necessitate invoking the language's interpreter Additionally, partial reflection, as suggested in (20, p.2-3), allows for the possibility of expressing an interpreter for a specific subset of the language, though this subset cannot represent its own interpreter Lastly, it may be feasible to create a bounded interpreter for the language, which functions like the original interpreter but halts with an error if the interpretation does not complete within a predetermined number of steps.

EQUALITY 0 ee HH ee ene 11

A relation ‘R on functions is an extensional equality iff, for any two functions ‘f and

Functions 'f' and 'g' are considered extensionally equal if their domains are identical and they yield the same results for all inputs from that domain This type of equality can equate functions that utilize different algorithms, as noted in [18, question 35] However, extensional equality poses challenges in computer science because it is not computable In the context of von Neumann's axiomatization and pure functions, equality is defined as extensional.

In NummSquared, small functions are represented by rules, while simpler small functions are depicted through more straightforward means The concept of equality in NummSquared is extensional for rule small functions, although it is not computable and thus cannot be employed in reduction Despite this limitation, equality plays a crucial role in propositions Conversely, computable equality, which excludes rule small functions, can be effectively utilized in reduction processes.

Gilmore's Intensional Type Theory (ITT) includes an appealing Rule of Intension- ality stating that the intensions of two predicates are Leibniz equal iff their names are

Gilmore addresses Russell's paradox by considering a predicate term as a name only when it lacks free predicate variables This approach highlights the significance of the Rule of Intensionality in the context of equality within computer science Furthermore, HiLog equality, which is derived from names, is computable and emphasizes the foundational principles of equality in programming languages.

In the future, NummSquared's equality on rule small functions may evolve to incorporate elements of ITT and HiLog Currently, an extensional equality is preferred for its logical and mathematical simplicity, although it presents challenges in computer science This choice enhances the relationship between NummSquared and set theory, particularly aligning with the axiom of extensionality in Zermelo-Fraenkel (ZF) set theory.

NSGO 2 cc ee ee eee ee ee ee eens 12

The NummSquared program interacts with other software through NsGo, which supports two methods of interaction When executed as a process, NsGo takes input as a NummSquared program and outputs either the program's results or error messages, alongside an exit code This limited interaction enhances security by isolating NsGo from global state changes, allowing for straightforward recovery from crashes, such as power failures, by simply re-running NsGo Additionally, as a NET assembly, NsGo can function as a library, enabling various calls from within NET applications.

Progress towards NsGo can be found in [22].

A language is an unordered collection of things without duplicates For a language

‘L, a program of ‘Lis a thing belonging to ‘L For languages ‘LO and “L1, ‘LO = “L1 iff, for each thing ‘x, ‘x is an ‘LO program iff ‘x is an ‘L1 program.

A language ‘L is formal iff ‘L is defined precisely A language ‘L is informal iff ‘L is not formal Mathematical English is an example of an informal language.

A document consists of programs written in one or more languages, divided into formal and informal parts The formal part includes programs of formal languages, while the informal part contains programs of informal languages Any informal comments embedded within the formal section are categorized as part of the informal segment.

The formal and informal parts of a document serve distinct yet complementary purposes While the formal section is ideal for clearly defining concepts, the informal section is valuable for discussing practical aspects and connecting these formal ideas to existing informal ones Additionally, the informal part can aid in defining new formal languages and relating them to established languages However, when good existing formal languages are available, it is recommended to utilize the formal section for definitions and comparisons, reserving the informal section for necessary explanations related to informal languages.

_ The formal part and informal part are the formal and informal parts, respectively, of the document you are reading.

WHERETO FIND THEFORMALPART

WHERE TO FIND THE FORMAL PART

This document presents the NummSquared metatheory, beginning with an informal section that provides comprehensive definitions, theorems, and proofs articulated in mathematical English Additionally, the formal representation of the NummSquared metatheory in the Cog language is included at the end, although this aspect is still under development.

NOTATIONINTHEINFORMALPART

NOTATION IN THE INFORMAL PART

Some notation is used in the informal part.

Where a phrase is defined, the phrase is written like this.

Text is given emphasis by writing it like this.

When quoting sources, the text is written “like this”, as with the following pearl from

Informal identifiers, marked by a grave accent (‘), are case-sensitive and can include periods (.) Examples of informal identifiers include ‘x, “X, ‘XO, and ‘A.x These identifiers differ from those in the formal section and from identifiers of the language being analyzed.

Anatural number is one of the things 0, 1, 2, (each distinct from the others) Let

‘Nat be the language of all natural numbers.

A Unicode code point (see [39, section 2.4]) is a natural number in the range 0-

1114111 Let ‘Unicode be the language of all Unicode code points.

Asingle isolated character in fixed-width font (the font distinguishes it from other text) represents a Unicode code point Example: H.

Two or more adjacent characters in fixed-width font represent a list (see below) of

NUMMSQUAREDSEMANTICS

DATA IN THE INFORMAL PART

The informal part now incorporates various types of data, aiming to offer capabilities similar to those found in NBG set theory.

Let ‘x = ‘y iff ‘x and ‘y are equal (equals must be defined for various kinds of data). Letx # yiffnotx=y.

The thing ‘null is introduced ‘null should be interpreted as the absence of relevant information, like the null pointer in many programming languages.

A Boolean is either 0 or 1, which should be interpreted as false or true, respectively. Let ‘Boo be the language of all Booleans.

For a Boolean ‘b, the negation of ‘b, denoted by ‘not(‘b), is 0 if ‘b = 1; and 1 otherwise.

To avoid confusion between the informal part and some language being discussed, the term language is preferred to the more conventional term set.

For languages “L0 and ‘LI, ‘LO is a sub-language of “L1 iff each ‘LO program is an ‘L1 program.

The empty language, denoted by ‘Lang.empty, is the language that has no programs.

For a language ‘L, ‘L is empty iff ‘L = ‘Lang.empty.

For a thing ‘x, the singleton of ‘x, denoted by ‘sing(‘x), is the language whose only program is ‘x.

For languages “L0 and “L1, the intersection of L0 and ‘L1, denoted by 'intersect(L0,

The union of languages L0 and L1, represented as union(L0, L1), encompasses all elements x that qualify as either an L0 program, an L1 program, or both.

A model consists of a language 'S and a specific mapping of each 'S program to a unique entity The source of a model 'm, represented as 'src('m), refers to the language component For any program 'x within 'src('m), the interpretation by model 'm, denoted as 'm('x), assigns a distinct entity to 'x Two models, 'm0 and 'm1, are considered equal, expressed as 'm0 = 'm1, if they share the same interpretations.

‘src(‘m0) = ‘src(‘m1) and, for each ‘src(‘m0) program ‘x, m0(*) = ‘m1(‘x).

To avoid confusion between the informal part and some language being discussed, the term model is preferred to the more conventional term function.

For a model ‘m, the destination of ‘m, denoted by ‘des(‘m), is the language of all

‘m(‘x) such that ‘xis a ‘src(‘m) program.

For a model ‘m and a language ‘S, ‘m is from ‘S iff ‘src(‘m) = “S.

In the context of a model ‘m and a language ‘D, model ‘m is considered to be a sub-language of ‘D if its description ‘des(‘m) falls within ‘D Additionally, for a language ‘S and an entity ‘y, the constant model from ‘S to ‘y, represented as ‘constant(‘S, ‘y), is defined as the model ‘m from ‘S where, for every program ‘x in ‘S, the output of ‘m(‘x) consistently equals ‘y.

For a language ‘S, the identity model on ‘S, denoted by ‘identity(‘S), is the model ‘m from ‘S such that, for each ‘S program ‘x, ‘m(‘x) = ‘x.

A pair is an ordered collection of two things, possibly with duplicates For a pair ‘p, the left and right of ‘p are thing one and thing two of ‘p, respectively For a pair ‘p, let

‘left(‘p) and ‘right(‘p) be the left and right of ‘p, respectively For pairs “p0 and “p1, “p0

= 'p1 iff Teftfp0) = ‘left(‘p1) and ‘right(‘p0) = ‘right(‘p1) For things ‘x0 and “x1, let be the pair ‘p such that ‘left(‘p) = ‘x0 and ‘right(‘p) = ‘x1.

Pairs are used to represent tuples (in a manner similar to [36, p.16]).

For any natural number $ m > 2 $ and an object $ t $, the definition of $ t $ being an $ m $-tuple is established recursively Specifically, if $ m = 2 $, then $ t $ is an $ m $-tuple if it is a pair For $ m > 2 $, $ t $ qualifies as an $ m $-tuple if it is a pair and its left component is an $ m - 1 $ tuple.

For a natural number ‘m > 2, and things ‘xg, XỊ Xm-2› Xm-1› let be the ‘m tuple -

For a pair ‘p = , let ‘flip(‘p) be .

Pairs are used to represent lists (in a manner similar to [29]).

Lists are defined inductively A list is exactly one of the following:

A list ‘lis empty iff ‘l= 0 The empty list is represented by 0, not ‘null The empty list is often interpreted differently than the absence of relevant information.

For a non-empty list , the head of 1, denoted by “head(), is ‘h; and the rest of “1, denoted by ‘rest(‘N), is ‘r.

For a list '1, the length of 1, denoted by ‘len(‘l), is defined by recursion on ‘I: se Oif‘1=0 se len(T) + Lif ‘l=

For a natural number ‘m, and things ‘xg, XỊ, Xm.1› let 1 be the length ‘m list .

For a list 1= 1, an element of ‘lis one of ‘xo, %1, , ‘Xqy-1- For a language ‘L, and a list ‘l, ‘lis of ‘Liff each element of Ì is an ‘L program.

For a non-empty list 1= 1 1.

For a property ‘PB and a relation < on ‘P < is well-founded iff there is no model ‘x from ‘Nat such that, for each natural number ‘m, ‘P(‘x(‘m)) and ‘x(‘m + 1) < ‘x(‘m) (See

[34, section 3] for a definition of a well-founded relation, and equivalent statements.)

For a language ‘L, ‘Lis small iff there exists some ZFC set ‘s (see [36, p.84,132-133]) and some model ‘m from ‘s such that ‘L is a sub-language of ‘des(‘s).

NUMMSQUAREDSYNTAX

NummSquared semantics have been established for both reduction and truth The computable aspect of these semantics enables a direct definition of reduction as a total function, ensuring automatic termination in the process.

NummSquared semantics are established through the definition of small function extensions, which form its core To address coercion and computational needs, the domain of a rule small function extension is represented by a domain extension, which retains the same information as a type in type theory but serves a different function The domain extension irrelevance theorem states that domain extensions provide no additional information beyond their domains Furthermore, tagged small function extensions are created by enhancing rule small function extensions with domain extensions, referred to as tags.

The tag irrelevance theorem suggests that tagging does not contribute additional information due to the domain extension irrelevance NummSquared coercion serves as a generalization of coercion, or type conversion, applicable to higher-order functions across various programming languages, and is defined by well-founded tango Additionally, the coercion stability theorem asserts that coercion processes do not introduce unnecessary modifications.

Coercion defines tagged small function extensions while ensuring computability, forming the foundation for reduction The extensionality theorem characterizes equality among rule tagged small function extensions Additionally, large function extensions, exemplified by NummSquared, are established, with the truth of both tagged small and large function extensions being clearly defined.

This article explores various extensions and combinations of large functions, highlighting both computational and non-computational aspects Notably, it discusses computational large function extensions such as Curry and recursion, alongside non-computational large function extensions like equals and Hilbert.

Even though small function extensions never appear directly in NummSquared programs, they are the core of NummSquared (The word extension means an object of the semantics.)

A null small function extension is exactly the null small function extension,

The term 'Func.Sm.Ext.null' signifies the absence of relevant information, akin to the null pointer in various programming languages It is crucial to note that 'Func.Sm.Ext.null' should not be equated with 0, false, undefined, or non-termination, as Numm-Squared reduction consistently terminates In map theory, there exists a comparable nil element, which is interpreted as both true and 0.

A zero small function extension inherently includes a null small function extension, where containment refers to structural containment, similar to how a record encompasses its fields This structural containment is essential for facilitating structural recursion and induction.

The zero small function extension, denoted as ‘Func.Sm.Ext.zero, includes ‘Func.Sm.Ext.null For any zero small function extension ‘x, it holds that ‘x is equivalent to ‘Func.Sm.Ext.zero, which should be understood as false.

A one small function extension, denoted as , consists of a null small function extension (‘n) and a zero small function extension (‘z) The notation ‘Func.Sm.Ext.one represents this one small function extension, which includes both ‘Func.Sm.Ext.null and ‘Func.Sm.Ext.zero For any one small function extension ‘x, it can be expressed as ‘x = ‘Func.Sm.Ext.one, indicating that ‘Func.Sm.Ext.one is to be interpreted as true.

A leaf small function extension is exactly one of the following:

* a zero small function extension ¢ aone small function extension

For leaf small function extensions ‘x and ‘y, ‘x = ‘y iff exactly one of the following holds:

* ‘x= ‘Func.Sm.Ext.null and ‘y = ‘Func.Sm.Ext.null. e ‘x= ‘Func.Sm.Ext.zero and ‘y = ‘Func.Sm.Ext.zero. © ‘x= Tunc.Sm.Ext.one and ‘y = ‘Func.Sm.Ext.one.

Small function extensions are defined inductively Let ‘Func.Sm.Ext be the language of all small function extensions.

Asmall function extension is exactly one of the following: ¢ asimple small function extension

A simple small function extension is exactly one of the following: ¢ aleaf small function extension

A small function extension is represented by a pair that includes , where ‘n denotes a null small function extension, ‘z signifies a zero small function extension, ‘o indicates a one small function extension, and ‘left and ‘right represent additional small function extensions.

A rule small function extension contains a model ‘model to ‘Func.Sm.Ext such that

‘src(‘model) is a small sub-language of ‘Func.Sm.Ext.

This concludes the inductive definition.

For a pair small function extension ‘p containing , the left and right of ‘p are ‘left and ‘right, respectively For a pair small function extension ‘p, let

In the context of pair small function extensions, let ‘p represent a function, with ‘left(‘p) and ‘right(‘p) denoting its left and right components, respectively Two small function extensions, ‘p0 and ‘p1, are considered equal if their left components and right components are identical, specifically ‘left(‘p0) = ‘left(‘p1) and ‘right(‘p0) = ‘right(‘p1) Additionally, for small function extensions ‘x0 and ‘x1, the notation {‘x0, ‘x1} signifies a pair small function extension.

‘p such that ‘left(‘p) = ‘x0 and ‘right(‘p) = ‘x1.

For any natural number $ m > 2 $ and a small function extension $ t $, the definition of $ t $ being an $ m $-tuple is established recursively Specifically, when $ m = 2 $, $ t $ qualifies as an $ m $-tuple if it is a pair of small function extensions For $ m > 2 $, $ t $ is considered an $ m $-tuple if it is a pair of small function extensions and the left component of $ t $ also meets this criterion.

For a natural number ‘m = 2, and small function extensions ‘xg, ‘x1, , Xn-2,

‘X4n-y let %0; %1, -ằ K4n-2ằ X4n-1} be the ‘m tuple {{f{'xg, ‘xy }, Xm-2} Xm-1è- Let ‘Func.Sm.Ext.Null be the language of all null smail function extensions.

For a small function extension ‘f, ‘fis a nuro iff ‘f = ‘Func.Sm.Ext.null or ‘f‘Func.Sm.Ext.zero.

Let ‘Func.Sm.Ext.Nuro be the language of all nuro small function extensions.

For a small function extension ‘f, ‘fis a Boolean iff ‘f = ‘Func.Sm.Ext.zero or ‘f“Func.Sm.Ext.one.

Let ‘Func.Sm.Ext.Boo be the language of all Boolean small function extensions. Let ‘Func.Sm.Ext.Leaf be the language of all leaf small function extensions.

In the context of small function extensions, a function 'f' is classified as a tree based on specific recursive criteria Firstly, if 'f' is a leaf small function extension, it qualifies as a tree Secondly, if 'f' is a pair small function extension, it is considered a tree only if both 'left(f)' and 'right(f)' are trees themselves Lastly, if 'f' is a rule small function extension, it does not meet the criteria to be classified as a tree.

Let ‘Func.Sm.Ext.Tree be the language of all tree small function extensions.

7.2_ DOMAIN AND SPECIFIC RESULT OF A SMALL FUNC-

For a small function extension ‘f, the domain of ‘f (a small sub-language of

The domain of the function, denoted as 'dom('f), is defined by several mutually exclusive cases: it is 'Func.Sm.Ext.Null when 'f equals 'Func.Sm.Ext.null, and it is also 'Func.Sm.Ext.Null when 'f equals 'Func.Sm.Ext.zero Additionally, it is 'Func.Sm.Ext.Nuro when 'f equals 'Func.Sm.Ext.one, and 'Func.Sm.Ext.Leaf when 'f is a pair small function extension Lastly, it is 'src('model) when 'f is a rule small function extension that includes 'model.

‘Func.Sm.Ext.null is a ‘dom(‘Func.Sm.Ext.null) program Thus ‘Func.Sm.Ext.null is a program of its own domain.

For a nuro small function extension ‘x, ‘dom(‘x) = ‘Func.Sm.Ext.Null.

For a leaf small function extension ‘x, ‘dom(‘x) is a sub-language of

For a tree small function extension ‘t, ‘dom(‘t) is a sub-language of

For a small function extension ‘f and a program ‘x within its domain, the result of ‘f at ‘x, denoted as ‘f, can be determined by several mutually exclusive cases: if ‘f is a leaf small function extension, then ‘f equals ‘x; if ‘f is a pair small function extension and ‘x equals ‘Func.Sm.Ext.zero, then ‘f is ‘Func.Sm.Ext.null; if ‘x equals ‘Func.Sm.Ext.one, then ‘f is ‘right(‘f); and if ‘f is a rule small function extension that includes ‘model, then ‘f results in ‘model(‘x).

For a small function extension ‘f, the range of ‘f (a small sub-language of

‘Func.Sm.Ext), denoted by ‘ran(‘f), is the language of all ‘f such that ‘x is a ‘dom(‘f) program.

‘ran(‘Func.Sm.Ext.null) = ‘Func.Sm.Ext.Null.

‘ran(‘Func.Sm.Ext.zero) = ‘Func.Sm.Ext.Null.

‘ran(‘Func.Sm.Ext.one) = ‘Func.Sm.Ext.Nuro.

For a leaf small function extension ‘x, ‘ran(‘x) = ‘dom(‘x).

For a pair small function extension ‘p, ‘ran(‘p) is the language whose only programs are ‘Func.Sm.Ext.null, ‘left(‘p) and ‘right(‘p).

For a rule small function extension ‘r containing ‘model, ‘ran(‘r) = ‘des(‘model). For a nuro small function extension ‘x, ‘ran(‘x) = ‘Func.Sm.Ext.Null.

For a leaf small function extension ‘x, ‘ran(‘x) is a sub-language of

For a tree small function extension ‘t, ‘ran(‘t) is a sub-language of ‘Func.Sm.Ext.Tree. For a small function extension ‘f, the field of ‘f (a small sub-language of

‘Func.Sm.Ext), denoted by ‘field(‘f), is ‘union(‘dom(‘f), ‘ran(‘f)).

For a small function extension ‘f # ‘Func.Sm.Ext.null, and a ‘field(‘f) program ‘x, ‘x is structurally smaller than ‘f.

For small function extensions ‘f and ‘g, ‘f = ‘g iff exactly one of the following holds:

ee eee 88 LARGEFUNCTIONS

TREEPREDICATE

~Tree.step.pair {%r.dom %r.ran %func} =

For a tagged small function extension ‘x = {‘t.dom, ‘r.ran, ‘func},

The function `Func.Lg.Ext.Tree.step.pair('x)` operates under specific mutually exclusive scenarios: it returns `Func.Lg.Ext.conf.n(r.ran(Func.Sm.Ext.one))` if `r.ran('Func.Sm.Ext.zero)` is true; it yields `Func.Sm.Ext.one` to `Func.Sm.Ext.zero` if `r.ran('Func.Sm.Ext.zero)` equals `Func.Sm.Ext.zero`; and it outputs `Punc.Sm.Ext.null` if `r.ran('Func.Sm.Ext.zero)` is not a Boolean value.

~Tree.step {%r.dom %r.ran %£unc} =

For a tagged small function extension ‘x = {r.dom, T.ran, func},

‘Func.Lg.Ext.Tree.step(‘x) is given by one of the following mutually exclusive cases: ¢ ‘Func.Sm.Ext.one if ‘func is a leaf small function extension

* ‘Func.Lg.Ext.Tree.step.pair(‘x) if ‘func is a pair tagged small function extension s ‘Func.Sm.Ext.zero if ‘func is a rule tagged small function extension

The function extension 'Func.Lg.Ext.Tree('x) is determined by specific cases: if 'x' is a leaf small function extension, then 'Func.Lg.Ext.Tree('x) equals 'Func.Sm.Ext.one Conversely, if 'x' is a pair tagged small function extension, the value of 'Func.Lg.Ext.Tree('x) is defined by additional mutually exclusive cases.

- ‘Func.Lg.Ext.conf.n(‘Func.Lg.Ext.Tree(‘right(‘x))) if

‘Func.Lg.Ext.Tree(‘left(‘x)) = ‘Func.Sm.Ext.one

— ‘Func.Sm.Ext.zero if ‘Func.Lg.Ext.Tree(‘left(‘x)) = ‘Func.Sm.Ext.zero

- ‘Func.Sm.Ext.null if ‘Func.Lg.Ext.Tree(‘left(‘x)) is not Boolean ằ If ‘xis a rule tagged small function extension: ‘Func.Lg.Ext.Tree(‘x) ‘Func.Sm.Ext.zero.

If x is equal to Func.Sm.Ext.null, then Func.Lg.Ext.Tree(x) results in Func.Sm.Ext.one Conversely, if x is not equal to Func.Sm.Ext.null, Func.Lg.Ext.Tree(x) will yield Func.Lg.Ext.Tree.step({1rDom).

— ‘rDom is the rule tagged small function extension such that ‘domExt(‘rDom)

= ‘domExt(‘x) and, for each for each ‘dom(‘rDom) program ‘y, ‘rDom ‘Func.Lg.Ext.Tree(‘tagged(‘rDom, ‘y)).

— ‘rRan is the rule tagged small function extension such that ‘domExt(‘rRan)

= ‘domExt(‘x) and, for each ‘dom(‘rRan) program “y, ‘rRan ‘Func.Lg.Ext.Tree(‘x(‘tagged (‘rRan, ‘y))) Oj

For a tagged small function extension “x, ‘Func.Lg.Ext.Tree(‘x) = ‘Func.Sm.Ext.one if

‘xis a tree; and ‘Func.Sm.Ext.zero otherwise.

If 'x' is a leaf small function extension, it holds true that 'Func.Lg.Ext.Tree(left(x))' equals 'Func.Sm.Ext.one' when 'left(x)' is a tree, and 'Func.Sm.Ext.zero' otherwise, based on the inductive hypothesis Additionally, 'Func.Lg.Ext.Tree(right(x))' is also determined by the properties of 'x'.

‘right(‘x) is a tree; and ‘Func.Sm.Ext.zero otherwise (by inductive hypothesis).

‘Func.Lg.Ext.Tree(‘x) is ‘Func.Sm.Ext.one if ‘left(‘x) and ‘right(‘x) are trees; and

‘Func.Sm.Ext.zero otherwise.

* Holds if ‘x is a rule tagged small function extension 1

~res {%func %arg} = (%func $%arg);

For a tagged small function extension ‘x = {‘func, ‘arg}, ‘Func.Lg.Ext.res(‘x) ‘func(‘arg).

For a normalized large function ‘unrestrict:

In pseudo-NummSquared, a definition parameterized by a normalized large function, such as "restrict['unrestrict]," corresponds to an implicit definition that links the informal identifier with its large function extension This relationship is also parameterized by a large function extension, exemplified by "restrict['unrestrict]" based on the large function extension 'unrestrict.

In the context of function extensions, the large function extension 'unrestrict' and the tagged small function extension 'x' are related through the rule tagged small function extension 'r' This relationship holds true when the domain extensions of 'r' and 'x' are identical, specifically 'domExt('r) = 'domExt('x)' Furthermore, for every program 'y' in the domain of 'r', the application of 'r' to 'y' results in 'unrestrict(tagged(r, y))'.

Proof “restrict{‘unrestrict] (‘x) is the rule tagged small function extension ‘r such that ‘domExt(‘r) = ‘domExt(‘x) and, for each ‘dom(‘r) program ‘y, ‘r = [‘unrestrict

‘Func.Lg.Ext.right] ({‘x, 'tagged(T, ‘y)}) = ‘unrestrict(‘tagged(', ‘y)) q

For a normalized large function “unrestrict:

~restrict.ran[‘unrestrict] = ~c[[‘unrestrict ~res] ~1];

In the context of function extensions, the large function extension 'unrestrict' and the tagged small function extension 'x' are related through the rule 'restrict.ran[‘unrestrict] (‘x)' This establishes a tagged small function extension 'r' with the same domain as 'x' For every program 'y' within the domain of 'r', the relationship 'r' is equivalent to 'unrestrict(x(tagged(T, ‘y)))', which further simplifies to 'unrestrict(‘x)'.

Proof “restrict.ran[‘unrestrict] (‘x) is the rule tagged small function extension ‘r such that ‘domExt(‘r) = ‘domExt(‘x) and, for each ‘dom(‘r) program ‘y, ‘r = [‘unrestrict

‘Func.Lg.Ext.res] ({‘x, ‘tagged(‘r, ‘y)}) = ‘unrestrict(‘x(‘tagged('r, ‘y))) 0

For a tagged small function extension ‘x, ‘Func.Lg.Ext.Nuro.set.res(‘x) is ‘x if ‘xis a nuro; and ‘Func.Sm.Ext.null otherwise.

For a tagged small function extension ‘x, ‘Func.Lg.Ext.Nuro.set.res(‘x) ‘Func.Sm.Ext.Tagged.Nuro.set(‘x).

For a tagged small function extension ‘x, ‘Func.Lg.Ext.Nuro.set.res(‘x) ‘Func.Sm.Ext.one(‘X).

For a tagged small function extension ‘x, ‘Func.Lg.Ext.Tree.set.res(‘x) is ‘x if “x is a tree; and ‘Func.Sm.Ext.null otherwise.

For a tagged small function extension ‘x, ‘Func.Lg.Ext.Tree.set.res(‘x) ‘Func.Sm.Ext.Tagged.Tree.set(‘x).

In a tagged small function extension, the expression ‘x = {‘family, ‘pair} indicates that if ‘pair is a tagged small function extension, then the result of Func.Lg.Ext.s.d.res.left(“) is ‘domFuncExt(‘family) (‘left(‘pair)) Otherwise, the result defaults to ‘Func.Sm.Ext.null.

( [~dom (%family ~s.d.res.left) ] [~right %pair] )

For a tagged small function extension ‘x = {‘family, ‘pair}, ‘Func.Lg.Ext.s.d.res.right(‘x) is ‘dom-

FuncExt(‘family(‘Func.Lg.Ext.s.d.res.left(‘x))) (‘right(‘pair)) if ‘pair is a pair tagged smail function extension; and “Func.Sm.Ext.null otherwise.

In the context of a tagged small function extension 'x' defined as {'family', 'pair'}, the function 'Func.Lg.Ext.s.d.res(x)' yields the result { 'Func.Lg.Ext.s.d.res.left(x)', 'Func.Lg.Ext.s.d.res.right(x)' } when 'pair' is identified as a pair tagged small function extension Conversely, if 'pair' is not a pair tagged small function extension, the function returns 'Func.Sm.Ext.null'.

For a tagged small function extension ‘x = {‘family, ‘pair}, ‘Func.Lg.Ext.s.d.res(‘x) ‘sumDep(‘family) (‘pair).

Proof. se If ‘pair is a pair tagged small function extension: ‘Func.Lg.Ext.s.d.res(“x) is the pair tagged small function extension ‘p such that ‘left(‘p)

= ‘domFuncExt(‘family) (‘left(‘pair)) and ‘right(‘p) = ‘dom-

FuncExt(‘family(‘left(‘p))) (‘right(‘pair)). ® If ‘pair is not a pair tagged small function extension: ‘Func.Lg.Ext.s.d.res(‘x) ‘Func.Sm.Ext.null oO

~p.d.res.rule.uncurry {%family %rule %arg} =

( [~dom (%family %arg)] (%rule %arg) );

For a tagged small function extension ‘x = {‘family, ‘rule, ‘arg},

‘Func.Lg.Ext.p.d.res.rule.uncurry(‘x) = ‘domFuncExt(‘family(‘arg)) (‘rule(‘arg)).

The tagged small function extension 'x = {'family', 'rule'} defines 'Func.Lg.Ext.p.d.res.rule('x') as the rule tagged small function extension 'r', where 'domExt('r) is a subset of 'domExt('family) Furthermore, for every program 'y' in 'dom('r), the relationship 'r< 'y>' is established through 'Func.Lg.Ext.p.d.res.rule.uncurry({'family', 'rule', 'tagged(r, 'y')}).

For a tagged small function extension ‘x = {‘family, ‘rule}, if ‘rule is a rule tagged small function extension, then ‘Func.Lg.Ext.p.d.res.rule(‘x) = ‘prodDep(‘family) (‘rule).

Proof ‘Func.Lg.Ext.p.d.res.rule(‘x) is the rule tagged small function extension ‘r such that ‘domExt(‘r) = ‘domExt(‘family) and, for each ‘dom(‘r) program program “y, ‘r ‘domFuncExt(‘family(‘tagged(‘r, ‘y))) (‘rule(‘tagged(‘r, ‘y))) 0

For a tagged small function extension ‘x = {family, ‘rule}, ‘Func.Lg.Ext.p.d.res(‘x) is ‘Func.Lg.Ext.p.d.res.rule(‘x) if ‘rule is a rule tagged small function extension; and

‘Func.Sm.Ext.null otherwise.

For a tagged small function extension ‘x = {family, ‘rule}, ‘Func.Lg.Ext.p.d.res(‘x) ‘prodDep(‘family) (‘rule).

In the context of function extensions, if a rule is tagged as a small function extension, it can be represented by the expression ‘Func.Lg-Ext.p.d.res(‘x) and ‘Func.Lg.Ext.p.d.res.rule(‘x) Conversely, if the rule is not tagged as a small function extension, the expression changes to ‘Func.Lg.Ext.p.d.res(‘x) and ‘Func.Sm.Ext.null o.

For normalized large functions ‘uncurry and ‘augmentor:

For large function extensions ‘uncurry and ‘augmentor, and a tagged small function extension ‘z = {‘x, ‘y}, “c.aug.uncurry[‘uncurry ‘augmentor] (‘z) = ‘uncurry({‘augmentor(‘x), ‘y}).

For normalized large functions ‘uncurry, ‘restrictor and ‘augmentor:

The large function extensions 'uncurry', 'restrictor', and 'augmentor', along with the tagged small function extension 'x', can be defined through the rule tagged small function extension 'r' This rule stipulates that 'domExt(r)' is a subset of 'domExt(restrictor(augmentor(x)))' Additionally, for every program 'y' in 'dom(r)', the relationship 'r' holds true, leading to the equation 'c.aug.uncurry[uncurry(augmentor)({x, tagged(r, y)})] = uncurry({augmentor(x)'.

For large function extensions ‘uncurry, ‘restrictor and ‘augmentor, and a tagged small function extension ‘x, ~c.aug[‘uncurry ‘restrictor ‘augmentor] (‘x) = ["c[‘uncurry

Proof [c[Ứuncurry ‘restrictor] ‘augmentor] (‘x) = ~c[‘uncurry ‘restrictor] (‘augmentor(‘x)) is the rule tagged small function extension ‘r such that ‘domExt(‘r)

= ‘domExt(‘Testrictor(‘augmentor(‘x))) and, for each ‘dom(‘r) program program ‘y,

For a normalized large function ‘uncurry:

For a large function extension ‘uncurry, and a tagged small function extension ‘z {‘x, ‘restrictor, ‘y}, “c.res[‘uncurry] (‘z) = ‘uncurry({‘x, ‘domFuncExt(‘restrictor)(‘y)}).

For normalized large functions ‘start and ‘step:

~r.dom{‘start ‘step] = ~restrict[~r[‘start step]];

For large function extensions ‘start and ‘step, and a tagged small function extension ‘x, “r.dom|[‘start ‘step](‘x) is the rule tagged small function extension ‘r such that

‘domExt(‘r) = ‘domExt(‘x) and, for each ‘dom(‘r) program program ‘y, ‘r = “r[‘start 'step](tagged(T, ‘y)).

For normalized large functions ‘start and ‘step:

~r.ran[‘start ‘step] = ~restrict.ran[~r[‘start ‘step]];

In the context of large function extensions 'start' and 'step', along with a tagged small function extension 'x', the expression "r.ran['start' 'step']('x)" defines a rule tagged small function extension 'r' This extension 'r' shares the same domain as 'x', specifically 'domExt(r) = domExt(x)' Furthermore, for every program 'y' within the domain of 'r', the transformation T (Op AA) ): Op_Simp-Ty.

The identity simple operator on A is the simple operator on A mapping a: A onto a. Definition Op_Simp_identity_Ty := ( V(A : Type), (Op_Simp A) ) : Type.

Definition Op_Simp_identity := ( fan Aa=> a) : Op_Simp_identity TY.

A binary operator from A0, A1 to Bis an operator from Á0 to an operator from A1 to

Definition Op_Bin_Ty := ( V(A0: Type)(A1 : Type)(B: Type), Type) : Type.

Definition Op_Bin := ( fun AO Al B> (Op AO (Op A1 B)) ) : Op_Bin_Ty.

A connective binary operator from A to Bis a binary operator from A, A to B.

Definition Op_ Bin_Conn_ Ty := ( V(A: Type)(B: Type), Type) : Type.

Definition Op_Bin_Conn := ( fun A B => (Op_Bin AA B) ) : Op_Bin_Conn_Ty.

A simple binary operator on A is a connective binary operator from Ato A.

Definition Op_Bin_Simp_Ty := (W(A: Type), Type) : Type.

Definition Op_Bin_Simp := ( fun A => (Op_Bin_Conn AA) ) : Op_Bin_Simp-Ty.

A trinary operator from A0, Al, A2 to Bis an operator from A0 to a binary operator from Al, A2 to B.

Definition Op-_Tri_Ty :( V(A0: Type)(A1 : Type)(A2: Type)(B: Type), Type) : Type.

Definition Op- Tri :( fun A0 A1 A2 B> (Op A0 (Op-_Bin Al A2 B)) ) : Op_Tri_Ty.

A connective trinary operator from A to Bis a trinary operator from A, A, Ato B. Definition Op_Tri_Conn_Ty := ( V(A : Type)(B: Type), Type) : Type.

Definition Op_Tri_Conn := ( fun A B=> (Op_Tri AAAB) ): Op_Tri_Conn_Ty.

A simple trinary operator on Ais a connective trinary operator from A to A.

Definition Op_Tri_Simp_Ty := ( V(A : Type), Type) : Type.

Definition Op_Tri_Simp:= ( fun A=> (Op_Tri.Conn A A) ) : Op_ Trí Simp_ Ty.

A quaternary operator from A0, Al, A2, A3to Bis an operator from A0 to a trinary operator from Al, A2, A3 to B.

Definition Op_Quat_Ty :(V(A0: Type){Al : Type)(A2: Type)(A3: Type)(B: Type), Type)

Definition Op_ Quat :(fun A0 A1 A2 A3 B> (Op A0 (Op-_Tri A1 A2 A3 B)) ) : Op_Quat Ty.

A connective quaternary operator from A to Bis a quaternary operator from A, A, A, Ato B.

Definition Op_Quat_Conn_Ty := ( V(A : Type)(B: Type), Type) : Type.

Definition Op_ Quat_Conn :(fun A B> (Op_QuatAAA A B) ) : Op_-Quat_Conn_Ty.

A simple quaternary operator on Ais a connective quaternary operator from Ato A. Definition Op_Quat_Simp_Ty := ( V(A : Type), Type) : Type.

Definition Op_Quat_Simp:= ( fun A=> (Op-Quat_Conn AA) ) : Op-Quat_Simp-Ty.

A quinary operator from A0, Al, A2, A3, A4 to Bis an operator from A0 to a quaternary operator from A1, A2, A3, A4to B.

Definition Op_ Quin_ Ty :(Vv

(A0: Type) (A1: Type) (A2: Type) (A3: Type) (A4: Type) (B: Type), Type

Definition Op_ Quin :( fun A0 Al A2 A3 A4 B => (Op A0 (Op-_Quat A1 A2 A3 A4 B)) )

A connective quinary operator from A to Bis a quinary operator from A, A, A, A, A to B

Definition Op_Quin_Conn_Ty := ( V(A: Type)(B: Type), Type) : Type.

Definition Op_ Quin_ Conn :(fun A B= (Op-QuinAAAAA B) ): Op_ Quin_Conn_ Tỳ.

A simple quinary operator on Ais a connective quinary operator from Ato A.

Definition Op_ Quin_Simp_ Ty := ( V(A: Type), Type) : Type.

Definition Op Quin Simp := ( fun A > (Op_Quin_Conn A A) ) : Op_Quin_Simp- Ty.

Poohbist.NummSquared.Fundamentals.Propositions.Main

Poohbist.NummSquared.Fundamentals.Propositions.Main outlines the definitions of various propositional predicates, including binary, trinary, quaternary, and quinary types It also covers essential propositional predicates, alongside the concepts of true and false propositions.

Require Import Poohbist NummSquared Fundamentals Operators Main.

A propositional predicate on A is an operator from A to Prop.

Definition Prp_Pred_Ty := (W(A: Type), Type) : Type.

Definition Prp_ Pred := ( fun A=> (Op A Prop) ) : Prp_Pred_Ty.

The constant propositonal predicate on A onto P: Propis the constant operator from A to Prop onto P.

Definition Prp_ Pred_const_ Ty :(V(A: Type)(P: Prop), (Prp_ Pred A) ) : Type.

Definition Prp_Pred_const :( fun A P > (Op_const A Prop P) ) : Prp_Pred_const_ Tỳ.

A binary propositional predicate on A0, Al is a binary operator from A0, A1 to Prop. Definition Prp_Pred_Bin_Ty := ( V(A0: Type)(Al: Type), Type) : Type.

Definition Prp_Pred_ Bin :( fun A0 Al > (Op_Bin A0 Al Prop) ) : Prp_Pred_Bin_Ty.

A connective binary propositional predicate on Ais a binary propositional predicate on A, A.

Definition Prp_Pred_Bin_Conn_Ty := ( V(A: Type), Type): Type.

Definition Prp_ Pred_Bin_ Conn :( fun A > (Prp_Pred_Bin AA) ): Prp_ Pred_Bin_Conn_ Tỳ.

A trinary propositional predicate on A0, Al, A2is a trinary operator from A0, Al, A2 to Prop.

Definition Prp_Pred_Tri_Ty :(V(A0: Type)(Al: Type)(A2: Type), Type) : Type.

Definition Prp_Pred_Tri:( fun AO Al A2 => (Op_Tri A0 A1 A2 Prop) ): Prp_Pred_Tri_Ty.

A connective trinary propositional predicate on Ais a trinary propositional predicate on A, A, A.

Definition Prp_Pred_Tri_Conn_Ty := (W(A: Type), Type) : Type.

Definition Prp_Pred_Tri_Conn :( fun A => (Prp_Pred_Tri AAA) ) : Prp_Pred_Tri_Conn_Ty.

A quaternary propositional predicate on A0, A1, A2, A3 is a quaternary operator from AO, Al, A2, A3 to Prop.

Definition Prp_Pred_Quat_Ty :(V(A0: Type)(Al : Type)(A2: Type)(A3: Type), Type): Type.

Definition Prp_Pred_Quat :( fun A0 Al A2 A3 => (Op_Quat A0 A1 A2 A3 Prop) ) : Prp_Pred_Quat_Ty.

A connective quaternary propositional predicate on A is a quaternary propositional predicate on A, A, A, A.

Definition Prp_ Pred_ Quat_Conn_ Ty := ( V(A : Type), Type) : Type.

Definition Prp_Pred_Quat_Conn :( fun A= (Prp_Pred_Quat AAAA) ): Prp_Pred_Quat_Conn-_Thy.

A quinary propositional predicate on A0, A1, A2, A3, A4is a quinary operator from A0, Al, A2 A3, A4 to Prop.

Definition Prp_ Pred_Quin_Ty :( V(AO: Type)(A1: Type)(A2: Type)(A3: Type)(A4: Type), Type)

Definition Prp_Pred_ Quin :( fun A0 A1 A2 A3 A4 > (Op_Quin A0 A1 A2 A3 A4 Prop) )

A connective quinary propositional predicate on Ais a quinary propositional predicate on A, A, A, A, A.

Definition Prp_Pred_Quin.Conn_Ty := ( V(A: Type), Type) : Type.

Definition Prp_ Pred_ Quin_ Conn :(fun A= (Prp_Pred_Quin AAAAA) ): Prp Pred_Quin_Conn_ Tỳ.

There is exactly one proof of the true proposition: the true proposition proof.

Prp_T is defined in the same way as True in Coq Init Logic.

Inductive Prp_T : Prop :| Prp_T_proof : Prp_T.

There are no proofs of the false proposition.

Prp_F is defined in the same way as False in Coq Init Logic.

Poohbist.NummSquared Fundamentals Booleans.Main

Poohbist.NummSquared Fundamentals explores the concept of Booleans, detailing various types of Boolean predicates, including binary, trinary, quaternary, and quinary predicates It also highlights essential fundamental Boolean predicates and discusses an operator that connects Booleans to propositions.

Require Import Poohbist NummSquared.Fundamentals Operators.Main.

Require Import Poohbist NummSquared.Fundamentals.Propositions.Main.

A Boolean is exactly one of the following: ¢ the true Boolean e the false Boolean

Boo is defined in the same way as bool in Coq Init Datatypes, except that Boo: Type whereas bool: Set.

Inductive Boo: Type :| Boo_t: Boo

A Boolean predicate on Ais an operator from A to Boo.

Definition Boo_Pred_Ty := ( V(A : Type), Type) : Type.

Definition Boo_ Pred := ( fun A=> (Op A Boo) ) : Boo_Pred_Ty.

The constant Boolean predicate on A onto b: Boo is the constant operator from Ato Boo onto b.

Definition Boo_ Pred_const_Ty :( V(A: Type)(b: Boo), (Boo_ Pred A) ) : Type.

Definition Boo_Pred_const :( fun A b> (Op_const A Boo b) ) : Boo_Pred_const_Ty.

BINARYBOOLEANPREDICATES

A binary Boolean predicate on A0, A1 is a binary operator from A0, Al to Boo.

Definition Boo_Pred_Bin_Ty := ( V(A0: Type)(A1 : Type), Type) : Type.

Definition Boo_Pred_Bin:( fun A0 Al > (Op_Bin A0 Al Boo) ) : Boo_Pred_Bin_Ty.

A connective binary Boolean predicate on Ais a binary Boolean predicate on A, A. Definition Boo_Pred_Bin_Conn_Ty := (V(A: Type), Type): Type.

Definition Boo_Pred_Bin_Conn :( fun A= (Boo_Pred_Bin AA) ) : Boo_Pred_Bin_Conn_Ty.

TRINARYBOOLEANPREDICATES

A trinary Boolean predicate on A0, Al, A2is a trinary operator from A0, Al, A2to Boo.

Definition Boo_Pred_Tri_Ty :(V(A0: Type)(A1: Type)(A2: Type), Type) : Type.

Definition Boo_Pred_Tri:( fun A0 A1 A2=> (Op- Tri A0 A1 A2 Boo) ) : Boo_Pred_Tri_Ty.

A connective trinary Boolean predicate on Ais a trinary Boolean predicate on A, A, A.

Definition Boo_Pred_Tri_Conn_Ty := ( V(A : Type), Type) : Type.

Definition Boo_Pred_Tri_Conn :(fun A > (Boo_Pred_Tri AAA) ): Boo_Pred_Tri.Conn-_Ty.

A quaternary Boolean predicate on A0, A1, A2, A3 is a quaternary operator from A0,

Definition Boo_ Pred_ Quat_ Ty :(V(A0: Type)(Al : Type)(A2: Type)(A3: Type), Type) : Type.

Definition Boo_ Pred Quat :( fun A0 Al A2 A3 => (Op_Quat A0 A1 A2 A3 Boo) ) : Boo_Pred_Quat_Ty.

A connective quaternary Boolean predicate on Ais a quaternary Boolean predicate on A, A, A, A.

Definition Boo_ Pred_Quat_ Conn_ Ty := ( V(A : Type), Type) : Type.

Definition Boo_ Pred_ Quat_ Conn :( fun A => (Boo_ Pred_ Quat A A A A) ) : Boo_ Pred_ Quat_ Conn_ T.

A quinary Boolean predicate on A0, A1, A2, A3, A4is a quinary operator from A0, A1,A2, A3, A4to Boo.

Definition Boo_Pred_ Quin_ Ty :(V(A0: Type)(A1: Type)(A2: Type)(A3: Type)(A4: Type), Type)

Definition Boo_ Pred_ Quin :(fun A0 Al A2 A3 A4 > (Op_ Quin A0 Al A2 A3 A4 Boo) )

A connective quinary Boolean predicate on Ais a quinary Boolean predicate on A, A,

Definition Boo_Pred_Quin.Conn_Ty := ( V(A : Type), Type) : Type.

Definition Boo_Pred_Quin_Conn :( fun A > (Boo_Pred_Quin AAAAA) ): Boo_Pred_Quin_Conn_Ty.

(Boo_to_ Prp b) is the true proposition if b; and the false proposition otherwise.

Boo_to_Prp is defined in the same way as Is_true in Coq.Bool.Bool.

Definition Boo_to_Prp:= ( fan b> if b return Prop then Prp_T else Prp_F

(Boo_eq b0 b1) is the true Boolean if b0 and b1 are structurally equal; and the false Boolean otherwise.

Definition Boo_eq := ( fun b0 b1 > match b0, bl return Boo with

): (Boo Pred_ Bin_Conn Boo).

(Boo_not b) is the false Boolean if b; and the true Boolean otherwise.

Definition Boo_not := ( fun b=> if b return Boo then Boo_f else Boo_t

Poohbist.NummSquared.Fundamentals Naturals.Main

Poohbist.NummSquared Fundamentals Naturals.Main defines natural numbers, and some operators on natural numbers.

Require Import Poohbist.NummSquared Fundamentals Operators.Main.

Require Import Poohbist NummSquared Fundamentals Booleans.Main.

A natural number is exactly one of the following: e the zero natural number e for some natural number m, the successor natural number of m

Nat is defined in the same way as nat in Coq Init.Datatypes, except that Nat: Type whereas nat:Set.

Inductive Nat: Type :| Nat_z: Nat

9.5.3 ABBREVIATIONS FOR SOME NATURAL NUMBERS

(Nat_eq m0 m1) is the true Boolean if m0 and m1 are structurally equal; and the false Boolean otherwise.

Definition Nat_eq := ( fix fp(m0: Nat)(m1: Nat){struct m0}: Boo :match m0, m1 return Boo with

| Nat_s m0Pre, Nat_s m1Pre => (fp m0Pre m1Pre)

): (Boo_Pred_Bin_Conn Nat).

(Nat_iter Af am) applies f m-times starting with a.

Definition Nat_iter_Ty :(V(A: Type)(f : (Op_Simp A)), (Op_Bin A Nat A) ) : Type.

Definition Nat_iter := ( fan Af a> fix fp(m: Nat){struct m}: A :match m return A with

| Nat_s mPre => (f (fp mPre)) end

Nat_add is somewhat similar in concept to the plus function in [28, p.234].

Definition Nat_add := (fun m=> fix fp(n: Nat{struct rủ : Nat :match n return Nat with

| Nat_s nPre = (Nat_s (fp nPre)) end

Nat_mult is somewhat similar in concept to the mult function in [28, p.235].

Definition Nat_mult := (funm=> fix fp(n: Nad{struct nì : Nat:match n return Nat with

| Nat_s nPre => (Nat_add (fp nPre) m) end

FUNDAMENTALS: NATURALS: EFFICIENT: MAIN

Poohbist.NummSquared.Fundamentals Naturals.Efficient.Main

Poohbist.NummSquared.Fundamentals Naturals Efficient.Main defines efficient natural numbers, and some operators on efficient natural numbers.

Require Import Poohbist NummSquared.Fundamentals.Booleans.Main.

FUNDAMENTAIS:UNITS:MAIN

Parameter Nat_Eff_eq: (Boo_Pred_Bin.Conn Nat_Eff).

Poohbist.NummSquared.Fundamentals Units.Main

Poohbist.NummSquared.Fundamentals Units.Main defines units, and some operators on units.

Require Import Poohbist NummSquared Fundamentals Booleans Main.

There is exactly one unit: the unit element.

Uniis defined in the same way as unit in Coq Init Datatypes, except that Uni: Type whereas unit:Set.

Inductive Uni: Type :| Uni_elem: Uni.

(Uni_eq u0 ul) is the true Boolean if ¿0 and 1 are structurally equal; and the false Boolean otherwise Of course, (Uni_eq u0 1) is always the true Boolean.

Definition Uni_eq:= ( fun u0 ul > Boo_t) : (Boo_Pred_Bin.Conn Uni).

Poohbist.NummSquared.Fundamentals.Optionals.Main

Poohbist NummSquared Fundamentals Optionals.Main defines optionals, and some operators on optionals.

Require Import Poohbist NummSquared Fundamentals Operators.Main.

An optional Ais exactly one of the following: se the none optional A ¢ for some a: A, the one optional A containing a

Optional is defined in the same way as option in Coq Init Datatypes, except that Op- tional: Type whereas option: Set.

Inductive Optional(A: Type) : Type :| Optional_none : (Optional A)

(Optional_rel A0 A1 rel01 o0 o1) is the true Boolean if 00 and o1 have the same shape, and their corresponding elements a0: A0, 41: A1 satisfy (rel01 a0 a1); and the false Boolean otherwise.

Definition Optional_rel_Ty : (Vv

(rel01: (Boo_Pred_ Bin AO A1)), (Boo_ Pred_ Bin (Optional AO) (Optional A1)) ): Type.

Definition OptionaL rel := ( fun AO A1 rel01 o0 o1 > match o0, o1 return Boo with

| Optional_none, Optional_none => Boo_t

| Optional_one a0, Optional_one al => (rel01 a0 al)

(Optional_rel_conn A relA 00 01) is (Optional_rel AA relA o0 o1).

Definition Optional_rel_conn_Ty :(v

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Boo_Pred_Bin_Conn (Optional A)) ): Type.

Definition Optional_rel_conn :(fun A relA 00 o1 > (Optional_rel AA relA 00 01) )

(Optional_nonEmpty A o) is the false Boolean if ois the none optional 4; and the true Boolean otherwise.

Definition Optional_nonEmpty_Ty :( V(A: Type), (Boo_Pred (Optional A)) ) : Type.

Definition Optional_nonEmpty := ( fun Ao=> match o return Boo with

(Optional_empty A o) is (Boo_not (Optional_nonEmpty A o)).

Definition Optional_empty.Ty :{V(A: Type), (Boo_Pred (Optional A)) ) : Type.

(Optional_Op_one A B opA) is the operator from A to an optional B mapping a: A onto the one optional B containing (opA a).

Definition Optional_Op_one_ Tỳ : (Vv

(A: Type) (B: Type) (apA: (Op A B)), (Op A (Optional B)) ): Type.

( fun A B opA a= (Optional_one B (opA a)) ) : Optional_Op_one_Ty.

(Optional_select A B selectA o) is the empty optional Bif ois the empty optional A;and (selectA a) if ois the one optional A containing a.

Definition Optional_select_Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A (Optional B))), (Op (Optional A) (Optional B)) ): Type.

Definition Optional_select := ( fun AB selectA o> match o return (Optional B) with

(Optional_select_toElem A B selectA o) is (Optional_select A B (Optional_Op_one A B selectA) 0).

Definition Optional_select_toElem_Ty :(Vv

(A: Type) (B: Type) (selectA: (Op A B)), (Op (Optional A) (Optional B)) ): Type.

Definition Optional select toElem := ( fun A B selectA o =>

(Optional_select A B (Optional_Op_one AB selectA) o)

Poohbist.NummSquared Fundamentals Booleans.AndOptionals

Poohbist NummSquared Fundamentals Booleans.AndOptionals defines some operators relating Booleans and optionals.

Require Import Poohbist.NummSquared.Fundamentals.Booleans.Main.

Require Import Poohbist.NummSquared.Fundamentals Units.Main.

Require Import Poohbist NummSquared Fundamentals Optionals.Main.

(Boo_to_ Optional A b a) is the one optional A containing aif ?; and the none optional A otherwise.

Definition Boo_to_Optional_Ty :(Vv

(A: Type), (Op-_Bin Boo A (Optional A)) ): Type.

Definition Boo_to_ Optional := (fun A ba=> if b return (Optional A) then (Optional_one A a) else (Optional_none A)

(Bool_Op-_ Optional A predA) is the operator from A to an optional A mapping a: A onto (Boo_to Optional A (predA a) a).

Definition Boo_Op_ Optional_ Ty :(v

(A: Type) (predA : (Boo_ Pred A)), (Op A (Optional A)) ): Type.

Definition Boo_Op_Optional :( fun A predA a > (Boo_to_Optional A (predA a) a) )

Poohbist.NummSquared Fundamentals Choices.Main

Poohbist NummSquared Fundamentals Choices Main defines choices, and some operators on choices.

Require Import Poohbist.NummSquared Fundamentals Booleans Main.

Require Import Poohbist.NummSquared Fundamentals Units.Main.

Require Import Poohbist.NummSquared Fundamentals Optionals.Main.

A choice F, Sis exactly one of the following: ¢ for f : F, the first choice F, S containing ƒ e for s: S, the second choice F, S containing s

Choice is defined in the same way as sưmn in Coq Init Datatypes, except that

Choice Type whereas sum: Set.

Inductive Choice(F : Type)(S: Type) : Type :| Choice_first : (Op F (Choice F S))

In Boolean logic, the expression (Choice_rel F0 S0 F1 S1 relF01 relS01 c0 cl) evaluates to true if the shapes of c0 and c1 are identical, and their respective elements f0: F0 and f1: F1 meet the condition (relFO1 fO fl), or if s0: S0 and s1: SI fulfill the requirement (relS01 s0 s1) If these conditions are not met, the expression evaluates to false.

Definition Choice_rel_Ty :(Vv

(FO: Type) (SO: Type) (F1: Type) (S1: Type) (relF01 : (Boo_Pred_Bin F0 F1)) (relSQ1 : (Boo_Pred_Bin S0 S1)), (Boo_ Pred_ Bim (Choice F0 S0) (Choice F1 S1)) ): Type.

Definition Choice_ rel := ( fun FO S0 F1 S1 relF01 relS01 c0 c1 > match c0, cl return Boo with

| Choice_first ƒ0, Choice_first fl > (relF01 fo f1)

| Choice_second s0, Choice_second s1 => (relS01 s0 s1)

(Choice_rel.conn F S relF relS c0 c1) is (Choice_rel F S F S relF relS c0 cl).

Definition Choice_rel_conn_Ty :(Vv

(F: Type) (S: Type) (relF : (Boo_Pred_Bin_Conn F)) (relS : (Boo_Pred_Bin_Conn S)), (Boo_Pred_Bin_Conn (Choice F ®)) ): Type.

Definition Choice_rel_conn :( fun F S relF relS c0 cl => (Choice_rel F S F S relF relS c0 c1) )

(Choice_to_Optional A c) is the one optional A containing aif c is the first choice A, unit containing ứ and the none optional A otherwise.

Definition Choice_to_Optional_Ty : (Vv

(A: Type), (Op (Choice A Uni) (Optional A)) ): Type.

Definition Choice_to_Optional := (fun Ac=> match c return (Optional A) with

| Choice_second elem => (Optional_none A) end

(Choice_merge A c) is awhere c is the first or second choice A, A containing a.

Definition Choice_merge_Ty :(V(A: Type), (Op (Choice A A) A) ) : Type.

Definition Choice_merge := ( fun Ac=> match c returri A with

Poohbist.NummSquared.Fundamentals.Pairs.Main

Poohbist.NummSquared Fundamentals Pairs Main defines pairs, triples, quadruples, and some operators on pairs, triples and quadruples.

Require Import Poohbist NummSquared.Fundamentals Operators Main.

A pair L, Rnamed p contains all of the following: ¢ the left of p, which is an L ¢ the right of p, whichis an R

Record Pair(L: Type)(R: Type) : Type := Pair_ctor {

(Pair_rel LO R0 L1 R1 relL01 relR01 p0 p1) is the true Boolean if (relL01 (Pair_left L0

RO p0) (Pair_left L1 R1 p1)) and (relRO1 (Pair right LO RO p0) (Pair_right L1 R1 p1)); and the false Boolean otherwise.

Definition Pair_rel_ Ty :(Vv

(LO: Type) (RO: Type) (L1: Type) (R1: Type) (relL01 : (Boo_Pred_Bin L0 L1)) (relRO1 : (Boo_Pred_Bin RO R1)), (Boo_Pred_Bin (Pair LO RO) (Pair L1 RN)

Definition Pair_rel := ( fun LO RO L1 R1 relL01 relRO1 p0 p1> if (relL01 (Pair_left LO RO p0) (Pair_left L1 R1 p1)) return Boo then (relROI (Pair_right LO RO p0) (Pair_right L1 R1 p])) else Boo_f

(Pair_rel_conn L R reÌL relR p0 pl) is (Pair_rel LRLR reÌL relR p0 pl).

Definition Pair_rel_conn_Ty:(Vv

(L: Type) (R: Type) (relL : (Boo_Pred_Bin_Conn L)) (relR : (Boo_Pred_Bin_Conn R)), (Boo_Pred_Bin.Conn (Pair L R))

Definition Pair_rel_conn :( fun L R relL relR p0 p1 => (Pair_rel LRLR relL relR p0 p1) )

A triple L0, L1, R1 is a (Pair L0 (Pair L1 RD).

Definition Trip_Ty := ( V(L0: Type)(L1 : Type) (R1 : Type), Type) : Type.

Definition Trip := ( fun LO L1 R1 > (Pair LO (Pair L1 R1) ) : Trip_ TY.

(Trip_leftO L0 L1 R1 t) is the left of t.

Definition Trip_leftO_Ty : (Vv

(LO: Type) (L1: Type) (R1: Type), (Op (Trip L0 L1 R1) L0 ): Type.

Definition Trip_left0 :(fun L0 L1 R1 t => (Pair_left L0 (Pair L1 R1) 0 ) : Trip_left0_Ty.

(Trip_rightO LO L1 R1 0) is the right of t.

(L0: Type) (L1: Type) (R1: Type), (Op (Trip LO L1 RI) (Pair L1 R1)) ): Type.

Definition Trip_right0 :( fun LO L1 R1 t > (Pair right LO (Pair L1 R1) 0): Trip_right0_Ty.

(Trip_left1 L0 L1 R1 t) is the right-left of t.

Definition Trip_leftl :( fun LO L1 R1 t => (Pair_left L1 R1 (Trip_rightO L0 L1 R10))

(Trip_right1 LO LI R1 £) is the right-right of t.

Definition Trip_right1_Ty :(Vv

(LO: Type) (L1: Type) (R1: Type), (Op (Trip L0 L1 R1) RD ): Type.

Definition Tríp_ right1 :( fun L0 L1 R1 t => (Pair_right L1 R1 (Trip_right0 L0 L1 R1 Ð) )

(Quad_left0 L0 L1 L2 R2 t) is the left of q.

Definition Quad left0_Ty :(Vv

(LO: Type) (L1: Type) (L2: Type) (R2: Type), (Op (Quad L0 L1 L2 R2) L0) ): Type.

Definition Quad_left0 :( fun L0 L1 L2 R2 q => (Pair_left L0 (Trip L1 L2 R2) q))

(Quad_rightO LO L1 L2 R2 t) is the right of q.

Definition Quad_right0_Ty :(Vv

(LO: Type)(L1: Type)(L2: Type)(R2: Type),

(Op (Quad LO L1 L2 R2) (Trip L1 L2 R2) ): Type.

Definition Quad_right0 :( fun L0 L1 L2 R2 q => (Pair_right LO (Trip L1 L2 R2) q) )

(Quad_left1 L0 L1 L2 R2 0) is the right-left of

Definition Quad_left1_Ty :(Vv

(Trip_leƒt0 L1 L2 R2 (Quad_ right0 LO L1 L2 R2 q))

(Quad_left2 LO L1 L2 R2 0) is the right-right-left of q.

(LO: Type) (L1: Type) (L2: Type) (R2: Type), (Op (Quad LO L1 L2 R2) L2) ): Type.

(Trip_leftI L1 L2 R2 (Quad_right0 LO L1 L2 R2 q))

(Quad_right2 L0 L1 L2 R2 t) is the right-right-right of q.

(LO: Type) (L1: Type) (L2: Type) (R2: Type), (Op (Quad LO L1 L2 R2) R2) ): Type.

(Trip_right1 L1 L2 R2 (Quad_right0 LO L1 L2 R2 q))

Poohbist.NummSquared.Fundamentals.Lists.Main

Poohbist.NummSquared Fundamentals Lists.Main defines lists, non-empty lists, and some operators on lists and non-empty lists.

Require Import Poohbist.NummSquared.Fundamentals.Operators.Main.

Require Import Poohbist.NummSquared.Fundamentals.Naturals.Main.

Require Import Poohbist NummSquared Fundamentals Optionals Main.

A list Ais exactly one of the following: ôâ the nil list A s for some head: Aand rest: (Lis A), the cons list A of head and rest

Lis is defined in the same way as list in Coq Lists List, except that Lis: Type whereas list:Set.

Inductive Lis(A: Type) : Type :| Lis_nil: (Lis A)

| Lis_cons : (Op_Bin A (Lis A) (Lis A)).

A,a0, , alis the list A containing the elements a2, , a1 a0, 41 must contain at least one element.

A, a0, , 41 is defined in the same way as the list notation in [8, section 11.1.1), except that A, a0, , al explicitly includes A.

Notation "[A,a0, ,al]":(Lis_cons A a0 (Lis_cons A al (Lis_nil A)) ) : LiS_ sc0pe.

(Lis_rel AO A1 rel01 10 11) is the true Boolean if 10 and 11 have the same shape, and their corresponding elements 20: AO, al : Al satisfy (rel01 a0 a1); and the false Boolean otherwise.

Definition Lis_rel_Ty :(Vv

(A0: Type) (A1: Type) (rel01 : (Boo_Pred_Bin AO Al), (Boo_Pred_Bin (Lis AO) (Lis A1)) ): Type.

Definition Lis_rel := ( fun A0 Al rel01 > fix fo(l0: (Lis AO))(11 : (Lis Al)){struct 10} : Boo :match 10, L1 return Boo with

| Lis_nil, Lis_nil > Boo_t

| Lis_cons l0Head l0Rest, Lis_cons L1 Head L1Rest > if (rel01 l0Head 11Head) return Boo then (fp I0Rest 11 Rest) else Boo_f

(Lis_rel_conn A relA 10 11) is (Lis_rel AA relA 10 11).

Definition Lis_rel_conn_Ty : (Vv

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Boo_Pred_Bin_Conn (Lis A)) ): Type.

Definition Lis_rel_conn:(fun A relA 10 ll > (Lis_rel AA relA 10 1D) ) : Lis_rel_conn_Ty.

(Lis_head A è) is the none optional Aif ẽ is the nil list A; and the one optional A containing /Head if lis the cons list A of [Head and IRest.

Definition Lis_head_Ty :(V(A: Type), (Op (Lis A) (Optional A)) ) : Type.

Definition Lis_head := (fun A ẽ => match | return (Optional A) with

| Lis_cons lHead lRest > (Optional_one A lHead) end

(Lis_rest A I) is the none optional list A if ẽ is the nil list 4; and the one optional list A containing /Rest if lis the cons list A of [Head and IRest.

Definition Lis_rest_Ty :( V(A: Type), (Op (Lis A) (Optional (Lis A))) ) : Type.

Definition Lis_ rest := (fun Al=> match | return (Optional (Lis A)) with

| Lis_nil => (Optional_none (Lis A))

| Lis_cons lHead IRest > (Optional_one (Lis A) IRest) end

(Lis_nonEmpty A D is the false Boolean if ? is the nil list 4; and the true Boolean oth-

Definition Lis_nonEmpty_Ty :( V(A: Type), (Boo_Pred (Lis A)) ) : Type.

Definition Lis nonEmpty := ( fun Al> match | return Boo with

| Lis_cons lHead lRest > Boo_t end

(Lis_empty AD is (Boo_ not (Lis_ nonEmpty AD).

Definition Lis_empty-Ty :( V(A: Type), (Boo_ Pred (Lis A)) ) : Type.

Definition Lis_empty := (fun Al=>

(Lis_cat A 10 11) is the list A containing the elements in 70 followed by the elements in H.

Definition Lis_cat_Ty :( V(A: Type), (Op_Bin_Simp (Lis A)) ) : Type.

Definition Lis_ cat := ( fan A => fix pd0: (Lis A))(H1: (Lis A)){struct 10} : (Lis A) :match 10 return (Lis A) with

| Lis_cons l0Head l0Rest => (Lis_cons A lOHead (fp I0Rest 11)) end

(Lis_append A Ì a) is (Lis_cat A I {A, al).

Definition Lis_append_Ty :( V(A: Type), (Op_Bin (Lis A) A (Lis A)) ) : Type.

Definition Lis_ append :(fun Al a= (Lis_cat Al{A, a]) ) : Lis_append_ Ty.

(Lis_ Op_singleton A B opA) is the operator from A to a list B mapping a: A onto [B, (opA a)].

Definition Lis Op_singleton_Ty :(Vv

(A: Type) (B: Type) (opA : (Op A B)), (Op A (Lis B)) ): Type.

Definition Lis Op_singleton :(fun A B opA a= [B, (opA a)} ) : Lis_Op_singleton- Ty.

9.12.13 THE LIST SINGLETON BINARY OPERATOR

(Lis_Op_singleton_bin A0 A1 B opA) is the binary operator from A0, A1 to a list B mapping a0: A0, al: Al onto [B, (opA a0 al)).

Definition Lis_Op_singleton_bin-_ Ty :(v

(A0: Type) (Al: Type) (B: Type) (opA : (Op_ Bin A0 A1 B)), (Op- Bin A0 A1 (Lis B)) ): Type.

Definition Lis_Op_ singleton_bỉm :( fun A0 Al B opA a0 al = [B, (opA a0 a1)] ) : Lis Op_singleton_bin_Ty.

(Lis Op_prefix A B opA prefix) is the operator from A to a list B mapping a: A onto

Definition Lis_Op_prefix_ Ty :(Vv

(A: Type) (B: Type) (opA : (Op A (Lis B))) (prefix: (Lis B)), (Op A (Lis B)) ): Type.

Definition Lis_Op_ prefix := ( fun A B opA prefix a=>

(Lis_Op_suffix A B opA suffix) is the operator from A to a list B mapping a: A onto (Lis_cat B(opA a) suffix).

Definition Lis_Op_suffix_Ty : (Vv

(A: Type) (B: Type) (opA: (Op A (Lis B))) (suffix : (Lis B)), (Op A (Lis B)) ): Type.

Definition Lis_Op_suffix := (fun A B opA suffix a>

(Lis_generate A genA m) is the list A whose elements are obtained by conatenating the following lists A: (genA Nat_z), , (gerA mì).

(A: Type) (genA : (Op Nat (Lis A))), (Op Nat (Lis A))

Definition Lis_ generate := (fun A gerLA => fix ƒp(m: Nat){struct m} : (Lis A) :match m return (Lis A) with

| Nat_s mPre => (Lis_cat A (fp mPre) (genA m)) end

(Lis_generate_toElem A genA mm) is (Lis_ generate A (Lis Op_singleton Nat A genA) m). Definition Lis_generate_toElem_Ty :(V

(A: Type) (genA : (Op Nat A)), (Op Nat (Lis A)) ): Type.

Definition Lis_generate_toElem := ( fun A genAm=>

(Lis_ generate A (Lis_Op_singleton Nat A genA) mì)

A non-empty list Anamed | contains all of the following: ¢ the head of J, which is an A e the rest of j which is a list A

Record Lis_Ne(A: Type) : Type:= Lis_Ne ctor {

9.12.19 NON-EMPTY LIST RELATED TO

(List_Ne_rel A0 A1 rel01 10 I1) is the true Boolean if (rel01 (Lis_Ne_head A0 10)

(Lis_Ne_head A1 1])) and (Lis_rel A0 A1 rel01 (Lis_Ne_rest A0 10) (Lis_Ne_rest A1 1])); and the false Boolean otherwise.

Definition Lis_Ne_rel_ Ty :(Vv

(AO: Type) (A1: Type) (rel01 : (Boo_Pred_Bin AO Al), (Boo_Pred_Bin (Lis_Ne AO) (Lis_Ne AD) ): Type.

Definition Lis Ne_rel:= ( fun A0 Al rel01 10 L1 > if (rel01 (Lis Ne_head A0 10) (Lis_Ne_head A1 I1)) return Boo then

(Lis_rel AO A1 rel01 (Lis_Ne_rest A0 10) (Lis_Ne_rest A1 11)) else Boo_f

9.12.20 NON-EMPTY LIST RELATED TO, CONNECTIVE

(List Ne_rel_conn A relA 10 I1) is (Lis Ne_rel AA relA 1011).

Definition Lis Ne_ re] conn_ Ty :(V

(A: Type)(relA : (Boo_Pred_Bin_Conn A)),

(Boo_ Pred_ Bin_ Conn (Lis_Ne A)) ): Type.

Definition Lis_Ne_rel_conn :(fun A relA 10 11 = (Lis_Ne_rel AA relA 1011) )

: Lis_Ne_rel_conn_Ty.

(List_Ne_singleton A a) is the non-empty list A containing just a.

Definition Lis_ Ne_singleton_Ty :(V(A: Type), (Op A (Lis_ Ne A)) ) : Type.

Definition Lis Ne_singleton := ( fun A a>

(Lis_Ne_ctor A a (Lis_nil A))

9.12.22 NON-EMPTY LIST TO LIST

(List_Ne_to_Lis A l) is the list A containing the same elements as /.

Definition Lis_Ne_to_Lis_Ty :( V(A: Type), (Op (Lis_Ne A) (Lis A)) ) : Type.

Definition Lis_Ne_to_Lis := ( fan Al=>

(Lis_cons A (Lis_Ne_head A Ù (Lis_Ne_rest AD)

) : Lis_Ne to_Lis_ Tỳ.

9.12.23 THE NON-EMPTY LIST HEAD OPERATOR

(Lis_ Ne_Op_ head A B opA) is the operator from a non-empty list A to B mapping ẽ: (Lis_Ne A) onto (opA (Lis_Ne_head A D).

Definition Lis_Ne_Op_head_Ty :(Vv

(A: Type)(B: Type)(apA: (Op A Bì),

Definition Lis_Ne_Op_head :( fun A B opA Ì > (opA (Lis_Ne_head A Ù) ) : Lis Ne_Op_head TY.

9.12.24 LIST TO NON-EMPTY LIST

The function Lis_to_Lis_Ne A I defines a non-empty list A as mandatory when J is an empty list Alternatively, it creates an optional non-empty list A that includes the same elements as the original list A if it is not empty.

Definition Lis_to_Lis_Ne_ Ty :( V(A: Type), (Op (Lis A) (Optional (Lis_Ne A))) ) : Type.

Definition Lis_to_Lis_Ne:=(funAl=> match Ì return (Optional (Lis_Ne A)) with

| Lis_nil => (Optional_none (Lis_Ne A))

(Optional_one (Lis_Ne A) (Lis_Ne_ctor A lHead LRest)) end

): Lis_to_Lis_Ne_Ty.

A 2 plus list Anamed / contains all of the following: e the head of J, which is an A ¢ the rest of j which is anon-empty list A

Record Lis P2(A: Type) : Type := Lis_P2_ctor {

Poohbist.NummSquared Fundamentals Optionals.AndLists

Poohbist.NummSquared.Fundamentals Optionals.AndLists defines some operators relating optionals and lists.

Require Import Poohbist.NummSquared Fundamentals Lists.Main.

(Optional_to_Lis A o) is the nil list A if ois the none optional A; and [A, a] if ois the one optional A containing a.

Definition Optional_to_Lis_ Ty :(V(A: Type), (Op (Optional A) (Lis A)) ) : Type.

Definition Optional_to_Lis := (fun Ao=> match o return (Lis A) with

Poohbist.NummSquared.Fundamentals.Booleans.AndLists

Poohbist.NummSquared Fundamentals Booleans.AndLists defines some operators relating Booleans and lists.

Require Import Poohbist NummSquared Fundamentals Booleans.AndOptionals.

Require Import Poohbist NummSquared Fundamentals Lists.Main.

Require Import Poohbist NummSquared Fundamentals Optionals.AndLists.

(Boo_to_Lis A b a) is (Optional_to_Lis A (Boo_to_ Optional A b a)).

Definition Boo_to_Lis_Ty :(V

(A: Type), (Op_Bin Boo A (Lis A)) ): Type.

Definition Boo_to_Lis:= ( fun A ba(Optional_to_Lis A (Boo_to_Optional A b a))

(Boo_Op-_ Lis A predA) is the operator from Ato an list Amapping 4: A onto

Definition Boo_Op-Lis_ Ty : (Vv

(A: Type) (predA : (Boo_ Pred A)), (Op A (Lis A))

Definition Boo_Op-Lis :( fun A predA a= (Boo_to_Lis A (predA a) a) ) : Boo_Op_ Lis_ T.

Poohbist.NummSquared Fundamentals Naturals.AndLists

Poohbist.NummSquared.Fundamentals Naturals.AndLists defines natural number lists, and some operators on natural number lists.

Require Import Poohbist NummSquared Fundamentals Naturals.Main.

Require lmport Poohbist NummSquared.Fundamentals.Lists.Main.

A natural number list is a list of natural numbers.

Definition Nat_Lis := (Lis Nat) : Type.

(Nat_Lis_eq 10 11) is the true Boolean if J0 and 11 are structurally equal; and the false Boolean otherwise.

Definition Nat Lis_eq := ( fun Ì0 11 >

(Lis_rel_conn Nat Nat_eq 10 11) ) : (Boo_Pred_Bin_Conn Nat_ Lis).

Poohbist.NummSquared Fundamentals Naturals Efficient.AndLists

Poohbist.NummSquared.Fundamentals Naturals Efficient.AndLists defines efficient natural number lists, and some operators on efficient natural number lists.

Require Import Poohbist.NummSquared Fundamentals Booleans.Main.

Require Import Poohbist.NummSquared.Fundamentals Naturals Efficient.Main.

Require Import Poohbist.NummSquared.Fundamentals Lists.Main.

An efficient natural number list is a list of efficient natural numbers.

Definition Nat_Eff Lis := (Lis Nat_Eff) : Type.

9.16.3 EFFICIENT NATURAL NUMBER LIST EQUALS

(Nat_Eff_Lis_eq 10 LD is the true Boolean if /0 and 11 are structurally equal (except using Nat_Eff.eq); and the false Boolean otherwise.

Definition Nat_Eff_Lis_eq:= ( fun loll >

(Lis_rel_conn Nat_Eff Nat_Eff_eq 10 11) ): (Boo_Pred_Bin Conn Nat_Eff_Lis).

Poohbist.NummSquared.Fundamentals.Pairs.AndLists

Poohbist.NummSquared Fundamentals Pairs.AndLists defines some operators relating pairs and lists.

Require Import Poohbist.NummSquared.Fundamentals.Pairs.Main.

Require Import Poohbist NummSquared.Fundamentals Lists.Main.

9.17.2 PAIR OF HEAD AND REST TO NON-EMPTY LIST

(Pair_headRest_to_Lis_Ne A p) is (Lis Ne_ctor A (Pair_left A (Lis A) p) (Pair_right A

Definition Pair_headRest to_Lis Ne_ Ty :( V (A: Type), (Op (Pair A (Lis A)) (Lis_Ne A)) )

Definition Pair_headRest_to_Lis_Ne:=( fun A p>

(Lis_Ne_ctor A (Pair_left A (Lis A) p) (Pair_right A (Lis A) p))

) : Pair_headRest_to_Lis_Ne_Ty.

Poohbist.NummSquared.Fundamentals.Lists.Select

Poohbist NummSquared.Fundamentals Lists.Select defines some selection operators on lists.

Require Import Poohbist NummSquared.Fundamentals Optionals.Main.

Require Import Poohbist NummSquared.Fundamentals.Booleans.AndLists.

The function (Lis_select A B selectSuffix I) generates list B by applying selectSuffix to each non-empty suffix of I, starting with I itself if it is non-empty, and creating a non-empty list A The resulting lists B are then concatenated If the list A is nil, the function returns (Lis_select A).

B selectSuffix 1) is the nil list B.

Lis_select is somewhat similar in concept to the LISP mapcon function (see [27, chapter 12]).

Definition Lis_select_Ty :(Vv

(A: Type) (B: Type) (selectSuffix : (Op (Lis_Ne A) (Lis B))), (Op (Lis A) (Lis B))

Definition Lis_select := ( fun A B selectSuffix > fix fll: (Lis A)){struct I: (Lis B) :match l return (Lis B) with

B (selectSuffix (Lis_Ne_ctor A lHead lRest)) (fp lRest)

(Lis_select_simp A selectSuffix D) is (Lis_select A A selectSuffix I).

Definition Lis_select_simp-_Ty :(Vv

(A: Type) (selectSuffix : (Op (Lis_Ne A) (Lis A))), (Op_Simp (Lis A))

Definition Lis_select_simp := ( fun A selectSuffix l=>

(Lis_select_iter A selectSuffix | m) is (Nat_iter (Lis A) (Lis_select_simp A selectSuffix) | mì).

Definition Lis_select_iter_Ty : (Vv

(A: Type) (selectSuffix : (Op (Lis_ Ne A) (Lis A))), (Op-_Bin (Lis A) Nat (Lis A))

Definition Lis_select_iter := ( fun A selectSuffix 1m =>

(Nat_iter (Lis A) (Lis_select_simp A selectSuffix) l mì)

(Lis_select_toElem A B selectSuffix 1) is (Lis_select A B (Lis_Op_singleton (Lis_Ne A) B selectSuffix) ).

Lis_select_toElem is somewhat similar in concept to the LISP maplist function (see

Definition Lis_select_toElem_Ty :(Vv

(A: Type) (B: Type) (selectSuffix : (Op (Lis_Ne A) B)), (Op (Lis A) (Lis B))

Definition Lis_select_toElem := ( fun A B selectSuffix Ì =>

(Lis_select A B (Lis_Op_singleton (Lis_Ne A) B selectSuffix) D

9.18.6 LIST SELECT, TO ELEMENT, SIMPLE

(Lis_select_toElem_simp A selectSuffix I) is (Lis_select_toElem A A selectSuffix Ù.

Definition Lis_select_toElem_simp_Ty :(Vv

(A: Type) (selectSuffix : (Op (Lis_ Ne A) A)), (Op_Simp (Lis A))

Definition Lis_select_toElem_simp := ( fun A selectSuffix Ì >

(Lis_select_toElem AA selectSuffix D

): Lis_select_toElem_simp_Ty.

9.18.7 LIST SELECT, TO ELEMENT, ITERATE

(Lis_select_toElem_iter A selectSuffix Ì m) is (Nat_iter (Lis A) (Lis_select_toElem_simp

Definition Lis_ select toElem iter_Ty : (Vv

(A: Type) (selectSuffix : (Op (Lis_Ne A) A)), (Op- Bin (Lis A) Nat (Lis A)) ): Type.

Definition Lis_select_toElem_iter := ( fun A selectSuffix Ì m =>

(Nat_iter (Lis A) (Lis_select.toElem_simp A selectSuffix) I m)

) : Lis_select_toElem_iter_Ty.

(Lis_select_byElem A B selectA I) is (Lis_select A B (Lis_Ne_Op_head A (Lis B) selectA)

The function (Lis_select_byElem A B selectA I) generates list B by applying the selectA function to each element of list A in the order they appear in list I, and then concatenating the resulting lists If list A is empty (nil), then the output list B will also be empty (nil).

Lis_select_byElem is somewhat similar in concept to the LISP mapcan function (see

Definition Lis_select_byElem_Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A (Lis B))), (Op (Lis A) (Lis B)) ): Type.

Definition Lis_select_byElem := ( fan AB selectA l(Lis_select A B (Lis Ne_Op_ head A (Lis B) selectA) }

9.18.9 LIST SELECT, BY ELEMENT, SIMPLE

(Lis_select_byElem_simpA selectA I) is (Lis_select_byElem AA selectA I).

Definition Lis_select_byElem_simp_Ty :(VY

(A: Type) (selectA : (Op A (Lis A))), (Op_Simp (Lis A)) ): Type.

Definition Lis_select_byElem_simp := ( fun A selectA | =>

) : Lis_select_byElem_simp_Ty.

9.18.10 LIST SELECT, BY ELEMENT, ITERATE

(Lis_select_byElem_iter A selectA I m) is (Nat_iter (Lis A) (Lis_select_byElem_simp A selectA) Ì m).

Definition Lis_select_byElem_iter_Ty :(Vv

(A: Type)(selectA : (Op A (Lis A))),(Op- Bin (Lis A) Nat (Lis A))): Type.

Definition Lis_select_byElem_iter := (fun A selectA ẽ m =>

(Nat_iter (Lis A) (Lis_select_byElem_simp A selectA) | mì)

) : Lis_select_byElem_iter_Ty.

9.18.11 LIST SELECT, BY ELEMENT, INTRODUCED

(Lis_select_byElem_intro A B selectA intro Ì) is (Lis_select_byElem A B (Lis_Op_ prefix A

Definition Lis_select.byElem_intro_Ty :(Vv

(B: Type) (selectA : (Op A (Lis B))) (intro: (Lis B)),

Definition Lis_select_byElem_intro := ( fun AB selectA intro Ì =>

(Lis_select_ byElem A B (Lis_Op-prefix A B selectA intro) I

): Lis_select_byElem_intro_Ty.

9.18.12 LIST SELECT, BY ELEMENT, TERMINATED

(Lis_select_byElem_ter A B selectA ter I) is (Lis_select_byElem A B (Lis_Op_suffix AB selectA ter) I).

Definition Lis_select_byElem_ter_Ty :(V

(A: Type) (B: Type) (selectA : (Op A (Lis B))) (ter: (Lis B)),

Definition Lis_select_byElem_ter := ( fun AB selectA ter |=>

(Lis_select_byElem A B (Lis_Op_suffix A B selectA ter) Ð

): Lis_select_byElem._ ter_ TY.

9.18.13 LIST SELECT, BY ELEMENT, SEPARATED

(Lis select_ byElem_ sep A B selectA sep Ì) is the nil list Bif lis the nil list A; and the list

B obtained by concatenating (selectA lHead) and (Lis_select_byElem_intro A B selectA sep IRest) if lis the cons list A of [Head and IRest.

Definition Lis_select_byElem_sep-Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A (Lis B))) (sep: (Lis B)),

Definition Lis_ select byElem_sep := ( fun AB selectA sep 1=> match | return (Lis B) with

B (selectA lHead) (Lis_select_byElem_intro A B selectA sep lRest) end

): Lis_select byElem-_sep- Tỳ.

9.18.14 LIST SELECT, BY ELEMENT, TO ELEMENT

(Lis_select byElem_toElem A B selectA Ì) is (Lis_select_ byElem A B (Lis.Op_ singleton A

Lis_select byElem_toElem is somewhat similar in concept to the LISP mapcar function (see [27, chapter 12]).

Definition Lis_select_byElem_toElem_Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A B)), (Op (Lis A) (Lis B)) ): Type.

Definition Lis_select_byElem_toElem := ( fun AB selectA | =>

(Lis_select_byElem A B (Lis_Op_singleton A B selectA) I)

): Lis_select_byElem_toElem- Ty.

9.18.15 LIST SELECT, BY ELEMENT, TO ELEMENT, SIMPLE

(Lis_select_byElem_toElem_simp A selectA I) is (Lis_select_byElem_toElem AA selectA D.

Definition Lis_select_byElem_toElem_simp- Ty :( V(A: Type) (selectA : (Op_Simp A)), (Op_Simp (Lis A))

Definition Lis_select_byElem_toElem_simp := ( fun A selectA Ì =>

(Lis_select_byElem_toElem A A selectA })

): Lis_select_byElem_toElem_simp- Ty.

9.18.16 LIST SELECT, BY ELEMENT, TO ELEMENT, ITERATE

(Lis_select_byElem_toElem_iter A selectA | m) is (Nat_iter (Lis A)

(Lis_select_byElem_toElem_simp A selectA) Ì mì.

Definition Lis_select_byElem_toElem_iter_Ty :(Vv

(A: Type) (selectA : (Op_Simp A)), (Op_Bin (Lis A) Nat (Lis A)) ): Type.

Definition Lis_select_byElem_toElem_iter := ( fun A selectA lm=>

(Nat_iter (Lis A) (Lis_select_byElem_toElem_simp A selectA) | mì)

) : Lis_select_byElem_toElem_iter_Ty.

9.18.17 LIST SELECT, BY PREFIX, RECURSIVE

The function Lis_select_byPrefix_recur A B selectPrefix | earlier generates list B by applying selectPrefix to each non-empty prefix of list |, which ends with 1 if list | is non-empty The results are prefixed with earlier and separated by the tail, followed by concatenating the resulting lists If list A is nil, then the output list B will also be nil.

Definition Lis_select_byPrefix_recur_Ty : (Vv

(A: Type) (B: Type) (selectPreftx: (Op_Bin (Lis A) A (Lis B))), (Op_Bin Conn (Lis A) (Lis B))

Definition Lis_select_byPrefix_recur := ( fun A B selectPrefix > fix fot: (Lis A)) (earlier : (Lis A)){struct 9 : (Lis B) :match | return (Lis B) with

B (selectPrefix earlier LHead) (fp lRest (Lis_append A earlier lHead)) end

): Lis_select_byPrefix_recur_Ty.

The function Lis_select_byPrefix A B selectPrefix Ì generates list B by applying selectPrefix to each non-empty prefix of list A, including the prefix that ends with 7, if A is not empty The resulting lists from this operation are then concatenated If list A is empty, the output will be an empty list B.

Definition Lis_select_byPrefix_ Ty :(Vv

(A: Type) (B: Type) (selectPrefix : (Op_Bin (Lis A) A (Lis B))), (Op (Lis A) (Lis B))

Definition Lis_select_byPrefix := ( fun A B selectPrefix ẽ =>

(Lis_select_byPrefix_recur A B selectPrefix | (Lis_nil A))

9.18.19 LIST SELECT, BY PREFIX, SIMPLE

(Lis_select_byPrefix_simp A selectPrefix l) is (Lis_select_byPrefix AA selectPrefix I). Definition Lis_select_byPrefix_simp_Ty :(Vv

(A: Type) (selectPrefix : (Op_Bin (Lis A) A (Lis A))), (Op_Simp (Lis A))

Definition Lis_select_byPrefix_simp := ( fun A selectPrefix Ì =>

(Lis_select_ byPrefix AA selectPrefix ])

) : Lis_select_byPrefix_simp_Ty.

9.18.20 LIST SELECT, BY PREFIX, ITERATE

(Lis_select_byPrefix_iter A selectPrefix | m) is (Nat_iter (Lis A)

(Lis_select_byPrefix.simp A selectPrefix) Ì mì.

Definition Lis_select_byPrefix_iter_Ty : (v

(A: Type) (selectPrefix : (Op_Bin (Lis A) A (Lis A))), (Op- Bí (Lis A) Nat (Lis A))

Definition Lis select_byPrefix_iter := ( fun A selectPrefix Ì m(Nat_iter (Lis A) (Lis_select_byPrefix_simp A selectPrefix) | m)

) : Lis_select_byPrefix_iter_Ty.

9.18.21 LIST SELECT, BY PREFIX, TO ELEMENT

(Lis_select_byPrefix_toElem A B selectPrefix Ù is (Lis_select_byPrefix A B

(Lis_Op_singleton_bin (Lis A) A B selectPrefix) 1).

Definition Lis_select_byPrefix_toElem_Ty :(Vv

(A: Type) (B: Type) (selectPrefix : (Op-_Bin (Lis A) A B)), (Op (Lis A) (Lis B))

Definition Lis_select_byPrefix_toElem := ( fun A B selectPrefix | =>

A B (Lis_Op_singleton_bin (Lis A) A B selectPrefix) l

) : Lis_select_byPrefix_toElem_ Ty.

9.18.22 LIST SELECT, BY PREFIX, TO ELEMENT, SIMPLE

(Lis_select_byPrefix_toElem_simp A selectPrefix ]) is (Lis_select_byPrefix_toElem AA selectPrefix Ì).

Definition Lís_select_byPrefix toElem simp TY : (v

(A: Type) (selectPrefix : (Op_Bin (Lis A) A A)), (Op_Simp (Lis A))

Definition Lis_select_byPrefix_toElem_simp := ( fun A selectPrefix Ì =>

(Lis_select_byPrefix_toElem A A selectPrefix 1)

) : Lis_select_byPrefix_toElem_simp_Ty.

9.18.23 LIST SELECT, BY PREFIX, TO ELEMENT, ITERATE

(Lis_select_byPrefix_toElem_iter A selectPrefix | mì) is (Nat_iter (Lis A)

(Lis_select_byPrefix_toElem_simp A selectPrefix) | mì).

Definition Lis_select_byPrefix_toElem_iter_Ty : (Vv

(A: Type) (selectPrefix : (Op_Bin (Lis A) A A)), (Op_Bin (Lis A) Nat (Lis A))

Definition Lis_select_byPrefix_toElem_iter := ( fun A selectPrefix Ì m (Nat_iter

(Lis A) (Lis_select_byPrefix_toElem_simp A selectPrefix) l m

) : Lis_select_byPrefix_toElem_iter_Ty.

(Lis_search A matA Ì) is (Lis_select_byElem_simp A (Boo_ Op_ Lis A matA) ]).

(Lis_search A mata Ì) is I, less those a: A that do not satisfy (mat a).

Definition Lis_search_Ty : (Vv

(A: Type) (matA : (Boo_Pred A)), (Op_Simp (Lis A)) ): Type.

Definition Lis_search := (fun A mata Ì =>

(Lis_select_byElem_simp A (Boo_Op_Lis A matA) Ì)

(Lis_search_first A mata I) is (Lis_ head A (Lis_search A matA Ì)).

Definition Lis_search_first_Ty :(V

(A: Type) (matA : (Boo_Pred A)), (Op (Lis A) (Optional A)) ): Type.

Definition Lis_search_first := (fun A mataAl=>

(Lis_head A (Lis_search A mat Ì))

(Lis_search_isFound A mata Ì) is (Lis.nonEmpty A (Lis_search A matA D).

(Lis_search_isFound A mata I) is the true Boolean if there is some 4: Ain / such that (mata a); and the false Boolean otherwise.

Definition Lis_search_isFound_Ty :(Vv

(A: Type) (mata : (Boo_ Pred A)), (Boo_ Pred (Lis A)) ): Type.

Definition Lis_search_isFound := ( fun A matAl=>

(Lis.nonEmpty A (Lis_search A matA Ì))

(Lis_intersect.mat A0 A1 rel01 11) is the Boolean predicate on AO mapping a0: A0 onto (Lis_search_isFound Al (rel01 a0) 1D).

The Boolean predicate (Lis_intersect_mat AO Al rel01 L1) evaluates whether a given element a0 from set A0 is true if there exists an element a1 from set Al in set 11 such that the relation rel01 holds between a0 and a1; otherwise, it returns false.

Definition Lis_intersect_mat_Ty :(V

(AO: Type) (AI: Type) (rel01: (Boo_Pred_Bin A0 A1)) (11: (Lis AD),

Definition Lis_intersect_mat := ( fun A0 Al rel01 l1 a0 >

(Lis_intersect AO Al relO1 10 11) is (Lis_ search AO (Lis_intersect_ mat AO Al rel01 11) 10).

(Lis_intersect AO A1 rel01 10 11) is 10, less those a0: A0 for which there is no 21: Alin L1 such that (rel01 a0 al).

Definition Lis_intersect_ Ty :(Vv

(A0: Type)(Al : Type)(rel01 : (Boo_ Pred_ Bin A0 Al)),(Op-_ Bin (Lis AO) (Lis Al) (Lis A0))

Definition Lis intersect := (fun A0 Al rel01 l0 11 >

(Lis_search AO (Lis_intersect mat A0 A1 rel01 1) 10)

(Lis_intersect_conn A relA I0 11) is (Lis_intersect AA relA 10 ID.

Definition Lis_intersect_conn_Ty :(Vv

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Op_Bin_Simp (Lis A))

Definition Lis_intersect_conn:= ( fun A relA I0 ll >

(Lis_intersect_first AO A1 rel01 10 11) is (Lis_ head A0 (Lis_intersect AO A1 rel01 10 11). Definition Lis_intersect_first_Ty :(Vv

(A0: Type) (Al: Type) (rel01 : (Boo Pred_Bin A0 Al)), (Op_Bin (Lis AO) (Lis A1) (Optional A0)) ): Type.

Definition Lis_intersect_first := (fun A0 A1 rel01 10 l1 >

(Lis_head AO (Lis_intersect A0 Al rel01 10 11)

(Lis_intersect_first.conn A relA 10 11) is (Lis_intersect_first A A relA 10 11).

Definition Lis_intersect_first_conn_Ty :(Vv

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Op_Bin_Conn (Lis A) (Optional A)) ): Type.

Definition Lis_intersect_first_conn := ( fun A relA 10 l1 >

): Lis_intersect_first_conn_Ty.

(Lis_intersect_nonEmpty A0 A1 rel01 10 11) is (Lis_nonEmpty A0 (Lis_intersect A0 Al rel01 10 11)).

Definition Lis_intersect_nonEmpty_Ty :(Vv

(AO: Type) (A1: Type) (rel01 : (Boo_Pred_Bin A0 A1)), (Boo_Pred_Bin (Lis A0) (Lis A1)) ): Type.

Definition Lis_intersect_nonEmpty := ( fun A0 Al rel01 10 l1 =>

(Lis_nonEmpty A0 (Lis_intersect AO Al rel01 10 11)

9.18.33 LIST INTERSECTION, NON-EMPTY, CONNECTIVE

(Lis_intersect_nonEmpty-_conn A relA 10 11) is (Lis_intersect.nonEmpty AA relA 10 11). Definition Lis_intersect_nonEmpty_conn_Ty :(Vv

(A: Type)(relA : (Boo_Pred_Bin_Conn A)),(Boo_Pred_Bin_Conn (Lis A))): Type.

Definition Lis_intersect.nonEmpty_conn:= ( fun A relA 10 l1 >

(Lis_intersect.nonEmpty AA relA 10 11)

): Lis_intersect_nonEmpty_conn_Ty.

(Lis_ to_Boo_ Pred A I) is the Boolean predicate on (Boo Pred A) mapping mata: (Boo_ Pred A) onto (Lis_search_isFound A matA I.

Definition Lis_to_Boo_Pred_Ty :(Vv

(A: Type), (Op (Lis A) (Boo_ Pred (Boo_Pred A))) ): Type.

Definition Lis_to_Boo_Pred:(fun Al matA => (Lis_search_isFound A mat ] ): Lis_to_Boo_Pred_Ty.

9.19 FUNDAMENTALS: OPTIONALS: AND LISTS SELECT

Poohbist NummSquared Fundamentals Optionals.AndaListsSelect

Poohbist NummSquared Fundamentals Optionals.AnaListsSelect defines some operators relating optionals and list selection operators.

Require Import Poohbist NummSquared.Fundamentals.Operators.Main.

Require Import Poohbist NummSquared.Fundamentals Optionals Main.

Require Import Poohbist.NummSquared Fundamentals Optionals.AndLists.

Require Import Poohbist NummSquared Fundamentals Lists.Select.

(Optional_flattenLis A I) is (Lis_select_ byElem (Optional A) A (Optional_to_Lis A) ID.

Definition Optional_flattenLis_Ty :(Vv

(A: Type), (Op (Lis (Optional A)) (Lis A)) ): Type.

(Lis_select_byElem (Optional A) A (Optional_to-Lis A) })

Poohbist.NummSquared Fundamentals Listfunctions.Main

Poohbist.NummSquared Fundamentals Listfunctions Main defines listfunctions, simple listfunctions, and some operators on listfunctions and simple listfunctions.

Require Import Poohbist.NummSquared Fundamentals Naturals.Main.

Require Import Poohbist NummSquared Fundamentals Lists Select.

A listfunction from A to Bis an operator from A to a list B.

Definition Lisfunction_Ty := ( V(A : Type)(B: Type), Type) : Type.

Definition Lisfunction := ( fun A B > (Op A (Lis B)) ) : Lisfunction_Ty.

(Lisfunction_to.Boo-_ Pred A B If a) is (Lis_to_Boo_ Pred B (If a)).

Definition Lisfunction_to_Boo_Pred_Ty :(Vv

(A: Type) (B: Type), (Op_Bin (Lisfunction A B) A (Boo_ Pred (Boo_ Pred B))) ): Type.

Definition Lisfunction_to_Boo_Pred :( fun A B If a= (Lis_to_Boo_Pred B (If a)))

: Lisfunction_to_Boo_Pred_Ty.

A simple listfunction on A is a listfunction from A to A.

Definition Lisfunction_Simp_Ty := (W(A: Type), Type) : Type.

Definition Lisfunction_ Simp :( fun A => (Lisfunction A A) ) : Lisfunction_Simp-Ty.

9.20.5 SIMPLE LISTFUNCTION TO BOOLEAN PREDICATE

(LisfuncHon_ Simp_to_Boo_ Pred A If a) is (Lisfunction_to_Boo_Pred A A Iƒ a).

Definition LisfuncHon_Simp to_Boo_ Pred_ Ty :(Vv

(A: Type), (Op_Bin (Lisfunction Simp A) A (Boo_ Pred (Boo_ Pred A))) ): Type.

Definition Lisfunction_Simp_to_Boo_Pred :( fun A If a= (Lisfunction_to_Boo_Pred AA If a) )

: Lisfunction_Simp-_to_Boo_Pred_Ty.

(Lisfunction_Simp-iter A If m) is the simple listfunction on A mapping 4: A onto (Lis_select_byElem_iter A If {A, a| m).

Definition Lisfunction_Simp-_iter_Ty : (v

(A: Type), (Op Bin (Lisfunction_Simp A) Nat (Lisfunction_Simp A)) ): Type.

Definition Lisfunction_Simp-iter := (fun Alf ma=>

(Lis_select_byElem_iter A If [A, a] m)

(Lisfunction_Simp-iter_c2 A If a m) is (Lisfunction_Simp_iter A lf ma).

Definition Lisfunction_Simp_iter_c2_Ty :(V

(A: Type), (Op-_Tri (Lisfunction_Simp A) A Nat (Lis A)) ): Type.

Definition Lisfunction_Simp_iter_c2:(fun Alf am = (Lisfunction_Simp_iter Alf ma) )

(Lisfunction_Simp-_iter_cum A If m) is the simple listfunction on A mapping 4: A onto (Lis_generate A (Lisfunction_Simp_iter_c2 Alf a) m).

Definition Lisfunction_Simp_iter.cum_Ty :(V

(A: Type), (Op_Bin (Lisfunction_Simp A) Nat (Lisfunction_Simp A)) ): Type.

Definition Lisfunction_Simp_iter_cum:= ( funAlf ma>

(Lis_ generate A (Lisfunction_Simp-iter_c2 A lf a) m)

) : Lisfunction_Simp-_iter_cum_ Tỳ.

Poohbist.NummSquared NummSquared.Syntax.Abstract.Main defines the Numm- Squared abstract syntax types, and some operators on these types.

Require Import Poohbist NummSquared Fundamentals Naturals Efficient.Main.

Require Import Poohbist NummSquared.Fundamentals Naturals Efficient.AndLists. Require Import Poohbist NummSquared Fundamentals Optionals.Main.

A NummSquared digit character should be interpreted as the similarly named Uni- code code point in the C0 Controls and Basic Latin range See [38, "CO Controls and Basic Latin"].

Inductive Ns_Chr_ Digit : Type :| Ns_Chr_Digit_d0: Ns Chr_ Digit

| Ns_Chr_Digit_dl: Ns_ Chr_ Digit

| Ns_Chr_Digit_d2: Ns_Chr_ Digit

| Ns_Chr_Digit.d3: Ns_Chr_Digit

| Ns_Chr_Digit_d4: Ns_ Chr_ Digit

| Ns_Chr._ Digit d5: Ns Chr_ Digit

| Ns_Chr_ Digit 46: Ns_Chr_ Digit

| Ns_Chr_Digit.d7: Ns_ Chr_ Digit

|Ns_Chr_ Digit d9: Ns_ Chr_ Digit.

(Ns_Chr-_Digit_eq cả0 cdl) is the true Boolean if cđ0 and cd1 are structurally equal; and the false Boolean otherwise.

Definition Ns Chr_ Digit_eq := ( fun cả0 cdl > match cdo, cdl return Boo with

| Ns_Chr_ Digit d0, Ns Chr Digit d0 > Boo_t

|Ns_Chr_ Digit d1, Ns Chr_Digit d1 => Boo_t

|Ns Chr_Digit d2, Ns_Chr_Digit_d2 => Boo_t

| Ms _Chr_Digit d3, Ns.Chr_Digit.d3 > Boo_t

|jNs_Chr_ Digit d4, Ns Chr_Digit.d4 => Boo_t

| Ns_Chr_Digit_d5, Ns Chr_Digit-d5 > Boo_t

| Ns_Chr_Digit.d6, Ns_Chr_Digit d6 > Boo_t

| Ns_Chr_Digit_d7, Ns_Chr_Digit.d7 => Boo_t

| Ns_Chr_Digit_d9, Ns_Chr_Digit_d9 > Boo_t

) : (Boo_Pred_Bin_Conn Ns_Chr_Digit).

A NummSquared identifier start character should be interpreted as the similarly named Unicode code point in the C0 Controls and Basic Latin range See [38, "C0 Con- trols and Basic Latin"].

Inductive Ns_Chr_Ident_Start : Type :| Ns_Chr_Ident_Start_exclamationMark : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_ampersand : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_asterisk : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_plusSign : Ns_ Chr_Ident_Start

| Ns_Chr_Ident_Start_hyphenMinus : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_slash: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_lessThanSign : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_equaisSign : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_greaterThanSign : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_A: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_B: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_C : Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_D: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_E : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_F : Ns Chr_Ident_ Start

| Ns_Chr_Ident_Start_G: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_H : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_I : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_J : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_K : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_L: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_M : Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_N : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_O: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_P ; Ns.Chr_Ident_Start

| Ns Chr_Ident_Start_Q: Ns Chr_Ident_Start

| Ns_Chr_Ident_Start_R: Ns_Chr-_Ident_Start

| Ns Chr_Ident_Start_S: Ns Chr_Ident_Start

| Ns Chr_Ident_Start.T : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start.U : Ns Chr_Ident_Start

| Ns_Chr_Ident_Start_V : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_W : Ns Chr ldent Start

| Ns Chr_Ident_Start_X : Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_Y : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_Z : Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_circumflexAccent : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_a: Ns_ Chr_ldent Start

| Ns.Chr_Ident_Start_b: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start.c: Ns_Chr_Ident_Start

| Ns_Chr_Ident.Start_d: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_e: Ns_Chr ldent Start

| Ns Chr_Ident_Start_f : Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_g: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_h: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_i: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_j: Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_k: Ns Chr_Ident_Start

| Ns_Chr_Ident_Start_l: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start.m: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_n: Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_o: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_p: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_q: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_r: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_s: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_t: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_u: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_v: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_w: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_x : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_y : Ns.Chr_Ident_Start

| Ns Chr_Ident_Start_z: Ns_Chr_Ident_ Start

| Ns_Chr_Ident_Start_verticalBar : Ns_Chr_Ident_Start.

9.21.5 NUMMSQUARED IDENTIFIER START CHARACTER EQUALS

(Ns_Chr_Ident_Start_eq cis0 cis1) is the true Boolean if cisO and cis1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Chr_Ident_Start_eq := ( fun cis0 cis1 => match cis0, cis1 return Boo with

| Ns_Chr_Ident_Start_exclamationMark,

Ns_Chr_Ident_Start_exclamationMark >

| Ns_Chr_Ident_Start_ampersand, Ns_Chr_Ident_Start_ampersand = Boo_t

| Ns_Chr_Ident_Start_asterisk, Ns.Chr_Ident_Start_asterisk => Boo_t

| Ns Chr_Ident_Start_plusSign, Ns_Chr_Ident_Start_plusSign => Boo_t

| Ns_Chr_Ident_Start_hyphenMinus, Ns_Chr_Ident_Start_hyphenMinus >

| Ns_Chr_Ident_Start_slash, Ns.Chr_Ident_Start_slash > Boo_t

| Ns_Chr_Ident_Start_lessThanSign, Ns_Chr_Ident_Start_lessThanSign >

| Ns_Chr_Ident_Start_equalsSign, Ns_Chr_Ident_Start_equalsSign => Boo_t

| Ns_Chr_Ident_Start_greaterThanSign,

Ns_Chr_Ident.Start_greaterThanSign >

| Ns_Chr_Ident_Start_A, Ns_Chr ldent Start A > Boo_t

| Ns_Chr_Ident_Start_B, Ns_Chr_Ident_Start_B => Boo_t

| Ns_Chr_Ident_Start_C, Ns_Chr_Ident_Start_C => Boo_t

| Ns_Chr_Ident_Start_D, Ns_Chr_Ident_Start_D => Boo_t

| Ns_Chr_Ident_Start_E, Ns_Chr_Ident_Start_E > Boo_t

| Ns_Chr_Ident_Start_F, Ns_Chr_Ident_Start_F > Boo_t

| Ns_Chr_Ident_Start_G, Ns_Chr_Ident_Start_G => Boo_t

| Ns_Chr_Ident_Start.H, Ns_Chr_Ident_Start_H => Boo_t

| Ns_Chr_Ident_Start_I, Ns_Chr_Ident_Start_I > Boo_t

| Ns_Chr_Ident_Start_J, Ns.Chr_Ident_Start_] => Boo_t

| Ns_Chr_Ident_Start_K, Ns_Chr_Ident_Start.K => Boo_t

| Ns_Chr_Ident_Start_L, Ns._Chr_Ident_Start_L => Boo_t

| Ns_Chr_Ident_Start_M, Ns_Chr_Ident_Start_M => Boo_t

| Ns_Chr_Ident_Start_N, Ns.Chr_Ident_Start_N => Boo_t

| Ns_Chr_Ident_Start_O, Ns_Chr_Ident_Start.O => Boo_t

| Ns_Chr_Ident_Start_P, Ns_Chr_Ident_Start.P => Boo_t

| Ns_Chr_Ident_Start_Q, Ns_Chr_Ident_Start_Q => Boo_t

| Ns_Chr_Ident_Start_R, Ns Chr_Ident_Start_R => Boo_t

| Ns_Chr_Ident_Start_S, Ns_Chr_Ident_Start_S => Boo_t

| Ns Chr_Ident_Start_T, Ns Chr ldent Start T = Boo_t

| Ns_Chr_Ident_Start_U, Ns_Chr_Ident_Start_U => Boo_t

| Ns_Chr_Ident_Start_V, Ns_Chr_Ident_Start.V => Boo_t

| Ns_Chr_Ident_Start_W, Ns_Chr_Ident_Start.W => Boo_t

| Ns_Chr_Ident_Start_X, Ns_Chr_Ident_Start_X => Boo_t

| Ns_Chr_Ident_Start_Y, Ns_Chr_Ident_Start.Y => Boo_t

| Ns_Chr_Ident_Start_Z, Ns.Chr_Ident_Start.Z = Boo_t

| Ns_Chr_Ident_Start_circumflexAccent,

Ns_Chr_Ident_Start_circumflexAccent >

| Ns_Chr_Ident_Start_a, Ns_Chr_Ident_Start.a => Boo_t

| Ns_Chr_Ident_Start_b, Ns_Chr_Ident_Start_b > Boo_t

| Ns_Chr_Ident_Start_c, Ns_Chr_Ident_Start_c => Boo_t

| Ns_Chr_Ident_Start_d, Ns.Chr_Ident_Start.d => Boo_t

| Ns_Chr_Ident_Start_e, Ns_Chr_Ident_Start_e=> Boo_t

| Ns_Chr_Ident_Start_f, Ns.Chr_Ident_Start_f > Boo_t

| Ns_Chr_Ident_Start_g, Ns_Chr_Ident_Start_g = Boo_t

| Ns_Chr_Ident_Start_h, Ns_Chr_Ident_Start_h > Boo_t

| Ns_Chr_Ident_Start_i, Ns.Chr_Ident_Start_i=> Boo_t

| Ns_Chr_Ident_Start_j, Ns_Chr_Ident_Start_j => Boo_t

| Ns_Chr_Ident_Start_k, Ns_Chr_Ident_Start_k > Boo_t

| Ns_Chr_Ident_Start_l, Ns_Chr_Ident_Start_l1=> Boo_t

| Ns_Chr_Ident_Start_m, Ns_Chr_Ident_Start_m => Boo_t

| Ns_Chr_Ident_Start_n, Ns_Chr_Ident_Start_n => Boo_t

| Ns_Chr_Ident_Start_o, Ns_Chr_Ident_Start_o => Boo_t

| Ns_Chr_Ident_Start_p, Ns_Chr_Ident_Start_p = Boo_t

| Ns_Chr_Ident_Start_q, Ns_Chr_Ident_Start_q => Boo_t

| Ns_Chr_Ident_Start_r, Ns_Chr_Ident_Start_r => Boo_t

| Ns_Chr_Ident_Start_s, Ns_Chr_Ident_Start_s => Boo-_t

| Ns_Chr_Ident_Start_t, Ns_Chr_Ident_Start_t > Boo_t

| Ns_Chr_Ident_Start_u, Ns_Chr_Ident_Start_u=> Boo_t

| Ns_Chr_Ident_Start_v, Ns._Chr_Ident_Start_v => Boo_t

| Ns_Chr_Ident.Start_w, Ns_Chr_Ident_Start_w => Boo-_t

| Ns_Chr_Ident_Start_x, Ns_Chr_Ident_Start_x => Boo_t

| Ns_Chr_Ident_Start_y, Ns_Chr_Ident_Start_y > Boo_t

| Ns_Chr_Ident_Start_z, Ns_Chr_Ident.Start_z => Boo_t

| Ns_Chr_Ident_Start_verticalBar, Ns_Chr_Ident_Start_verticalBar >

): (Boo_Pred_Bin.Conn Ns_ Chr_ldent_Start).

A Numm Squared identifier continue character is exactly one of the following: ¢ a NummSquared identifier start character s® a NummSquared digit character

Note that a NummSquared identifier start character and a NummSquared digit character never have the same Unicode code point.

Inductive Ns_Chr_Ident.Cont : Type :| Ns_Chr_Ident.Cont_ident_start : (Op Ns_Chr_Ident_Start Ns_Chr_Ident_Cont)

| Ns_Chr_Ident_Cont_digit : (Op Ns_Chr_ Digit Ns_Chr_Ident_Cont).

(Ns_Chr_Ident_Cont_eq cic0 cic1) is the true Boolean if cicO and cic1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Chr_Ident_Cont_eq := ( fun cỉc0 cicl > match cic0, cicl return Boo with

| Ns_Chr_Ident_Cont_ident_start cis0,

Ns_Chr_Ident_Cont_ident_start cis1 =>

(Ns_Chr_Ident_Start_eg cis0 cis1)

| Ns_Chr_Ident_Cont_digit cd0, Ns_Chr_Ident_Cont_digit cdl >

(Ns_Chr_Digit.eq cd0 cal)

) : (Boo_Pred_Bin_Conn Ns_Chr_Ident_Cont).

A NummSquared comment is an efficient natural number list.

Recall that natural numbers in the range 0-1114111 are Unicode code points Natu- ral numbers above this range may be interpreted in whatever way you wish.

Definition Ns_Comment := Nat_Eff.Lis: Type.

(Ns Comment_eq comment0 commentl) is (Ns_ Eff Lis.eq comment0 comment). Definition Ns_Comment_eq := ( fun comment0 comment] >

(Nat_Eff_Lis_eq comment0 commentl) ): (Boo_Pred_Bin.Conn Ns_Comment).

A NummSquared simple identifier, referred to as "ids," consists of two main components: the initial character, which signifies the start of the identifier, and a subsequent sequence of characters that form the continuation of the identifier.

Record Ns_Ident_Simp: Type := Ns ldentSimp_ctor {

Ns ldent Simp start: Ns_Chr_Ident_Start,

Ns_Ident_Simp_conts : (Lis Ns_Chr_Ident_Cont)

(Ns_Ident_Simp_eq idsO ids1) is the true Boolean if idsO and ids1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Ident_Simp_eq := ( fun idsO ids1 => if

(Ns_Chr_Ident_Start_eq

(Ns_Ident_Simp-start ids0)(Ns_Ident_Simp_start ids1)

Ns Chr Ident Cont Ns_Chr_Ident_Cont_eq (Ns_Ident_Simp-conts ids0) (Ns_Ident_Simp_conts ids1) ) else Boo_f

) : (Boo_Pred_Bin_Conn Ns_Ident_Simp).

A NummSquared identifier is a non-empty list of NummSquared simple identifiers. Definition Ns_ Ident := (Lis_Ne Ns_Ident_Simp).

(Ns_Ident_eq idO id1) is the true Boolean if id0 and id1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Ident_eq := ( fun ¡d0 idl >

(Lis_Ne_rel_conn Ns_Ident_Simp Ns_Ident_Simp_eq ¡d0 idl) ) : (Boo_Pred_Bin_Conn Ns_Ident).

9.21.14 NUMMSQUARED SIMPLE IDENTIFIER TO NUMMSQUARED

(Ns_Ident_Simp_to_Ns_Ident ids) is the NummSquared identifier containing just ids. Definition Ns_Ident_Simp_to_Ns_Ident := ( fun ids >

(Lis_Ne_singleton Ns_Ident_Simp ids)

): (Op Ns_Ident_Simp Ns_ Ident).

A NummSquared natural number primitive is an efficient natural number.

Definition Ns_Prim_Nat := Nat_Eff : Type.

9.21.16 NUMMSQUARED NATURAL NUMBER PRIMITIVE EQUALS

(Ns Prim_Nat_eq m0 m1) is (Nat_ HÍƒ eq m0 m1).

Definition Ns_ Prim_Nat_eq:= ( fun m0 m1 >

): (Boo_Pred_Bin_Conn Ns_Prim_Nat).

A NummSquared character primitive is an efficient natural number.

Definition Ns_Prim_Chr := Nat_Eff : Type.

(Ns_Prim_Chr_eq m0 m1) is (Nat_Eff_eq m0 m1).

Definition Ns_Prim_Chr_eq:= ( fun m0 m1 >

): (Boo_Pred_Bin_Conn Ns_Prim_Chr).

A NummSquared string primitive is an efficient natural number list.

Definition Ns_Prim_Str := Nat_Eff_Lis: Type.

(Ns_Prim_Str_eq str0 sír1) is (Ns_Eff_Lis_eq stro strI).

Definition Ns_Prim_Str_eq := ( fun str0 str1 =>

(Nat_Eff_Lis_eq str0 str}) ): (Boo_Pred_Bin_Conn Ns_ Prim_ St).

A NummSquared primitive is exactly one of the following: e a NummSquared natural number primitive ¢ a NummSquared character primitive ¢ a NummSquared string primitive

Inductive Ns_ Prim: Type :| Ns_Prim_nat : (Op Ns_Prim_Nat Ns_Prim)

| Ns_Prim_chr : (Op Ns_Prim_Chr Ns_ Prim)

| Ns_Prim_str : (Op Ns_Prim_Str Ns_ Prim).

(Ns_Prim_eq prim0 prim1) is the true Boolean if prim0 and prim] are structurally equal (except using Nat_Eff_eq); and the false Boolean otherwise.

Definition Ns_Prim_eq := ( fun prim0 prim1 > match primo, prim1 return Boo with

| Ns_Prim_nat m0, Ns_Prim_nat m1 => (Ns_Prim_Nat_eq m0 m1

| Ns_Prim_chr m0, Ns_Prim_chr m1 => (Ns_ Prim_Chr_eq m0 mI)

| Ns_Prim_str str0, Ns_Prim_str str1 => (Ns_Prim_Str_eq str0 str])

): (Boo_ Pred_Bim_ Conn Ns_ Prim).

A NummSquared computational normalized constant is exactly one of the following: ¢ the identity NummSquared computational normalized constant ¢ the null NummSquared computational normalized constant

The NummSquared computational normalized constants include various sets: the zero set, one set, null set, nuro set, leaf set, tree set, and domain set Each of these constants plays a crucial role in computational processes and normalization within the NummSquared framework.

* the null predicate NummSquared computational normalized constant ¢ the pair predicate NummSquared computational normalized constant

Inductive Ns_Constant.Norm_Compu: Type :| Ns_ Constant_ Norm_ Compu_¡: Ns.Constant.Norm_Compu

| Ns_Constant_Norm_Compu_null: Ns.Constant_Norm_Compu

| Ns_Constant.Norm_Compu_zero: Ns_Constant_Norm_Compu

| Ns_Constant_Norm_Compu_one : Ns_Constant_Norm_Compu

| Ns_Constant_Norm_Compu_Null_set : Ns Constant Norm_Compu

| Ns_Constant_Norm_Compu_Nuro_set : Ns Constant Norm_Compu

| Ns_Constant Norm_Compu_Leaf_set : Ns.Constant_Norm_Compu

| Ns_Constant_Norm_Compu_Tree_set : Ns_Constant_Norm_.Compu

| Ns_Constant_Norm_Compu_dom: Ns_Constant_Norm_Compu

| Ns_Constant.Norm.Compu_Null: Ns_Constant.Norm_Compu

| Ns_Constant_Norm_Compu_Pair: Ns Constant Norm_Compu.

A NummSquared non-computational normalized constant is exactly one of the following: ¢ the equals NummSquared non-computational normalized constant

Inductive Ns_Constant_Norm_Noncompu: Type :| Ns_Constant_Norm_Noncompu_ns_eq: Ns_-Constant_Norm_Noncompu.

A NummSquared normalized constant is exactly one of the following: ¢ a NummSquared computational normalized constant ¢ a NummSquared non-computational normalized constant

Inductive Ns_Constant_Norm: Type :| Ns_Constant_Norm_compu: (Op Ns_Constant_Norm.Compu Ns_Constant_ Norm)

(Op Ns_Constant_Norm_Noncompu Ns_Constant_Norm).

A NummSquared computational non-normalized constant can be classified into several categories: the left and right NummSquared constants, confirmation and negation with a null constant, and the transition from null to zero It also includes the zero and one predicate constants, the nuro predicate, the leaf predicate, the simple predicate, and the rule predicate constants.

* the tree predicate step pair unguarded NummSquared computational non- normalized constant

The tree predicate NummSquared represents a computational non-normalized constant within a non-empty domain This constant yields various results, including the nuro set and tree set results, both of which are classified as NummSquared computational non-normalized constants Additionally, the dependent sum results, whether left unguarded, right unguarded, or simply unguarded, all fall under the NummSquared computational non-normalized constant category Furthermore, the dependent product result, when uncurry unguarded, is also identified as a NummSquared computational non-normalized constant.

The NummSquared computational non-normalized constant is influenced by several factors, including the dependent product result, its negation, and implications, both with and without null values Understanding these relationships is crucial for analyzing the constant effectively.

Inductive Ns_Constant_Nonnorm_Compu : Type :| Ns_Constant_Nonnorm_Compu_left : Ns_ Constant Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_right : Ns_Constant_Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_conf_n: Ns Constant.Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_not_n: Ns_Constant_Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_Null_to_Zero: Ns_Constant_Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_Zero: Ns_Constant Nonnorm._Compu

| Ns_ Constant_ Nonnorm_Cornpu_ One : Ns.Constant.Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_Nuro: Ns_Constant_Nonnorm_Cornpu

| Ns_Constant_Nonnorm_Compu_Leaf : Ns_Constant.Nonnorm_Compu

|NMs_ Constant_ Nonnorm_Compu_Simp: Ns_Constant_Nonnorm_ Compu

| Ns_Constant_Nonnorm_Compu_Rule: Ns_Constant_Nonnorm_Compu

| Ns_ Constant Nonnorm_Compu-Tree_step_pair_ug :

| Ns_Constant_Nonnorm_Compu-Tree_step_ug : Ns_Constant.Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_Tree: Ns_Constant.Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_dom_ne: Ns_Constant_Nonnorm.Compu

| Ns_Constant_Nonnorm_Compu_res: Ns Constant Nonnorm Compu

| Ns_Constant_Nonnorm_Compu_Nuro_set_res: Ns_Constant_Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu-Tree_set_res : Ns_Constant Nonnorm Compu

| Ns_Constant_Nonnorm_Compu_s_d_res_left_ug : Ns_ Constant Nonnorm_Cornpu

| Ns_Constant_Nonnorm_Compu_s_d_res_right_ug : ẹs_Constant Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_s_d_res_ug: Ns_Constant_Nonnorm.Compu

| Ns_Constant_Nonnorm_Compu_s_d_res: Ns_Constant Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_p-_d_res_uncurry_ug :

| Ns_Constant_Nonnorm_Compu_p_d_res_ug : Ns_Constant.Nonnorm_Compu

| Ns.Constant_Nonnorm.Compu-p-_d_res: Ns_ Constant Nonnorm_Compu

| ẹMs_ Constant_ Nonnorm_Compu_ not: Ns_Constant_Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_imp_n: Ns_Constant_Nonnorm_Compu

| Ns_Constant_Nonnorm_Compu_imp : Ns_Constant_Nonnorm_Compu.

A NummSquared non-computational non-normalized constant can be defined as one of the following: it is not equal to the NummSquared non-computational non-normalized constant; it represents a small universal quantification; it consists of equal pairs that are unguarded; it yields equal results; it signifies equal domain results; it reflects equal outcomes for both sides; and it corresponds to the equals on the right-hand side of the equation.

Inductive Ns_Constant_Nonnorm_Noncompu : Type :| Ns Constant_Nonnorm_Noncompu-not_eq: Ns_Constant Nonnorm_Noncompu

| Ns_Constant_Nonnorm_Noncompu_all_sm: Ns_Constant_Nonnorm_Noncompu

| Ns_Constant_Nonnorm_Noncompu-_eq_pair_ug :

| Ns_Constant_Nonnorm_Noncompu_eq_res_at :

| Ns_Constant_Nonnorm_Noncompu_eq_res: Ns Constant_Nonnorm_Noncompu

| Ns_Constant_Nonnorm_Noncompu_eq_dom_tres:

| Ns_Constant_Nonnorm_Noncompu-_eq_both_res:

| Ns_Constant_Nonnorm_Noncompu-_eq_rhs: Ns_Constant.Nonnorm_Noncompu.

A NummSquared non-normalized constant is exactly one of the following: ¢ a NummSquared computational non-normalized constant ¢ a NummSquared non-computational non-normalized constant

Inductive Ns_Constant_Nonnorm : Type :| Ns.Constant_Nonnorm_compu:

(Op Ns_Constant_Nonnorm_Compu Ns_Constant_Nonnorm)

(Op Ns_Constant_Nonnorm_Noncompu Ns_Constant_Nonnorm).

A NummSquared constant is exactly one of the following: ¢ a NummSquared normalized constant ¢ a NummSquared non-normalized constant

Inductive Ns_Constant : Type :| Ns_Constant_norm : (Op Ns_ Constant Norm Ns_ Constant)

| Ns_Constant_nonnorm: (Op Ns_Constant_Nonnorm Ns_ Constant).

A NummSquared large composition computational combination c contains all of the following: ¢ the outer of c, which is a NummSquared large function

* the inners of c, which is a NummSquared large function non-empty list

A NummSquared small composition computational combination c contains all of the following: ¢ the called and arguments of c, which is a NummSquared large function 2 plus list

A NummSquared tuple computational combination c contains all of the following: se the components of c, which is a NummSquared large function 2 plus list

A NummSquared list computational combination c contains all of the following: e the elements of c, which is a NummSquared large function list

A NummSquared dependent sum computational combination c contains all of the following: ¢ the family of c, which is a NummSquared large function

A NummSquared dependent product computational combination c contains all of the following: ¢ the family of c, which is a NummSquared large function

A NummSquared Curry computational combination c contains all of the following: ¢ the root of c, which is a NummSquared large function ¢ the restrictor of c, which is a NummSquared large function

A NummSquared if-then-else computational combination, denoted as c, encompasses three essential components: the if-part, which is a NummSquared large function; the then-part, also a NummSquared large function; and the else-part, which is likewise a NummSquared large function.

A NummSquared recursion computational combination c contains all of the following: the start of c, which is a NummSquared large function se the step of c, which is a NummSquared large function

A NummSquared restrict computational combination c contains all of the following: ¢ the root of c, which is a NummSquared large function

A NummSquared restrict to range computational combination c contains all of the following:

* the root of c, which is a NummSquared large function

A NummSquared Curry augmented root computational combination c contains all of the following: s the root of c, which is a NummSquared large function

* the augmentor of c, which is a NummSquared large function

A NummSquared Curry augmented computational combination c contains all of the following:

* the root of c, which is a NummSquared large function ¢ the restrictor of c, which is a NummSquared large function ¢ the augmentor of c, which is a NummSquared large function

A NummSquared Curry result computational combination c contains all of the following: ¢ the root of c, which is a NummSquared large function

A NummSquared recursion on domain computational combination c contains all of the following: e the start of c, which is a NummSquared large function ¢ the step of c, which is a NummSquared large function

A NummSquared recursion on range computational combination c contains all of the following: e the start of c, which is a NummSquared large function © the step of c, which is a NummSquared large function

A NummSquared recursion step computational combination c contains all of the following: ¢ the start of c, which is a NummSquared large function ¢ the step of c, which is a NummSquared large function

A NummSquared recursion right-hand-side computational combination c contains all of the following: ® the start of c, which is a NummSquared large function the step of c, which is a NummSquared large function

A NummSquared computational combination can be categorized into several distinct types, including large and small composition combinations, tuple and list combinations, as well as dependent sum and product combinations Additionally, it encompasses various Curry combinations, such as augmented root, augmented, and result combinations Other forms include if-then-else combinations, recursion combinations (on domain, on range, and recursion steps), and restrict combinations (including restrict to range) Each type serves a unique purpose within the NummSquared framework, contributing to its computational versatility.

A NummSquared Hilbert non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

A NummsSquared existential quantification unguarded non-computational combination c contains all of the following:

* the predicate of c, which is a NummSquared large function

A NummSquared existential quantification non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

A NummSquared not universal quantification non-computational combination c contains all of the following: s the predicate of c, which is a NummSquared large function

A NummSquared universal quantification non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

A NummSquared unary universal quantification non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

A NummSquared inductive domain hypothesis non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

A NummSquared inductive range hypothesis non-computational combination c contains all of the following:

A NummSquared inductive case at non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

A NummSquared inductive case non-computational combination c contains all of the following: ¢ the predicate of c, which is a NummSquared large function

FUNDAMENTALS: BOOLEANS: AND OPTIONALS

Poohbist.NummSquared Fundamentals Booleans.AndOptionals

Poohbist NummSquared Fundamentals Booleans.AndOptionals defines some operators relating Booleans and optionals.

Require Import Poohbist.NummSquared.Fundamentals Units.Main.

Require Import Poohbist NummSquared Fundamentals Optionals.Main.

(Boo_to_ Optional A b a) is the one optional A containing aif ?; and the none optional A otherwise.

Definition Boo_to_Optional_Ty :(Vv

(A: Type), (Op-_Bin Boo A (Optional A)) ): Type.

Definition Boo_to_ Optional := (fun A ba=> if b return (Optional A) then (Optional_one A a) else (Optional_none A)

(Bool_Op-_ Optional A predA) is the operator from A to an optional A mapping a: A onto (Boo_to Optional A (predA a) a).

Definition Boo_Op_ Optional_ Ty :(v

(A: Type) (predA : (Boo_ Pred A)), (Op A (Optional A)) ): Type.

Definition Boo_Op_Optional :( fun A predA a > (Boo_to_Optional A (predA a) a) )

FUNDAMENTALS: CHOICES:MAIN

Poohbist.NummSquared Fundamentals Choices.Main

Poohbist NummSquared Fundamentals Choices Main defines choices, and some operators on choices.

Require Import Poohbist.NummSquared Fundamentals Booleans Main.

Require Import Poohbist.NummSquared Fundamentals Units.Main.

Require Import Poohbist.NummSquared Fundamentals Optionals.Main.

A choice F, Sis exactly one of the following: ¢ for f : F, the first choice F, S containing ƒ e for s: S, the second choice F, S containing s

Choice is defined in the same way as sưmn in Coq Init Datatypes, except that

Choice Type whereas sum: Set.

Inductive Choice(F : Type)(S: Type) : Type :| Choice_first : (Op F (Choice F S))

A true Boolean result occurs when c0 and c1 share the same shape, and their corresponding elements f0 and f1 meet the condition of (relFO1 fO fl), or when s0, s1 satisfy (relS01 s0 s1) If these conditions are not met, the result is a false Boolean.

Definition Choice_rel_Ty :(Vv

(FO: Type) (SO: Type) (F1: Type) (S1: Type) (relF01 : (Boo_Pred_Bin F0 F1)) (relSQ1 : (Boo_Pred_Bin S0 S1)), (Boo_ Pred_ Bim (Choice F0 S0) (Choice F1 S1)) ): Type.

Definition Choice_ rel := ( fun FO S0 F1 S1 relF01 relS01 c0 c1 > match c0, cl return Boo with

| Choice_first ƒ0, Choice_first fl > (relF01 fo f1)

| Choice_second s0, Choice_second s1 => (relS01 s0 s1)

(Choice_rel.conn F S relF relS c0 c1) is (Choice_rel F S F S relF relS c0 cl).

Definition Choice_rel_conn_Ty :(Vv

(F: Type) (S: Type) (relF : (Boo_Pred_Bin_Conn F)) (relS : (Boo_Pred_Bin_Conn S)), (Boo_Pred_Bin_Conn (Choice F ®)) ): Type.

Definition Choice_rel_conn :( fun F S relF relS c0 cl => (Choice_rel F S F S relF relS c0 c1) )

(Choice_to_Optional A c) is the one optional A containing aif c is the first choice A, unit containing ứ and the none optional A otherwise.

Definition Choice_to_Optional_Ty : (Vv

(A: Type), (Op (Choice A Uni) (Optional A)) ): Type.

Definition Choice_to_Optional := (fun Ac=> match c return (Optional A) with

| Choice_second elem => (Optional_none A) end

(Choice_merge A c) is awhere c is the first or second choice A, A containing a.

Definition Choice_merge_Ty :(V(A: Type), (Op (Choice A A) A) ) : Type.

Definition Choice_merge := ( fun Ac=> match c returri A with

Poohbist.NummSquared.Fundamentals.Pairs.Main

Poohbist.NummSquared Fundamentals Pairs Main defines pairs, triples, quadruples, and some operators on pairs, triples and quadruples.

Require Import Poohbist NummSquared.Fundamentals Operators Main.

A pair L, Rnamed p contains all of the following: ¢ the left of p, which is an L ¢ the right of p, whichis an R

Record Pair(L: Type)(R: Type) : Type := Pair_ctor {

(Pair_rel LO R0 L1 R1 relL01 relR01 p0 p1) is the true Boolean if (relL01 (Pair_left L0

RO p0) (Pair_left L1 R1 p1)) and (relRO1 (Pair right LO RO p0) (Pair_right L1 R1 p1)); and the false Boolean otherwise.

Definition Pair_rel_ Ty :(Vv

(LO: Type) (RO: Type) (L1: Type) (R1: Type) (relL01 : (Boo_Pred_Bin L0 L1)) (relRO1 : (Boo_Pred_Bin RO R1)), (Boo_Pred_Bin (Pair LO RO) (Pair L1 RN)

Definition Pair_rel := ( fun LO RO L1 R1 relL01 relRO1 p0 p1> if (relL01 (Pair_left LO RO p0) (Pair_left L1 R1 p1)) return Boo then (relROI (Pair_right LO RO p0) (Pair_right L1 R1 p])) else Boo_f

(Pair_rel_conn L R reÌL relR p0 pl) is (Pair_rel LRLR reÌL relR p0 pl).

Definition Pair_rel_conn_Ty:(Vv

(L: Type) (R: Type) (relL : (Boo_Pred_Bin_Conn L)) (relR : (Boo_Pred_Bin_Conn R)), (Boo_Pred_Bin.Conn (Pair L R))

Definition Pair_rel_conn :( fun L R relL relR p0 p1 => (Pair_rel LRLR relL relR p0 p1) )

A triple L0, L1, R1 is a (Pair L0 (Pair L1 RD).

Definition Trip_Ty := ( V(L0: Type)(L1 : Type) (R1 : Type), Type) : Type.

Definition Trip := ( fun LO L1 R1 > (Pair LO (Pair L1 R1) ) : Trip_ TY.

(Trip_leftO L0 L1 R1 t) is the left of t.

Definition Trip_leftO_Ty : (Vv

(LO: Type) (L1: Type) (R1: Type), (Op (Trip L0 L1 R1) L0 ): Type.

Definition Trip_left0 :(fun L0 L1 R1 t => (Pair_left L0 (Pair L1 R1) 0 ) : Trip_left0_Ty.

(Trip_rightO LO L1 R1 0) is the right of t.

(L0: Type) (L1: Type) (R1: Type), (Op (Trip LO L1 RI) (Pair L1 R1)) ): Type.

Definition Trip_right0 :( fun LO L1 R1 t > (Pair right LO (Pair L1 R1) 0): Trip_right0_Ty.

(Trip_left1 L0 L1 R1 t) is the right-left of t.

Definition Trip_leftl :( fun LO L1 R1 t => (Pair_left L1 R1 (Trip_rightO L0 L1 R10))

(Trip_right1 LO LI R1 £) is the right-right of t.

Definition Trip_right1_Ty :(Vv

(LO: Type) (L1: Type) (R1: Type), (Op (Trip L0 L1 R1) RD ): Type.

Definition Tríp_ right1 :( fun L0 L1 R1 t => (Pair_right L1 R1 (Trip_right0 L0 L1 R1 Ð) )

(Quad_left0 L0 L1 L2 R2 t) is the left of q.

Definition Quad left0_Ty :(Vv

Definition Quad_left0 :( fun L0 L1 L2 R2 q => (Pair_left L0 (Trip L1 L2 R2) q))

(Quad_rightO LO L1 L2 R2 t) is the right of q.

Definition Quad_right0_Ty :(Vv

(LO: Type)(L1: Type)(L2: Type)(R2: Type),

(Op (Quad LO L1 L2 R2) (Trip L1 L2 R2) ): Type.

Definition Quad_right0 :( fun L0 L1 L2 R2 q => (Pair_right LO (Trip L1 L2 R2) q) )

(Quad_left1 L0 L1 L2 R2 0) is the right-left of

Definition Quad_left1_Ty :(Vv

(Trip_leƒt0 L1 L2 R2 (Quad_ right0 LO L1 L2 R2 q))

(Quad_left2 LO L1 L2 R2 0) is the right-right-left of q.

(LO: Type) (L1: Type) (L2: Type) (R2: Type), (Op (Quad LO L1 L2 R2) L2) ): Type.

(Trip_leftI L1 L2 R2 (Quad_right0 LO L1 L2 R2 q))

(Quad_right2 L0 L1 L2 R2 t) is the right-right-right of q.

(LO: Type) (L1: Type) (L2: Type) (R2: Type), (Op (Quad LO L1 L2 R2) R2) ): Type.

(Trip_right1 L1 L2 R2 (Quad_right0 LO L1 L2 R2 q))

Poohbist.NummSquared.Fundamentals.Lists.Main

Poohbist.NummSquared Fundamentals Lists.Main defines lists, non-empty lists, and some operators on lists and non-empty lists.

Require Import Poohbist.NummSquared.Fundamentals.Operators.Main.

A list Ais exactly one of the following: ôâ the nil list A s for some head: Aand rest: (Lis A), the cons list A of head and rest

Lis is defined in the same way as list in Coq Lists List, except that Lis: Type whereas list:Set.

Inductive Lis(A: Type) : Type :| Lis_nil: (Lis A)

| Lis_cons : (Op_Bin A (Lis A) (Lis A)).

A,a0, , alis the list A containing the elements a2, , a1 a0, 41 must contain at least one element.

A, a0, , 41 is defined in the same way as the list notation in [8, section 11.1.1), except that A, a0, , al explicitly includes A.

Notation "[A,a0, ,al]":(Lis_cons A a0 (Lis_cons A al (Lis_nil A)) ) : LiS_ sc0pe.

(Lis_rel AO A1 rel01 10 11) is the true Boolean if 10 and 11 have the same shape, and their corresponding elements 20: AO, al : Al satisfy (rel01 a0 a1); and the false Boolean otherwise.

Definition Lis_rel_Ty :(Vv

(A0: Type) (A1: Type) (rel01 : (Boo_Pred_Bin AO Al), (Boo_Pred_Bin (Lis AO) (Lis A1)) ): Type.

Definition Lis_rel := ( fun A0 Al rel01 > fix fo(l0: (Lis AO))(11 : (Lis Al)){struct 10} : Boo :match 10, L1 return Boo with

| Lis_nil, Lis_nil > Boo_t

| Lis_cons l0Head l0Rest, Lis_cons L1 Head L1Rest > if (rel01 l0Head 11Head) return Boo then (fp I0Rest 11 Rest) else Boo_f

(Lis_rel_conn A relA 10 11) is (Lis_rel AA relA 10 11).

Definition Lis_rel_conn_Ty : (Vv

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Boo_Pred_Bin_Conn (Lis A)) ): Type.

Definition Lis_rel_conn:(fun A relA 10 ll > (Lis_rel AA relA 10 1D) ) : Lis_rel_conn_Ty.

(Lis_head A è) is the none optional Aif ẽ is the nil list A; and the one optional A containing /Head if lis the cons list A of [Head and IRest.

Definition Lis_head_Ty :(V(A: Type), (Op (Lis A) (Optional A)) ) : Type.

Definition Lis_head := (fun A ẽ => match | return (Optional A) with

| Lis_cons lHead lRest > (Optional_one A lHead) end

(Lis_rest A I) is the none optional list A if ẽ is the nil list 4; and the one optional list A containing /Rest if lis the cons list A of [Head and IRest.

Definition Lis_rest_Ty :( V(A: Type), (Op (Lis A) (Optional (Lis A))) ) : Type.

Definition Lis_ rest := (fun Al=> match | return (Optional (Lis A)) with

| Lis_nil => (Optional_none (Lis A))

| Lis_cons lHead IRest > (Optional_one (Lis A) IRest) end

(Lis_nonEmpty A D is the false Boolean if ? is the nil list 4; and the true Boolean oth-

Definition Lis_nonEmpty_Ty :( V(A: Type), (Boo_Pred (Lis A)) ) : Type.

Definition Lis nonEmpty := ( fun Al> match | return Boo with

| Lis_cons lHead lRest > Boo_t end

(Lis_empty AD is (Boo_ not (Lis_ nonEmpty AD).

Definition Lis_empty-Ty :( V(A: Type), (Boo_ Pred (Lis A)) ) : Type.

Definition Lis_empty := (fun Al=>

(Lis_cat A 10 11) is the list A containing the elements in 70 followed by the elements in H.

Definition Lis_cat_Ty :( V(A: Type), (Op_Bin_Simp (Lis A)) ) : Type.

Definition Lis_ cat := ( fan A => fix pd0: (Lis A))(H1: (Lis A)){struct 10} : (Lis A) :match 10 return (Lis A) with

| Lis_cons l0Head l0Rest => (Lis_cons A lOHead (fp I0Rest 11)) end

(Lis_append A Ì a) is (Lis_cat A I {A, al).

Definition Lis_append_Ty :( V(A: Type), (Op_Bin (Lis A) A (Lis A)) ) : Type.

Definition Lis_ append :(fun Al a= (Lis_cat Al{A, a]) ) : Lis_append_ Ty.

(Lis_ Op_singleton A B opA) is the operator from A to a list B mapping a: A onto [B, (opA a)].

Definition Lis Op_singleton_Ty :(Vv

(A: Type) (B: Type) (opA : (Op A B)), (Op A (Lis B)) ): Type.

Definition Lis Op_singleton :(fun A B opA a= [B, (opA a)} ) : Lis_Op_singleton- Ty.

9.12.13 THE LIST SINGLETON BINARY OPERATOR

(Lis_Op_singleton_bin A0 A1 B opA) is the binary operator from A0, A1 to a list B mapping a0: A0, al: Al onto [B, (opA a0 al)).

Definition Lis_Op_singleton_bin-_ Ty :(v

(A0: Type) (Al: Type) (B: Type) (opA : (Op_ Bin A0 A1 B)), (Op- Bin A0 A1 (Lis B)) ): Type.

Definition Lis_Op_ singleton_bỉm :( fun A0 Al B opA a0 al = [B, (opA a0 a1)] ) : Lis Op_singleton_bin_Ty.

(Lis Op_prefix A B opA prefix) is the operator from A to a list B mapping a: A onto

Definition Lis_Op_prefix_ Ty :(Vv

(A: Type) (B: Type) (opA : (Op A (Lis B))) (prefix: (Lis B)), (Op A (Lis B)) ): Type.

Definition Lis_Op_ prefix := ( fun A B opA prefix a=>

(Lis_Op_suffix A B opA suffix) is the operator from A to a list B mapping a: A onto (Lis_cat B(opA a) suffix).

Definition Lis_Op_suffix_Ty : (Vv

(A: Type) (B: Type) (opA: (Op A (Lis B))) (suffix : (Lis B)), (Op A (Lis B)) ): Type.

Definition Lis_Op_suffix := (fun A B opA suffix a>

(Lis_generate A genA m) is the list A whose elements are obtained by conatenating the following lists A: (genA Nat_z), , (gerA mì).

(A: Type) (genA : (Op Nat (Lis A))), (Op Nat (Lis A))

Definition Lis_ generate := (fun A gerLA => fix ƒp(m: Nat){struct m} : (Lis A) :match m return (Lis A) with

| Nat_s mPre => (Lis_cat A (fp mPre) (genA m)) end

(Lis_generate_toElem A genA mm) is (Lis_ generate A (Lis Op_singleton Nat A genA) m). Definition Lis_generate_toElem_Ty :(V

(A: Type) (genA : (Op Nat A)), (Op Nat (Lis A)) ): Type.

Definition Lis_generate_toElem := ( fun A genAm=>

(Lis_ generate A (Lis_Op_singleton Nat A genA) mì)

A non-empty list Anamed | contains all of the following: ¢ the head of J, which is an A e the rest of j which is a list A

Record Lis_Ne(A: Type) : Type:= Lis_Ne ctor {

9.12.19 NON-EMPTY LIST RELATED TO

(List_Ne_rel A0 A1 rel01 10 I1) is the true Boolean if (rel01 (Lis_Ne_head A0 10)

(Lis_Ne_head A1 1])) and (Lis_rel A0 A1 rel01 (Lis_Ne_rest A0 10) (Lis_Ne_rest A1 1])); and the false Boolean otherwise.

Definition Lis_Ne_rel_ Ty :(Vv

(AO: Type) (A1: Type) (rel01 : (Boo_Pred_Bin AO Al), (Boo_Pred_Bin (Lis_Ne AO) (Lis_Ne AD) ): Type.

Definition Lis Ne_rel:= ( fun A0 Al rel01 10 L1 > if (rel01 (Lis Ne_head A0 10) (Lis_Ne_head A1 I1)) return Boo then

(Lis_rel AO A1 rel01 (Lis_Ne_rest A0 10) (Lis_Ne_rest A1 11)) else Boo_f

9.12.20 NON-EMPTY LIST RELATED TO, CONNECTIVE

(List Ne_rel_conn A relA 10 I1) is (Lis Ne_rel AA relA 1011).

Definition Lis Ne_ re] conn_ Ty :(V

(A: Type)(relA : (Boo_Pred_Bin_Conn A)),

(Boo_ Pred_ Bin_ Conn (Lis_Ne A)) ): Type.

Definition Lis_Ne_rel_conn :(fun A relA 10 11 = (Lis_Ne_rel AA relA 1011) )

: Lis_Ne_rel_conn_Ty.

(List_Ne_singleton A a) is the non-empty list A containing just a.

Definition Lis_ Ne_singleton_Ty :(V(A: Type), (Op A (Lis_ Ne A)) ) : Type.

Definition Lis Ne_singleton := ( fun A a>

(Lis_Ne_ctor A a (Lis_nil A))

9.12.22 NON-EMPTY LIST TO LIST

(List_Ne_to_Lis A l) is the list A containing the same elements as /.

Definition Lis_Ne_to_Lis_Ty :( V(A: Type), (Op (Lis_Ne A) (Lis A)) ) : Type.

Definition Lis_Ne_to_Lis := ( fan Al=>

(Lis_cons A (Lis_Ne_head A Ù (Lis_Ne_rest AD)

) : Lis_Ne to_Lis_ Tỳ.

9.12.23 THE NON-EMPTY LIST HEAD OPERATOR

(Lis_ Ne_Op_ head A B opA) is the operator from a non-empty list A to B mapping ẽ: (Lis_Ne A) onto (opA (Lis_Ne_head A D).

Definition Lis_Ne_Op_head_Ty :(Vv

(A: Type)(B: Type)(apA: (Op A Bì),

Definition Lis_Ne_Op_head :( fun A B opA Ì > (opA (Lis_Ne_head A Ù) ) : Lis Ne_Op_head TY.

9.12.24 LIST TO NON-EMPTY LIST

The function Lis_to_Lis_Ne A I defines a non-empty list A as mandatory when J is an empty list A It also specifies that if J is not empty, A can be an optional non-empty list containing the same elements as the given list.

Definition Lis_to_Lis_Ne_ Ty :( V(A: Type), (Op (Lis A) (Optional (Lis_Ne A))) ) : Type.

Definition Lis_to_Lis_Ne:=(funAl=> match Ì return (Optional (Lis_Ne A)) with

| Lis_nil => (Optional_none (Lis_Ne A))

(Optional_one (Lis_Ne A) (Lis_Ne_ctor A lHead LRest)) end

): Lis_to_Lis_Ne_Ty.

A 2 plus list Anamed / contains all of the following: e the head of J, which is an A ¢ the rest of j which is anon-empty list A

Record Lis P2(A: Type) : Type := Lis_P2_ctor {

Poohbist.NummSquared Fundamentals Optionals.AndLists

Poohbist.NummSquared.Fundamentals Optionals.AndLists defines some operators relating optionals and lists.

(Optional_to_Lis A o) is the nil list A if ois the none optional A; and [A, a] if ois the one optional A containing a.

Definition Optional_to_Lis_ Ty :(V(A: Type), (Op (Optional A) (Lis A)) ) : Type.

Definition Optional_to_Lis := (fun Ao=> match o return (Lis A) with

Poohbist.NummSquared.Fundamentals.Booleans.AndLists

Poohbist.NummSquared Fundamentals Booleans.AndLists defines some operators relating Booleans and lists.

Require Import Poohbist NummSquared Fundamentals Booleans.AndOptionals.

Require Import Poohbist NummSquared Fundamentals Optionals.AndLists.

(Boo_to_Lis A b a) is (Optional_to_Lis A (Boo_to_ Optional A b a)).

Definition Boo_to_Lis_Ty :(V

(A: Type), (Op_Bin Boo A (Lis A)) ): Type.

Definition Boo_to_Lis:= ( fun A ba(Optional_to_Lis A (Boo_to_Optional A b a))

(Boo_Op-_ Lis A predA) is the operator from Ato an list Amapping 4: A onto

Definition Boo_Op-Lis_ Ty : (Vv

(A: Type) (predA : (Boo_ Pred A)), (Op A (Lis A))

Definition Boo_Op-Lis :( fun A predA a= (Boo_to_Lis A (predA a) a) ) : Boo_Op_ Lis_ T.

Poohbist.NummSquared Fundamentals Naturals.AndLists

Poohbist.NummSquared.Fundamentals Naturals.AndLists defines natural number lists, and some operators on natural number lists.

Require Import Poohbist NummSquared Fundamentals Naturals.Main.

Require lmport Poohbist NummSquared.Fundamentals.Lists.Main.

A natural number list is a list of natural numbers.

Definition Nat_Lis := (Lis Nat) : Type.

(Nat_Lis_eq 10 11) is the true Boolean if J0 and 11 are structurally equal; and the false Boolean otherwise.

Definition Nat Lis_eq := ( fun Ì0 11 >

(Lis_rel_conn Nat Nat_eq 10 11) ) : (Boo_Pred_Bin_Conn Nat_ Lis).

Poohbist.NummSquared Fundamentals Naturals Efficient.AndLists

Poohbist.NummSquared.Fundamentals Naturals Efficient.AndLists defines efficient natural number lists, and some operators on efficient natural number lists.

Require Import Poohbist.NummSquared.Fundamentals Naturals Efficient.Main.

Require Import Poohbist.NummSquared.Fundamentals Lists.Main.

An efficient natural number list is a list of efficient natural numbers.

Definition Nat_Eff Lis := (Lis Nat_Eff) : Type.

9.16.3 EFFICIENT NATURAL NUMBER LIST EQUALS

(Nat_Eff_Lis_eq 10 LD is the true Boolean if /0 and 11 are structurally equal (except using Nat_Eff.eq); and the false Boolean otherwise.

Definition Nat_Eff_Lis_eq:= ( fun loll >

(Lis_rel_conn Nat_Eff Nat_Eff_eq 10 11) ): (Boo_Pred_Bin Conn Nat_Eff_Lis).

Poohbist.NummSquared.Fundamentals.Pairs.AndLists

Poohbist.NummSquared Fundamentals Pairs.AndLists defines some operators relating pairs and lists.

Require Import Poohbist.NummSquared.Fundamentals.Pairs.Main.

Require Import Poohbist NummSquared.Fundamentals Lists.Main.

9.17.2 PAIR OF HEAD AND REST TO NON-EMPTY LIST

(Pair_headRest_to_Lis_Ne A p) is (Lis Ne_ctor A (Pair_left A (Lis A) p) (Pair_right A

Definition Pair_headRest to_Lis Ne_ Ty :( V (A: Type), (Op (Pair A (Lis A)) (Lis_Ne A)) )

Definition Pair_headRest_to_Lis_Ne:=( fun A p>

(Lis_Ne_ctor A (Pair_left A (Lis A) p) (Pair_right A (Lis A) p))

) : Pair_headRest_to_Lis_Ne_Ty.

Poohbist.NummSquared.Fundamentals.Lists.Select

Poohbist NummSquared.Fundamentals Lists.Select defines some selection operators on lists.

Require Import Poohbist NummSquared.Fundamentals Optionals.Main.

Require Import Poohbist NummSquared.Fundamentals.Booleans.AndLists.

The function (Lis_select A B selectSuffix I) generates list B by applying selectSuffix to each non-empty suffix of I, including I itself if it is non-empty, resulting in a non-empty list A The final output, list B, is formed by concatenating the lists produced from each suffix If list A is empty, then (Lis_select A will also yield an empty result.

B selectSuffix 1) is the nil list B.

Lis_select is somewhat similar in concept to the LISP mapcon function (see [27, chapter 12]).

Definition Lis_select_Ty :(Vv

(A: Type) (B: Type) (selectSuffix : (Op (Lis_Ne A) (Lis B))), (Op (Lis A) (Lis B))

Definition Lis_select := ( fun A B selectSuffix > fix fll: (Lis A)){struct I: (Lis B) :match l return (Lis B) with

B (selectSuffix (Lis_Ne_ctor A lHead lRest)) (fp lRest)

(Lis_select_simp A selectSuffix D) is (Lis_select A A selectSuffix I).

Definition Lis_select_simp-_Ty :(Vv

(A: Type) (selectSuffix : (Op (Lis_Ne A) (Lis A))), (Op_Simp (Lis A))

Definition Lis_select_simp := ( fun A selectSuffix l=>

(Lis_select_iter A selectSuffix | m) is (Nat_iter (Lis A) (Lis_select_simp A selectSuffix) | mì).

Definition Lis_select_iter_Ty : (Vv

(A: Type) (selectSuffix : (Op (Lis_ Ne A) (Lis A))), (Op-_Bin (Lis A) Nat (Lis A))

Definition Lis_select_iter := ( fun A selectSuffix 1m =>

(Nat_iter (Lis A) (Lis_select_simp A selectSuffix) l mì)

(Lis_select_toElem A B selectSuffix 1) is (Lis_select A B (Lis_Op_singleton (Lis_Ne A) B selectSuffix) ).

Lis_select_toElem is somewhat similar in concept to the LISP maplist function (see

Definition Lis_select_toElem_Ty :(Vv

(A: Type) (B: Type) (selectSuffix : (Op (Lis_Ne A) B)), (Op (Lis A) (Lis B))

Definition Lis_select_toElem := ( fun A B selectSuffix Ì =>

(Lis_select A B (Lis_Op_singleton (Lis_Ne A) B selectSuffix) D

9.18.6 LIST SELECT, TO ELEMENT, SIMPLE

(Lis_select_toElem_simp A selectSuffix I) is (Lis_select_toElem A A selectSuffix Ù.

Definition Lis_select_toElem_simp_Ty :(Vv

(A: Type) (selectSuffix : (Op (Lis_ Ne A) A)), (Op_Simp (Lis A))

Definition Lis_select_toElem_simp := ( fun A selectSuffix Ì >

(Lis_select_toElem AA selectSuffix D

): Lis_select_toElem_simp_Ty.

9.18.7 LIST SELECT, TO ELEMENT, ITERATE

(Lis_select_toElem_iter A selectSuffix Ì m) is (Nat_iter (Lis A) (Lis_select_toElem_simp

Definition Lis_ select toElem iter_Ty : (Vv

(A: Type) (selectSuffix : (Op (Lis_Ne A) A)), (Op- Bin (Lis A) Nat (Lis A)) ): Type.

Definition Lis_select_toElem_iter := ( fun A selectSuffix Ì m =>

(Nat_iter (Lis A) (Lis_select.toElem_simp A selectSuffix) I m)

) : Lis_select_toElem_iter_Ty.

(Lis_select_byElem A B selectA I) is (Lis_select A B (Lis_Ne_Op_head A (Lis B) selectA)

The function (Lis_select_byElem A B selectA I) generates list B by applying selectA to each element in A, preserving the original order from list I, and then concatenating the resulting lists If list A is empty (nil), the output list B will also be empty (nil).

Lis_select_byElem is somewhat similar in concept to the LISP mapcan function (see

Definition Lis_select_byElem_Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A (Lis B))), (Op (Lis A) (Lis B)) ): Type.

Definition Lis_select_byElem := ( fan AB selectA l(Lis_select A B (Lis Ne_Op_ head A (Lis B) selectA) }

9.18.9 LIST SELECT, BY ELEMENT, SIMPLE

(Lis_select_byElem_simpA selectA I) is (Lis_select_byElem AA selectA I).

Definition Lis_select_byElem_simp_Ty :(VY

(A: Type) (selectA : (Op A (Lis A))), (Op_Simp (Lis A)) ): Type.

Definition Lis_select_byElem_simp := ( fun A selectA | =>

) : Lis_select_byElem_simp_Ty.

9.18.10 LIST SELECT, BY ELEMENT, ITERATE

(Lis_select_byElem_iter A selectA I m) is (Nat_iter (Lis A) (Lis_select_byElem_simp A selectA) Ì m).

Definition Lis_select_byElem_iter_Ty :(Vv

(A: Type)(selectA : (Op A (Lis A))),(Op- Bin (Lis A) Nat (Lis A))): Type.

Definition Lis_select_byElem_iter := (fun A selectA ẽ m =>

(Nat_iter (Lis A) (Lis_select_byElem_simp A selectA) | mì)

) : Lis_select_byElem_iter_Ty.

9.18.11 LIST SELECT, BY ELEMENT, INTRODUCED

(Lis_select_byElem_intro A B selectA intro Ì) is (Lis_select_byElem A B (Lis_Op_ prefix A

Definition Lis_select.byElem_intro_Ty :(Vv

(B: Type) (selectA : (Op A (Lis B))) (intro: (Lis B)),

Definition Lis_select_byElem_intro := ( fun AB selectA intro Ì =>

(Lis_select_ byElem A B (Lis_Op-prefix A B selectA intro) I

): Lis_select_byElem_intro_Ty.

9.18.12 LIST SELECT, BY ELEMENT, TERMINATED

(Lis_select_byElem_ter A B selectA ter I) is (Lis_select_byElem A B (Lis_Op_suffix AB selectA ter) I).

Definition Lis_select_byElem_ter_Ty :(V

(A: Type) (B: Type) (selectA : (Op A (Lis B))) (ter: (Lis B)),

Definition Lis_select_byElem_ter := ( fun AB selectA ter |=>

(Lis_select_byElem A B (Lis_Op_suffix A B selectA ter) Ð

): Lis_select_byElem._ ter_ TY.

9.18.13 LIST SELECT, BY ELEMENT, SEPARATED

(Lis select_ byElem_ sep A B selectA sep Ì) is the nil list Bif lis the nil list A; and the list

B obtained by concatenating (selectA lHead) and (Lis_select_byElem_intro A B selectA sep IRest) if lis the cons list A of [Head and IRest.

Definition Lis_select_byElem_sep-Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A (Lis B))) (sep: (Lis B)),

Definition Lis_ select byElem_sep := ( fun AB selectA sep 1=> match | return (Lis B) with

B (selectA lHead) (Lis_select_byElem_intro A B selectA sep lRest) end

): Lis_select byElem-_sep- Tỳ.

9.18.14 LIST SELECT, BY ELEMENT, TO ELEMENT

(Lis_select byElem_toElem A B selectA Ì) is (Lis_select_ byElem A B (Lis.Op_ singleton A

Lis_select byElem_toElem is somewhat similar in concept to the LISP mapcar function (see [27, chapter 12]).

Definition Lis_select_byElem_toElem_Ty :(Vv

(A: Type) (B: Type) (selectA : (Op A B)), (Op (Lis A) (Lis B)) ): Type.

Definition Lis_select_byElem_toElem := ( fun AB selectA | =>

(Lis_select_byElem A B (Lis_Op_singleton A B selectA) I)

): Lis_select_byElem_toElem- Ty.

9.18.15 LIST SELECT, BY ELEMENT, TO ELEMENT, SIMPLE

(Lis_select_byElem_toElem_simp A selectA I) is (Lis_select_byElem_toElem AA selectA D.

Definition Lis_select_byElem_toElem_simp- Ty :( V(A: Type) (selectA : (Op_Simp A)), (Op_Simp (Lis A))

Definition Lis_select_byElem_toElem_simp := ( fun A selectA Ì =>

(Lis_select_byElem_toElem A A selectA })

): Lis_select_byElem_toElem_simp- Ty.

9.18.16 LIST SELECT, BY ELEMENT, TO ELEMENT, ITERATE

(Lis_select_byElem_toElem_iter A selectA | m) is (Nat_iter (Lis A)

(Lis_select_byElem_toElem_simp A selectA) Ì mì.

Definition Lis_select_byElem_toElem_iter_Ty :(Vv

(A: Type) (selectA : (Op_Simp A)), (Op_Bin (Lis A) Nat (Lis A)) ): Type.

Definition Lis_select_byElem_toElem_iter := ( fun A selectA lm=>

(Nat_iter (Lis A) (Lis_select_byElem_toElem_simp A selectA) | mì)

) : Lis_select_byElem_toElem_iter_Ty.

9.18.17 LIST SELECT, BY PREFIX, RECURSIVE

The function `Lis_select_byPrefix_recur` generates a list B by applying `selectPrefix` to each non-empty prefix of a given list, appending earlier elements, and separating the tail If the input list A is empty, the resulting list B will also be empty.

Definition Lis_select_byPrefix_recur_Ty : (Vv

(A: Type) (B: Type) (selectPreftx: (Op_Bin (Lis A) A (Lis B))), (Op_Bin Conn (Lis A) (Lis B))

Definition Lis_select_byPrefix_recur := ( fun A B selectPrefix > fix fot: (Lis A)) (earlier : (Lis A)){struct 9 : (Lis B) :match | return (Lis B) with

B (selectPrefix earlier LHead) (fp lRest (Lis_append A earlier lHead)) end

): Lis_select_byPrefix_recur_Ty.

The function Lis_select_byPrefix A B selectPrefix Ì generates list B by applying selectPrefix to each non-empty prefix of list A, ensuring that the process includes the last element, 7, if list A is not empty It separates the tail of each prefix and concatenates the resulting lists to form B If list A is empty (nil), the output will also be an empty list B.

Definition Lis_select_byPrefix_ Ty :(Vv

(A: Type) (B: Type) (selectPrefix : (Op_Bin (Lis A) A (Lis B))), (Op (Lis A) (Lis B))

Definition Lis_select_byPrefix := ( fun A B selectPrefix ẽ =>

(Lis_select_byPrefix_recur A B selectPrefix | (Lis_nil A))

9.18.19 LIST SELECT, BY PREFIX, SIMPLE

(Lis_select_byPrefix_simp A selectPrefix l) is (Lis_select_byPrefix AA selectPrefix I). Definition Lis_select_byPrefix_simp_Ty :(Vv

(A: Type) (selectPrefix : (Op_Bin (Lis A) A (Lis A))), (Op_Simp (Lis A))

Definition Lis_select_byPrefix_simp := ( fun A selectPrefix Ì =>

(Lis_select_ byPrefix AA selectPrefix ])

) : Lis_select_byPrefix_simp_Ty.

9.18.20 LIST SELECT, BY PREFIX, ITERATE

(Lis_select_byPrefix_iter A selectPrefix | m) is (Nat_iter (Lis A)

(Lis_select_byPrefix.simp A selectPrefix) Ì mì.

Definition Lis_select_byPrefix_iter_Ty : (v

(A: Type) (selectPrefix : (Op_Bin (Lis A) A (Lis A))), (Op- Bí (Lis A) Nat (Lis A))

Definition Lis select_byPrefix_iter := ( fun A selectPrefix Ì m(Nat_iter (Lis A) (Lis_select_byPrefix_simp A selectPrefix) | m)

) : Lis_select_byPrefix_iter_Ty.

9.18.21 LIST SELECT, BY PREFIX, TO ELEMENT

(Lis_select_byPrefix_toElem A B selectPrefix Ù is (Lis_select_byPrefix A B

(Lis_Op_singleton_bin (Lis A) A B selectPrefix) 1).

Definition Lis_select_byPrefix_toElem_Ty :(Vv

(A: Type) (B: Type) (selectPrefix : (Op-_Bin (Lis A) A B)), (Op (Lis A) (Lis B))

Definition Lis_select_byPrefix_toElem := ( fun A B selectPrefix | =>

A B (Lis_Op_singleton_bin (Lis A) A B selectPrefix) l

) : Lis_select_byPrefix_toElem_ Ty.

9.18.22 LIST SELECT, BY PREFIX, TO ELEMENT, SIMPLE

(Lis_select_byPrefix_toElem_simp A selectPrefix ]) is (Lis_select_byPrefix_toElem AA selectPrefix Ì).

Definition Lís_select_byPrefix toElem simp TY : (v

(A: Type) (selectPrefix : (Op_Bin (Lis A) A A)), (Op_Simp (Lis A))

Definition Lis_select_byPrefix_toElem_simp := ( fun A selectPrefix Ì =>

(Lis_select_byPrefix_toElem A A selectPrefix 1)

) : Lis_select_byPrefix_toElem_simp_Ty.

9.18.23 LIST SELECT, BY PREFIX, TO ELEMENT, ITERATE

(Lis_select_byPrefix_toElem_iter A selectPrefix | mì) is (Nat_iter (Lis A)

(Lis_select_byPrefix_toElem_simp A selectPrefix) | mì).

Definition Lis_select_byPrefix_toElem_iter_Ty : (Vv

(A: Type) (selectPrefix : (Op_Bin (Lis A) A A)), (Op_Bin (Lis A) Nat (Lis A))

Definition Lis_select_byPrefix_toElem_iter := ( fun A selectPrefix Ì m (Nat_iter

(Lis A) (Lis_select_byPrefix_toElem_simp A selectPrefix) l m

) : Lis_select_byPrefix_toElem_iter_Ty.

(Lis_search A matA Ì) is (Lis_select_byElem_simp A (Boo_ Op_ Lis A matA) ]).

(Lis_search A mata Ì) is I, less those a: A that do not satisfy (mat a).

Definition Lis_search_Ty : (Vv

(A: Type) (matA : (Boo_Pred A)), (Op_Simp (Lis A)) ): Type.

Definition Lis_search := (fun A mata Ì =>

(Lis_select_byElem_simp A (Boo_Op_Lis A matA) Ì)

(Lis_search_first A mata I) is (Lis_ head A (Lis_search A matA Ì)).

Definition Lis_search_first_Ty :(V

(A: Type) (matA : (Boo_Pred A)), (Op (Lis A) (Optional A)) ): Type.

Definition Lis_search_first := (fun A mataAl=>

(Lis_head A (Lis_search A mat Ì))

(Lis_search_isFound A mata Ì) is (Lis.nonEmpty A (Lis_search A matA D).

(Lis_search_isFound A mata I) is the true Boolean if there is some 4: Ain / such that (mata a); and the false Boolean otherwise.

Definition Lis_search_isFound_Ty :(Vv

(A: Type) (mata : (Boo_ Pred A)), (Boo_ Pred (Lis A)) ): Type.

Definition Lis_search_isFound := ( fun A matAl=>

(Lis.nonEmpty A (Lis_search A matA Ì))

(Lis_intersect.mat A0 A1 rel01 11) is the Boolean predicate on AO mapping a0: A0 onto (Lis_search_isFound Al (rel01 a0) 1D).

The Boolean predicate (Lis_intersect_mat AO Al rel01 L1) maps elements from A0 to true if there exists an element a1 in Al such that the relation rel01 holds between a0 and a1; otherwise, it maps to false.

Definition Lis_intersect_mat_Ty :(V

(AO: Type) (AI: Type) (rel01: (Boo_Pred_Bin A0 A1)) (11: (Lis AD),

Definition Lis_intersect_mat := ( fun A0 Al rel01 l1 a0 >

(Lis_intersect AO Al relO1 10 11) is (Lis_ search AO (Lis_intersect_ mat AO Al rel01 11) 10).

(Lis_intersect AO A1 rel01 10 11) is 10, less those a0: A0 for which there is no 21: Alin L1 such that (rel01 a0 al).

Definition Lis_intersect_ Ty :(Vv

(A0: Type)(Al : Type)(rel01 : (Boo_ Pred_ Bin A0 Al)),(Op-_ Bin (Lis AO) (Lis Al) (Lis A0))

Definition Lis intersect := (fun A0 Al rel01 l0 11 >

(Lis_search AO (Lis_intersect mat A0 A1 rel01 1) 10)

(Lis_intersect_conn A relA I0 11) is (Lis_intersect AA relA 10 ID.

Definition Lis_intersect_conn_Ty :(Vv

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Op_Bin_Simp (Lis A))

Definition Lis_intersect_conn:= ( fun A relA I0 ll >

(Lis_intersect_first AO A1 rel01 10 11) is (Lis_ head A0 (Lis_intersect AO A1 rel01 10 11). Definition Lis_intersect_first_Ty :(Vv

(A0: Type) (Al: Type) (rel01 : (Boo Pred_Bin A0 Al)), (Op_Bin (Lis AO) (Lis A1) (Optional A0)) ): Type.

Definition Lis_intersect_first := (fun A0 A1 rel01 10 l1 >

(Lis_head AO (Lis_intersect A0 Al rel01 10 11)

(Lis_intersect_first.conn A relA 10 11) is (Lis_intersect_first A A relA 10 11).

Definition Lis_intersect_first_conn_Ty :(Vv

(A: Type) (relA : (Boo_Pred_Bin_Conn A)), (Op_Bin_Conn (Lis A) (Optional A)) ): Type.

Definition Lis_intersect_first_conn := ( fun A relA 10 l1 >

): Lis_intersect_first_conn_Ty.

(Lis_intersect_nonEmpty A0 A1 rel01 10 11) is (Lis_nonEmpty A0 (Lis_intersect A0 Al rel01 10 11)).

Definition Lis_intersect_nonEmpty_Ty :(Vv

(AO: Type) (A1: Type) (rel01 : (Boo_Pred_Bin A0 A1)), (Boo_Pred_Bin (Lis A0) (Lis A1)) ): Type.

Definition Lis_intersect_nonEmpty := ( fun A0 Al rel01 10 l1 =>

(Lis_nonEmpty A0 (Lis_intersect AO Al rel01 10 11)

9.18.33 LIST INTERSECTION, NON-EMPTY, CONNECTIVE

(Lis_intersect_nonEmpty-_conn A relA 10 11) is (Lis_intersect.nonEmpty AA relA 10 11). Definition Lis_intersect_nonEmpty_conn_Ty :(Vv

(A: Type)(relA : (Boo_Pred_Bin_Conn A)),(Boo_Pred_Bin_Conn (Lis A))): Type.

Definition Lis_intersect.nonEmpty_conn:= ( fun A relA 10 l1 >

(Lis_intersect.nonEmpty AA relA 10 11)

): Lis_intersect_nonEmpty_conn_Ty.

(Lis_ to_Boo_ Pred A I) is the Boolean predicate on (Boo Pred A) mapping mata: (Boo_ Pred A) onto (Lis_search_isFound A matA I.

Definition Lis_to_Boo_Pred_Ty :(Vv

(A: Type), (Op (Lis A) (Boo_ Pred (Boo_Pred A))) ): Type.

Definition Lis_to_Boo_Pred:(fun Al matA => (Lis_search_isFound A mat ] ): Lis_to_Boo_Pred_Ty.

9.19 FUNDAMENTALS: OPTIONALS: AND LISTS SELECT

Poohbist NummSquared Fundamentals Optionals.AndaListsSelect

Poohbist NummSquared Fundamentals Optionals.AnaListsSelect defines some operators relating optionals and list selection operators.

Require Import Poohbist NummSquared.Fundamentals Optionals Main.

Require Import Poohbist.NummSquared Fundamentals Optionals.AndLists.

Require Import Poohbist NummSquared Fundamentals Lists.Select.

(Optional_flattenLis A I) is (Lis_select_ byElem (Optional A) A (Optional_to_Lis A) ID.

Definition Optional_flattenLis_Ty :(Vv

(A: Type), (Op (Lis (Optional A)) (Lis A)) ): Type.

(Lis_select_byElem (Optional A) A (Optional_to-Lis A) })

Poohbist.NummSquared Fundamentals Listfunctions.Main

Poohbist.NummSquared Fundamentals Listfunctions Main defines listfunctions, simple listfunctions, and some operators on listfunctions and simple listfunctions.

Require Import Poohbist.NummSquared Fundamentals Naturals.Main.

A listfunction from A to Bis an operator from A to a list B.

Definition Lisfunction_Ty := ( V(A : Type)(B: Type), Type) : Type.

Definition Lisfunction := ( fun A B > (Op A (Lis B)) ) : Lisfunction_Ty.

(Lisfunction_to.Boo-_ Pred A B If a) is (Lis_to_Boo_ Pred B (If a)).

Definition Lisfunction_to_Boo_Pred_Ty :(Vv

(A: Type) (B: Type), (Op_Bin (Lisfunction A B) A (Boo_ Pred (Boo_ Pred B))) ): Type.

Definition Lisfunction_to_Boo_Pred :( fun A B If a= (Lis_to_Boo_Pred B (If a)))

: Lisfunction_to_Boo_Pred_Ty.

A simple listfunction on A is a listfunction from A to A.

Definition Lisfunction_Simp_Ty := (W(A: Type), Type) : Type.

Definition Lisfunction_ Simp :( fun A => (Lisfunction A A) ) : Lisfunction_Simp-Ty.

9.20.5 SIMPLE LISTFUNCTION TO BOOLEAN PREDICATE

(LisfuncHon_ Simp_to_Boo_ Pred A If a) is (Lisfunction_to_Boo_Pred A A Iƒ a).

Definition LisfuncHon_Simp to_Boo_ Pred_ Ty :(Vv

(A: Type), (Op_Bin (Lisfunction Simp A) A (Boo_ Pred (Boo_ Pred A))) ): Type.

Definition Lisfunction_Simp_to_Boo_Pred :( fun A If a= (Lisfunction_to_Boo_Pred AA If a) )

: Lisfunction_Simp-_to_Boo_Pred_Ty.

(Lisfunction_Simp-iter A If m) is the simple listfunction on A mapping 4: A onto (Lis_select_byElem_iter A If {A, a| m).

Definition Lisfunction_Simp-_iter_Ty : (v

(A: Type), (Op Bin (Lisfunction_Simp A) Nat (Lisfunction_Simp A)) ): Type.

Definition Lisfunction_Simp-iter := (fun Alf ma=>

(Lis_select_byElem_iter A If [A, a] m)

(Lisfunction_Simp-iter_c2 A If a m) is (Lisfunction_Simp_iter A lf ma).

Definition Lisfunction_Simp_iter_c2_Ty :(V

(A: Type), (Op-_Tri (Lisfunction_Simp A) A Nat (Lis A)) ): Type.

Definition Lisfunction_Simp_iter_c2:(fun Alf am = (Lisfunction_Simp_iter Alf ma) )

(Lisfunction_Simp-_iter_cum A If m) is the simple listfunction on A mapping 4: A onto (Lis_generate A (Lisfunction_Simp_iter_c2 Alf a) m).

Definition Lisfunction_Simp_iter.cum_Ty :(V

(A: Type), (Op_Bin (Lisfunction_Simp A) Nat (Lisfunction_Simp A)) ): Type.

Definition Lisfunction_Simp_iter_cum:= ( funAlf ma>

(Lis_ generate A (Lisfunction_Simp-iter_c2 A lf a) m)

) : Lisfunction_Simp-_iter_cum_ Tỳ.

Poohbist.NummSquared NummSquared.Syntax.Abstract.Main defines the Numm- Squared abstract syntax types, and some operators on these types.

Require Import Poohbist NummSquared Fundamentals Naturals Efficient.Main.

Require Import Poohbist NummSquared.Fundamentals Naturals Efficient.AndLists. Require Import Poohbist NummSquared Fundamentals Optionals.Main.

A NummSquared digit character should be interpreted as the similarly named Uni- code code point in the C0 Controls and Basic Latin range See [38, "CO Controls and Basic Latin"].

Inductive Ns_Chr_ Digit : Type :| Ns_Chr_Digit_d0: Ns Chr_ Digit

| Ns_Chr_Digit_dl: Ns_ Chr_ Digit

| Ns_Chr_Digit.d3: Ns_Chr_Digit

| Ns_Chr_Digit_d4: Ns_ Chr_ Digit

| Ns_Chr._ Digit d5: Ns Chr_ Digit

| Ns_Chr_ Digit 46: Ns_Chr_ Digit

| Ns_Chr_Digit.d7: Ns_ Chr_ Digit

|Ns_Chr_ Digit d9: Ns_ Chr_ Digit.

(Ns_Chr-_Digit_eq cả0 cdl) is the true Boolean if cđ0 and cd1 are structurally equal; and the false Boolean otherwise.

Definition Ns Chr_ Digit_eq := ( fun cả0 cdl > match cdo, cdl return Boo with

| Ns_Chr_ Digit d0, Ns Chr Digit d0 > Boo_t

|Ns_Chr_ Digit d1, Ns Chr_Digit d1 => Boo_t

|Ns Chr_Digit d2, Ns_Chr_Digit_d2 => Boo_t

| Ms _Chr_Digit d3, Ns.Chr_Digit.d3 > Boo_t

|jNs_Chr_ Digit d4, Ns Chr_Digit.d4 => Boo_t

| Ns_Chr_Digit_d5, Ns Chr_Digit-d5 > Boo_t

| Ns_Chr_Digit.d6, Ns_Chr_Digit d6 > Boo_t

| Ns_Chr_Digit_d9, Ns_Chr_Digit_d9 > Boo_t

) : (Boo_Pred_Bin_Conn Ns_Chr_Digit).

A NummSquared identifier start character should be interpreted as the similarly named Unicode code point in the C0 Controls and Basic Latin range See [38, "C0 Con- trols and Basic Latin"].

Inductive Ns_Chr_Ident_Start : Type :| Ns_Chr_Ident_Start_exclamationMark : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_ampersand : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_asterisk : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_plusSign : Ns_ Chr_Ident_Start

| Ns_Chr_Ident_Start_hyphenMinus : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_slash: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_lessThanSign : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_equaisSign : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_greaterThanSign : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_A: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_B: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_C : Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_D: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_E : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_F : Ns Chr_Ident_ Start

| Ns_Chr_Ident_Start_G: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_H : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_I : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_J : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_K : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_L: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_M : Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_N : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_O: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_P ; Ns.Chr_Ident_Start

| Ns Chr_Ident_Start_Q: Ns Chr_Ident_Start

| Ns_Chr_Ident_Start_R: Ns_Chr-_Ident_Start

| Ns Chr_Ident_Start_S: Ns Chr_Ident_Start

| Ns Chr_Ident_Start.T : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start.U : Ns Chr_Ident_Start

| Ns_Chr_Ident_Start_V : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_W : Ns Chr ldent Start

| Ns Chr_Ident_Start_X : Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_Y : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_Z : Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_circumflexAccent : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_a: Ns_ Chr_ldent Start

| Ns.Chr_Ident_Start_b: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start.c: Ns_Chr_Ident_Start

| Ns_Chr_Ident.Start_d: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_e: Ns_Chr ldent Start

| Ns Chr_Ident_Start_f : Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_g: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_h: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_i: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_j: Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_k: Ns Chr_Ident_Start

| Ns_Chr_Ident_Start_l: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start.m: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_n: Ns_Chr_Ident_Start

| Ns Chr_Ident_Start_o: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_p: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_q: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_r: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_s: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_t: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_u: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_v: Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_w: Ns.Chr_Ident_Start

| Ns_Chr_Ident_Start_x : Ns_Chr_Ident_Start

| Ns_Chr_Ident_Start_y : Ns.Chr_Ident_Start

| Ns Chr_Ident_Start_z: Ns_Chr_Ident_ Start

| Ns_Chr_Ident_Start_verticalBar : Ns_Chr_Ident_Start.

9.21.5 NUMMSQUARED IDENTIFIER START CHARACTER EQUALS

(Ns_Chr_Ident_Start_eq cis0 cis1) is the true Boolean if cisO and cis1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Chr_Ident_Start_eq := ( fun cis0 cis1 => match cis0, cis1 return Boo with

| Ns_Chr_Ident_Start_exclamationMark,

Ns_Chr_Ident_Start_exclamationMark >

| Ns_Chr_Ident_Start_ampersand, Ns_Chr_Ident_Start_ampersand = Boo_t

| Ns_Chr_Ident_Start_asterisk, Ns.Chr_Ident_Start_asterisk => Boo_t

| Ns Chr_Ident_Start_plusSign, Ns_Chr_Ident_Start_plusSign => Boo_t

| Ns_Chr_Ident_Start_hyphenMinus, Ns_Chr_Ident_Start_hyphenMinus >

| Ns_Chr_Ident_Start_slash, Ns.Chr_Ident_Start_slash > Boo_t

| Ns_Chr_Ident_Start_lessThanSign, Ns_Chr_Ident_Start_lessThanSign >

| Ns_Chr_Ident_Start_equalsSign, Ns_Chr_Ident_Start_equalsSign => Boo_t

| Ns_Chr_Ident_Start_greaterThanSign,

Ns_Chr_Ident.Start_greaterThanSign >

| Ns_Chr_Ident_Start_A, Ns_Chr ldent Start A > Boo_t

| Ns_Chr_Ident_Start_B, Ns_Chr_Ident_Start_B => Boo_t

| Ns_Chr_Ident_Start_C, Ns_Chr_Ident_Start_C => Boo_t

| Ns_Chr_Ident_Start_D, Ns_Chr_Ident_Start_D => Boo_t

| Ns_Chr_Ident_Start_E, Ns_Chr_Ident_Start_E > Boo_t

| Ns_Chr_Ident_Start_F, Ns_Chr_Ident_Start_F > Boo_t

| Ns_Chr_Ident_Start_G, Ns_Chr_Ident_Start_G => Boo_t

| Ns_Chr_Ident_Start.H, Ns_Chr_Ident_Start_H => Boo_t

| Ns_Chr_Ident_Start_I, Ns_Chr_Ident_Start_I > Boo_t

| Ns_Chr_Ident_Start_J, Ns.Chr_Ident_Start_] => Boo_t

| Ns_Chr_Ident_Start_K, Ns_Chr_Ident_Start.K => Boo_t

| Ns_Chr_Ident_Start_L, Ns._Chr_Ident_Start_L => Boo_t

| Ns_Chr_Ident_Start_M, Ns_Chr_Ident_Start_M => Boo_t

| Ns_Chr_Ident_Start_N, Ns.Chr_Ident_Start_N => Boo_t

| Ns_Chr_Ident_Start_O, Ns_Chr_Ident_Start.O => Boo_t

| Ns_Chr_Ident_Start_P, Ns_Chr_Ident_Start.P => Boo_t

| Ns_Chr_Ident_Start_Q, Ns_Chr_Ident_Start_Q => Boo_t

| Ns_Chr_Ident_Start_R, Ns Chr_Ident_Start_R => Boo_t

| Ns_Chr_Ident_Start_S, Ns_Chr_Ident_Start_S => Boo_t

| Ns Chr_Ident_Start_T, Ns Chr ldent Start T = Boo_t

| Ns_Chr_Ident_Start_U, Ns_Chr_Ident_Start_U => Boo_t

| Ns_Chr_Ident_Start_V, Ns_Chr_Ident_Start.V => Boo_t

| Ns_Chr_Ident_Start_W, Ns_Chr_Ident_Start.W => Boo_t

| Ns_Chr_Ident_Start_X, Ns_Chr_Ident_Start_X => Boo_t

| Ns_Chr_Ident_Start_Y, Ns_Chr_Ident_Start.Y => Boo_t

| Ns_Chr_Ident_Start_Z, Ns.Chr_Ident_Start.Z = Boo_t

| Ns_Chr_Ident_Start_circumflexAccent,

Ns_Chr_Ident_Start_circumflexAccent >

| Ns_Chr_Ident_Start_a, Ns_Chr_Ident_Start.a => Boo_t

| Ns_Chr_Ident_Start_b, Ns_Chr_Ident_Start_b > Boo_t

| Ns_Chr_Ident_Start_c, Ns_Chr_Ident_Start_c => Boo_t

| Ns_Chr_Ident_Start_d, Ns.Chr_Ident_Start.d => Boo_t

| Ns_Chr_Ident_Start_e, Ns_Chr_Ident_Start_e=> Boo_t

| Ns_Chr_Ident_Start_f, Ns.Chr_Ident_Start_f > Boo_t

| Ns_Chr_Ident_Start_g, Ns_Chr_Ident_Start_g = Boo_t

| Ns_Chr_Ident_Start_h, Ns_Chr_Ident_Start_h > Boo_t

| Ns_Chr_Ident_Start_i, Ns.Chr_Ident_Start_i=> Boo_t

| Ns_Chr_Ident_Start_j, Ns_Chr_Ident_Start_j => Boo_t

| Ns_Chr_Ident_Start_k, Ns_Chr_Ident_Start_k > Boo_t

| Ns_Chr_Ident_Start_l, Ns_Chr_Ident_Start_l1=> Boo_t

| Ns_Chr_Ident_Start_m, Ns_Chr_Ident_Start_m => Boo_t

| Ns_Chr_Ident_Start_n, Ns_Chr_Ident_Start_n => Boo_t

| Ns_Chr_Ident_Start_o, Ns_Chr_Ident_Start_o => Boo_t

| Ns_Chr_Ident_Start_p, Ns_Chr_Ident_Start_p = Boo_t

| Ns_Chr_Ident_Start_q, Ns_Chr_Ident_Start_q => Boo_t

| Ns_Chr_Ident_Start_r, Ns_Chr_Ident_Start_r => Boo_t

| Ns_Chr_Ident_Start_s, Ns_Chr_Ident_Start_s => Boo-_t

| Ns_Chr_Ident_Start_t, Ns_Chr_Ident_Start_t > Boo_t

| Ns_Chr_Ident_Start_u, Ns_Chr_Ident_Start_u=> Boo_t

| Ns_Chr_Ident_Start_v, Ns._Chr_Ident_Start_v => Boo_t

| Ns_Chr_Ident.Start_w, Ns_Chr_Ident_Start_w => Boo-_t

| Ns_Chr_Ident_Start_x, Ns_Chr_Ident_Start_x => Boo_t

| Ns_Chr_Ident_Start_y, Ns_Chr_Ident_Start_y > Boo_t

| Ns_Chr_Ident_Start_z, Ns_Chr_Ident.Start_z => Boo_t

| Ns_Chr_Ident_Start_verticalBar, Ns_Chr_Ident_Start_verticalBar >

): (Boo_Pred_Bin.Conn Ns_ Chr_ldent_Start).

A Numm Squared identifier continue character is exactly one of the following: ¢ a NummSquared identifier start character s® a NummSquared digit character

Note that a NummSquared identifier start character and a NummSquared digit character never have the same Unicode code point.

Inductive Ns_Chr_Ident.Cont : Type :| Ns_Chr_Ident.Cont_ident_start : (Op Ns_Chr_Ident_Start Ns_Chr_Ident_Cont)

| Ns_Chr_Ident_Cont_digit : (Op Ns_Chr_ Digit Ns_Chr_Ident_Cont).

(Ns_Chr_Ident_Cont_eq cic0 cic1) is the true Boolean if cicO and cic1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Chr_Ident_Cont_eq := ( fun cỉc0 cicl > match cic0, cicl return Boo with

| Ns_Chr_Ident_Cont_ident_start cis0,

Ns_Chr_Ident_Cont_ident_start cis1 =>

(Ns_Chr_Ident_Start_eg cis0 cis1)

| Ns_Chr_Ident_Cont_digit cd0, Ns_Chr_Ident_Cont_digit cdl >

(Ns_Chr_Digit.eq cd0 cal)

) : (Boo_Pred_Bin_Conn Ns_Chr_Ident_Cont).

A NummSquared comment is an efficient natural number list.

Definition Ns_Comment := Nat_Eff.Lis: Type.

(Ns Comment_eq comment0 commentl) is (Ns_ Eff Lis.eq comment0 comment). Definition Ns_Comment_eq := ( fun comment0 comment] >

(Nat_Eff_Lis_eq comment0 commentl) ): (Boo_Pred_Bin.Conn Ns_Comment).

A NummSquared simple identifier, referred to as "ids," consists of two main components: the initial character, which serves as the NummSquared identifier start character, and a subsequent sequence that includes a list of NummSquared identifier continuation characters.

Record Ns_Ident_Simp: Type := Ns ldentSimp_ctor {

Ns ldent Simp start: Ns_Chr_Ident_Start,

Ns_Ident_Simp_conts : (Lis Ns_Chr_Ident_Cont)

(Ns_Ident_Simp_eq idsO ids1) is the true Boolean if idsO and ids1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Ident_Simp_eq := ( fun idsO ids1 => if

(Ns_Chr_Ident_Start_eq

(Ns_Ident_Simp-start ids0)(Ns_Ident_Simp_start ids1)

Ns Chr Ident Cont Ns_Chr_Ident_Cont_eq (Ns_Ident_Simp-conts ids0) (Ns_Ident_Simp_conts ids1) ) else Boo_f

) : (Boo_Pred_Bin_Conn Ns_Ident_Simp).

A NummSquared identifier is a non-empty list of NummSquared simple identifiers. Definition Ns_ Ident := (Lis_Ne Ns_Ident_Simp).

(Ns_Ident_eq idO id1) is the true Boolean if id0 and id1 are structurally equal; and the false Boolean otherwise.

Definition Ns_Ident_eq := ( fun ¡d0 idl >

(Lis_Ne_rel_conn Ns_Ident_Simp Ns_Ident_Simp_eq ¡d0 idl) ) : (Boo_Pred_Bin_Conn Ns_Ident).

9.21.14 NUMMSQUARED SIMPLE IDENTIFIER TO NUMMSQUARED

(Ns_Ident_Simp_to_Ns_Ident ids) is the NummSquared identifier containing just ids. Definition Ns_Ident_Simp_to_Ns_Ident := ( fun ids >

(Lis_Ne_singleton Ns_Ident_Simp ids)

): (Op Ns_Ident_Simp Ns_ Ident).

A NummSquared natural number primitive is an efficient natural number.

Definition Ns_Prim_Nat := Nat_Eff : Type.

9.21.16 NUMMSQUARED NATURAL NUMBER PRIMITIVE EQUALS

(Ns Prim_Nat_eq m0 m1) is (Nat_ HÍƒ eq m0 m1).

Definition Ns_ Prim_Nat_eq:= ( fun m0 m1 >

): (Boo_Pred_Bin_Conn Ns_Prim_Nat).

A NummSquared character primitive is an efficient natural number.

Definition Ns_Prim_Chr := Nat_Eff : Type.

(Ns_Prim_Chr_eq m0 m1) is (Nat_Eff_eq m0 m1).

Definition Ns_Prim_Chr_eq:= ( fun m0 m1 >

): (Boo_Pred_Bin_Conn Ns_Prim_Chr).

A NummSquared string primitive is an efficient natural number list.

Definition Ns_Prim_Str := Nat_Eff_Lis: Type.

(Ns_Prim_Str_eq str0 sír1) is (Ns_Eff_Lis_eq stro strI).

Definition Ns_Prim_Str_eq := ( fun str0 str1 =>

(Nat_Eff_Lis_eq str0 str}) ): (Boo_Pred_Bin_Conn Ns_ Prim_ St).

A NummSquared primitive is exactly one of the following: e a NummSquared natural number primitive ¢ a NummSquared character primitive ¢ a NummSquared string primitive

Inductive Ns_ Prim: Type :| Ns_Prim_nat : (Op Ns_Prim_Nat Ns_Prim)

| Ns_Prim_chr : (Op Ns_Prim_Chr Ns_ Prim)

| Ns_Prim_str : (Op Ns_Prim_Str Ns_ Prim).

(Ns_Prim_eq prim0 prim1) is the true Boolean if prim0 and prim] are structurally equal (except using Nat_Eff_eq); and the false Boolean otherwise.

Definition Ns_Prim_eq := ( fun prim0 prim1 > match primo, prim1 return Boo with

| Ns_Prim_nat m0, Ns_Prim_nat m1 => (Ns_Prim_Nat_eq m0 m1

| Ns_Prim_chr m0, Ns_Prim_chr m1 => (Ns_ Prim_Chr_eq m0 mI)

| Ns_Prim_str str0, Ns_Prim_str str1 => (Ns_Prim_Str_eq str0 str])

): (Boo_ Pred_Bim_ Conn Ns_ Prim).

A NummSquared computational normalized constant is exactly one of the following: ¢ the identity NummSquared computational normalized constant ¢ the null NummSquared computational normalized constant

The NummSquared computational normalized constants include the zero constant, one constant, null set constant, nuro set constant, leaf set constant, tree set constant, and domain constant.

* the null predicate NummSquared computational normalized constant ¢ the pair predicate NummSquared computational normalized constant

Inductive Ns_Constant.Norm_Compu: Type :| Ns_ Constant_ Norm_ Compu_¡: Ns.Constant.Norm_Compu

| Ns_Constant_Norm_Compu_null: Ns.Constant_Norm_Compu

| Ns_Constant.Norm_Compu_zero: Ns_Constant_Norm_Compu

| Ns_Constant_Norm_Compu_one : Ns_Constant_Norm_Compu

| Ns_Constant_Norm_Compu_Null_set : Ns Constant Norm_Compu

| Ns_Constant_Norm_Compu_Nuro_set : Ns Constant Norm_Compu

| Ns_Constant Norm_Compu_Leaf_set : Ns.Constant_Norm_Compu

| Ns_Constant_Norm_Compu_Tree_set : Ns_Constant_Norm_.Compu

| Ns_Constant_Norm_Compu_dom: Ns_Constant_Norm_Compu

| Ns_Constant.Norm.Compu_Null: Ns_Constant.Norm_Compu

| Ns_Constant_Norm_Compu_Pair: Ns Constant Norm_Compu.

A NummSquared non-computational normalized constant is exactly one of the following: ¢ the equals NummSquared non-computational normalized constant

Inductive Ns_Constant_Norm_Noncompu: Type :| Ns_Constant_Norm_Noncompu_ns_eq: Ns_-Constant_Norm_Noncompu.

A NummSquared normalized constant is exactly one of the following: ¢ a NummSquared computational normalized constant ¢ a NummSquared non-computational normalized constant

Inductive Ns_Constant_Norm: Type :| Ns_Constant_Norm_compu: (Op Ns_Constant_Norm.Compu Ns_Constant_ Norm)

(Op Ns_Constant_Norm_Noncompu Ns_Constant_Norm).

The NummSquared computational non-normalized constant can be classified into several specific categories: the left and right NummSquared constants, the confirmation and negation with null constants, the null to zero and zero predicate constants, the one predicate constant, the nuro predicate constant, the leaf predicate constant, the simple predicate constant, and the rule predicate constant Each of these constants plays a distinct role in the framework of NummSquared computations.

* the tree predicate step pair unguarded NummSquared computational non- normalized constant

The NummSquared computational non-normalized constant encompasses various results, including the tree predicate and non-empty domain, both of which remain unguarded Additionally, it addresses the nuro set and tree set results, as well as the dependent sum results, which are categorized into left unguarded, right unguarded, and overall unguarded constants Furthermore, the dependent product result is also highlighted as uncurry unguarded, emphasizing the significance of the NummSquared constant in computational contexts.

The dependent product results in the NummSquared computational non-normalized constant, which includes both the unguarded and negated forms Additionally, the implications associated with the null and standard NummSquared computational non-normalized constants are also significant.