notes.txt

PUBLIC NOTES
------------

Due to problems with running the OpenPGP Encryption extension in VS Code. 
  Install gnupg2 via .vscode/launch.json
  Created ./notes_decrpyt.sh to decrypt notes.gpg.md

Each scene has dependecies and can link to a number of thoer concepts. Could allow the user to make that choice. Can also highlight scenes that have alreday been observed.

Prompt: This storyboard is in development. Align the style of "Scene: "  with the precedent scenes. I will be adding further scenes later. Focus on explaining the conceptual mapping from the visual scene to the objective of the scene, rather than describing the visual itself. Maintain the order of the sections in the scene description. 

Wrap the final animation in an App that allows pausing the presentation and discussing with an LLM
How to animate complexity ? 
  A state machine
  A particle could go through 1st plane, through 2nd plane, loop back through 1st plane and modify structure of second plane. 
    This is cpef. clef is where the 2nd plane modifies the 1st plane.
  A particle could go through 1st plane, rebound from 2nd plane and integrate into 1st plane
  Anticipation
    One cluster that maintains a model of another cluster that it can speed up and use for prediction
      Then intervene so a particular outcome occurs
        Basic predict + act sequence
          If the system being predicted is simple then it will continue to be accurate
            Just keep the prediction x steps ahead of actual
              Maybe we just have a delayed copy to simulate this
  Intelligence
    Learning to adapt to changes in the system - requires monitoring for changes
      Could build a second model that learns about changes in dynamics
      A "black blob" that provides the "common sense" of how to update the model

Family resemblances of process-centric philosophies
  Primacy of Change and Becoming
    Balance with the importance of scale
  Relationality and Interconnectedness
    Balance with notion of autonomy
  Temporal and Evolutionary Perspective
    Balance with the present moment
  Creativity and Emergence
    Balance with tradition and structure
  Holistic and Non-Reductionist Approach
    Balance with the applicability of reductionism
  Emphasis on Experience and Perception
    Balance with notion of non-subjective and unconscious ?
  Dynamic Ontology
    Balance with the value of shared meaning
  Contextuality
    Balance with the degree of stable/shared context

Consciousness allows for the correlation of qualia which is a causal role. If qualia cause illusions then there is an undeniable causal role.

https://blog.maximeheckel.com/posts/the-study-of-shaders-with-react-three-fiber/ see 3D blob for shader example 

Does it make sense to have relations at the level of compoundEntities - these are abstractions (maybe a different form e.g. dotted line)

Spent $350 as of 4/8/2024

Instead of entity it may be better to refer to communities (as per Whitehead) (no an entity it a community)

WDS_SOCKET_PORT=0 only in CodeSpace ?
The AnimationMixer in Three.js provides a robust and flexible way to handle animations
Entity-Component-System (ECS) is an architectural pattern often used in game development. Entity: A unique identifier representing an object. Component: Holds data attributes for an entity (e.g., position, velocity). System: Contains logic to process entities with specific components (e.g., movement, rendering).

Example of calling a Physics function through animation controller:
[1, 'emergent1.Sphere1', { action: { name: 'applyImpulse', params: [{ x: 10, y: 5, z: 0 }] } }],

Below a certain scale joints could become fixed and merge into a single collider (capsule) the intermediate joints can be ignored
Why can joints have large gaps appear due to forces

The entities form a new internal boundary as well as an external boundary. The internal boundary if "sheltered" from direct external influecne

Top-down -> outside-in
Bottom-up -> inside-out

Equate complex systems with learning systems

A distributed process - patterns of events (is that a final cause?) A notion of a distributed cause.

Process produce material change e.g a document materializes a history of process.

A relation is in one direction - in many cases there are two relations between two entities
Before an entity can establish a relation there must be an interaction that enables the possibility
Prior to each relation being established there is a history that establishes the "potential relation"

Process can give rise to new entities

Migration - randomly choose the destination, like relations. Detach inward or outward.

Introducing the concept of "meta" - attending to the dynamics of the system while interacting with it. Process can be seen as an abstraction in time. Essentialism tends to function in an all encompassing now. Concepts of meta (as emergent level? as self-referencing ?) and perspective

Need to be able to slow down the simulation, easily, to see what is going on with migration etc. Add a speed config.

Process = sequence of relations that repeat (locally, abstractly, metaphorically..)

Entities that transit other entities e.g. allowing for material causation

Use opacity for blobs 

As a blob expands we could hide the relations that were going to/from it

Could automate lastCompoundEntity in storeEntity

isParticle could maintain a particle array rather than using isParticle

Because CompoundEntity can become Particle we do not know when we have the full tree ready.

chainRef should be a distinct entry ?

Creating a node for each particle creates dealys for the mounting of the React components, so we do not mount the lowest level as a CompoundEntity.

Eventually a CompoundEntity could become a Particle or vice-verca. In this case we would need to copy the properties ?

-------------------------------
A ref that causes a rerender:
const [ref, setRef] = useState(null);

useEffect(() => {
  if (ref) {
    // do the thing
  }
}, [ref]);

<RigidBody ref={setRef}>
-------------------------------

https://blog.maximeheckel.com/posts/the-magical-world-of-particles-with-react-three-fiber-and-shaders/

Emergent substrate - processing particles to form entities in another dimension e.g. processor constructs objects/relations. Particle can traverse the "plane" and form objects - no it is the plan that traverses the particles back-and-forth. A bit like Turing machine. Stream of particles could generate objects. Impredicative if the planes are arranged into a loop - this could be end-to-end trained ? Can insert LLM and fine-tune

Facilitate staged development independent of the user's framework