Skip to content

Instantly share code, notes, and snippets.

@michaeljklein
Created October 21, 2017 05:49
Show Gist options
  • Save michaeljklein/f455ecaefa24b7e9f149e1a5f2944d25 to your computer and use it in GitHub Desktop.
Save michaeljklein/f455ecaefa24b7e9f149e1a5f2944d25 to your computer and use it in GitHub Desktop.
  • Mindfulness meditation is one of the best ways I know to live faster without dying faster
  • Tell a man to not be lazy, and his spirit may only hear "work hard". Tell a man to work hard and his spirit may learn to not be lazy.
@michaeljklein
Copy link
Author

The above section(s) may be interpreted as a digraph, where vertices are definitions and arcs are dependent relations.
This digraph is isomorphic to the:

  • 1-hypercube
  • 2-hypercube
  • 3-hypercube
  • 4-hypercube

The chapters each provide a

  • parallel in dependency:

    • finite set of names (category)
    • explicitly as section dependency (partial-ord),
    • literally as expressions in the Flock language (total-ord),
    • in combinatoric/statistical-thermodynamic expressions (natural)
  • serialized:

    • categorically(names),
    • durationally(poset),
    • literally(expressions),
    • numerically(numbered)
      traversal of all of the sub-hypercubes of the 4-hypercube.

The directed 4-hypercube is minimally 3-(edge)-connected, (removing any edge results in a 2-(edge)-connected graph?)

Each n-hypercube defines a n-dimensional language space,

  • where each dimension is fixed by choice of n-hypercube,
  • along with explicit requirements (including "prior" steps in the traversal).
    The resulting space has explicit expressions, types, evaluation requirements/bounds, etc.
  • These may be used to translate abstract results into spaces, and spaces into implementations.
  • This paper is intended to provide all of the translations for the hypercube into the specified languages.
  • Since the model provides explicit requirements for complete implementation (which is finite, decidable, computable), and is also capable of implementing/evaluating/type-checking/etc dependent implementations of the model within itself, the resulting 4-hypercube (language), Flock, has all of these properties.

Thus the definitions trivially form a finite boolean algebra.

Every Boolean algebra (A, ∧, ∨) gives rise to a ring (A, +, ·) by defining a + b := (a ∧ ¬b) ∨ (b ∧ ¬a) = (a ∨ b) ∧ ¬(a ∧ b) (this operation is called symmetric difference in the case of sets and XOR in the case of logic) and a · b := a ∧ b. The zero element of this ring coincides with the 0 of the Boolean algebra; the multiplicative identity element of the ring is the 1 of the Boolean algebra. This ring has the property that a · a = a for all a in A; rings with this property are called Boolean rings.

Conversely, if a Boolean ring A is given, we can turn it into a Boolean algebra by defining x ∨ y := x + y + (x · y) and x ∧ y := x · y. [5][6] Since these two constructions are inverses of each other, we can say that every Boolean ring arises from a Boolean algebra, and vice versa. Furthermore, a map f : A → B is a homomorphism of Boolean algebras if and only if it is a homomorphism of Boolean rings. The categories of Boolean rings and Boolean algebras are equivalent.[7]


Hsiang (1985) gave a rule-based algorithm to check whether two arbitrary expressions denote the same value in every Boolean ring.
More generally, Boudet, Jouannaud, and Schmidt-Schauß (1989) gave an algorithm to solve equations between arbitrary Boolean-ring expressions.

=> https://en.wikipedia.org/wiki/Boolean_ring

In mathematics, a Boolean ring R is a ring for which x^2 = x for all x in R, such as the ring of integers modulo 2. That is, R consists only of idempotent elements.

Furthermore, location in the cube is unique, and may be encoded using just:

  • 2^(2^1) = 2^2 = 4 bits for 1 point
  • 2^(2^2) = 2^4 = 16 bits for 0..1 arcs, 1 path, 2 points
  • 2^(2^3) = 2^8 = 32 bits for 0..1 squares, 1 arc, 2 paths, 4 points
  • 2^(2^4) = 2^16 = 64 bits for 0..1 cubes, 1 square, 2 arcs, 4 paths, 8 points
  • 2^(2^5) = 2^32 = 128 bits for 0..1 4-hypercubes, 1 cube, 2 squares, 4 arcs, 8 paths, 16 points
  • 2^(2^6) = 2^64 = 256 bits for 0..1 5-hypercubes, 1 hypercube, 2 cubes, 4 squares, 8 arcs, 16 paths, 32 points
  • 2^(2^(n+1)) bits for 0..1 n-hypercubes, 2^i (n-(i+1))-hypercubes. (n+1) points, n paths

The paper is organized to be a map of this language, with the chapters/sections/etc forming the nodes, which branch in parallel (independently) to sections, etc.

The tesseract, along with all hypercubes, tessellates Euclidean space

@michaeljklein
Copy link
Author

Flock is a 4-dimensional abstraction 😄

https://www.oreilly.com/learning/engineering-incremental-change?cmp=tw-prog-books-videos-article-lgen_evolutionary_architectures_chapter_jj

Software architects have to determine how systems fit together, often by creating diagrams, with varying degrees of ceremony.
Architects often fall into the trap of seeing software architecture as an equation they must solve.

This "trap" is over-constraining the architecture space: once you're at the equation level, you're already inside a strict model.
In other words, you're no longer strictly working on architecture.

Much of the commercial tooling sold to software architects reinforces the mathematical illusion of certainty with boxes, lines, and arrows.
While useful, these diagrams offer a 2D view—a snapshot of an ideal world—but we live in a 4D world.
To flesh out that 2D diagram, we must add specifics.

Exactly what I'm doing with Flock: 0D (characters) -> 1D (sentences) -> 2D (diagrams) -> 3D (models) -> 4D (Flock)

The ORM label Figure 1-4 becomes JDBC 2.1, evolving into a 3D view of the world, where architects prove their designs in a real production environment using real software.
As Figure 1-4 illustrates, over time, changes in business and technology require architects to adopt a 4D view of architecture, making evolution a first-class concern.

Which Flock addresses directly. It provides a toolkit for evolving it which includes explicit, strict, complete, parametrized, and modular requirements.

You can solve architecture problems in Flock by solving equations! Because the equations completely encapsulate the language!

When we know how to put architecture into production and upgrade it to incorporate inevitable changes
(security patches, new versions of software, evolutions of the architecture, and so on)
as needed, we’ve graduated to a 4D world.

"You think 4-D is your ally. You've merely adapted the dimensions. Flock was born in them, molded by them."

@michaeljklein
Copy link
Author

michaeljklein commented Oct 24, 2017

To stay within the model, there must be 4 distinct points in a line.
We also add introduction and conclusion

0 Introduction
0 1:     2,              3,                  4,                           5
1 Cat: Category, Categorical, 
2 Dur: Duration, Durational, 
3 Lit: Literal, Literal, 
4 Nat: Natural, natural, 
5 Conclusion
0 1:     2,              3,                  4,                           5
Being good is difficult, so I break it down into six steps:
0: Find what's good
1: Be good to yourself
2: Be good to individuals
3: Be good to relationships
4: Be good to families
5: Be good to systems

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment