However, The whole is often greater than the sum of its parts, and the attempt to understand complex systems through reductionism neglects the interactions, emergent behaviors, and non-linear dynamics within the system.

In neuroscience and artificial intelligence, attempting to understand consciousness through the examination of individual neurons can't answer how consciousness emerge from those simple parts, as well as trying to create intelligence by connect neurons in a predefined way, whatsoever it's convolutional, hierarchical or recurrent. Similarly, In ecology, reducing an ecosystem to its individual species is unable to explain the stability,resilience and at the same time, the fragility of ecosystem.

Aside from those complicated systems, simple deterministic system may show unpredictable behaviors. In this article, I will introduce the concept of dynamical systems and show some of those systems described with simple mathematical formula.

In this part 1 note, basic concepts of dynamical systems like phase space, trajectory, bifurcation, Feigenbaum constant will be introduced, and we mostly focus on examples.
Advanced concepts like chaos, renormalization, self-organization will be discussed in the next part, as well as the mathematical tools.

Define Chaos

For a particular mathematical formula or computation process(like calculate the trajectory of three body system, predict weather ,etc), a slightly different initial condition, or input, would result in very different result.

What does this sensitivity implies? For an computation process to be useful, we usually expect to get similar result for similar input, otherwise the output is not meaningful since a small rounding error will invalidate the result.

sensitivity to initial condition

To display the essence of chaotic behavior, we start from simple deterministic mathematics formulas.

Example: a slightly different initial condition would result in a vastly different trajectory

Example: Three 2 node system with slightly different initial condition:

Example: logistic map

Example: Three-body problem

Example: Biosphere II was a expensive failure to create a self-sustaining replica of Earth ecosystems.

Example

while we are sure about our location in the short run, we can not say precisely where we are at a specific date in the long run, for example in a year.

Describe and analyze Chaos: dynamical systems theory

Although we can't calculate chaotic system in the usual way, there are some new tools that will shed some light.

bifurcation diagram

for the logistic map example we just discussed, this diagram plots the stabilized x value versus the parameter R:

As the parameter R increase at 3.0, X have more possible values.

phase space

In dynamical systems theory and control theory, a phase space or state space is a space to display all possible "states"(positions), in contrast to the trajectory(position at specific time t) of the system.

Example: https://verzep.github.io/Learning-Lorenz/

In space (x,y,z) - time

In phase space (x,y,z):

Feigenbaum constant:

The constant represents the ratio of the difference in parameter values at which successive bifurcations occur as a system undergoes a period-doubling route to chaos. It has an approximate value of 4.6692.

TBD

AI and the failed prediction of Chaos

TBD
Lorenz System https://verzep.github.io/Learning-Lorenz/

Reference:

https://en.wikipedia.org/wiki/Three-body_problem

Complexity: A Guided Tour , by Melanie Mitchell

https://en.wikipedia.org/wiki/Chaos_theory

lorenz equation: https://www.math.fsu.edu/~bertram/lectures/Chaos.pdf

https://verzep.github.io/Learning-Lorenz/

https://gereshes.com/2018/11/19/chaos-and-the-double-pendulum/

QA:

I presented this in a meeting and got some good questions:

Are chaotic systems calculable?

yes, if you have extremely accuracy of the initial condition. There're two way to address this: 1. we continue to quest for higher precision. 2. we accept this difficulty and give up for precise prediction/computation

In addition, someone mentioned Kolmogorov–Arnold–Moser about the persistence of quasiperiodic motions under small perturbations, which can be seen as a special case when computation is desirable.

Visually, the first half of The Matrix Resurrections presents a dystopia dominated by corporate power and consumerism, raising questions about the nature of reality, identity, and liberation from capitalist systems. Those scenes where Neo work as game designers provoke me deeply and shows directly how capitalism is able to internalize and commodify everything you can think of, like natural resources, holidays and Valentine's day. Free resources like clean water and air are more like luxuries now since PFAS and exhaust from cars are everywhere.

Not unexpectedly, The director Lilly Wachowski Claims The Matrix series was Born Out Of “Rage At Capitalism”. Neo now works as a game designer for a top game company, MetaCortex.
It's always hard to get up in the morning everyday:

Looks like your dream office?

Despite his extraordinary capabilities in his professional career, Neo finds himself trapped in mundane routine, making him mentally sick, thus seeking help from the psychology consultant "The Analyst " which we will talk about in the next part.

The conversations among Neo's colleagues about the latest Matrix game represent the commodification of creativity and the reduction of art to a mere product for consumption. Instead of engaging in meaningful discussions about the philosophical or artistic implications of their work, they focus on market trends, sales figures, and competition, reflecting the prioritization of profit over genuine artistic expression.

The scenes where Neo and his colleagues play leisure games in the office highlight the superficial distractions that capitalism offers to workers as a means of pacifying them and preventing deeper introspection or dissatisfaction. These escapism allows employees to momentarily forget the monotony of their work while reinforcing the status quo that you are still working. I still remember those pictures of dream office in Google:

The archaic luxury hand pressed coffee machine depicts the ubiquitous presence of coffee in the workplace, symbolizes the reliance on stimulants and comforts to cope with the demands of productivity. Trying to build an artistic feeling by combining caffeine and red bricks?

Coffee breaks, though ostensibly a moment of respite, ultimately serve to perpetuate the cycle of consumption and production, reinforcing the expectation of constant productivity and the normalization of overwork.

The scenes depicting Neo and his boss enjoying the view from skyscrapers underscore the illusion of success and prosperity perpetuated by capitalism. The impressive skyline and luxurious corporate offices create an illusion of achievement and progress, masking the underlying exploitation and inequality inherent in the system. The view serves as a distraction from the harsh realities of capitalism, perpetuating the myth of upward mobility, meritocracy.

"The Matrix Resurrections" illustrate how capitalism commodifies non tradable experiences, offering pleasures to maintain control and prevent individuals from questioning the underlying structures of power and exploitation. Despite moments of fleeting joy, the characters remain trapped in a cycle of banality, unable to awake from the capitalist system.

For now at least, we can stop buying non stick pans(I prefer ceramic pans), waterproof cloths made with Teflon(due to PFAS), and put priority of environmentalism over consumerism. Maybe also growing some vegetables at home?

As said in Wikipedia, it can be considered as a form of partial evaluation that performs computations at compile-time.To make more analogies, it's also similar to the scenario for embedded DSL, where full access to the AST is given and any transformations are possible.

Mostly based on the official guide at https://docs.scala-lang.org/scala3/guides/macros/index.html , I will divide the topic into several parts and focus on theories than giving examples, while also referencing other languages:

• conversion between code and data(AST)

• operations on AST (AST for type or terms)

• get information from the child node of an AST

• organize code and modularity

Clarifying terminologies

• code: the runnable code as it is.

• data and AST: we treat the code as data structure. It's usually a tree so we call it AST(abstract syntax tree). Quoted code is a shorthand for manually written AST.

• conversion between code and data: usually called

  • quote : transform code to data

  • splice (or eval) : evaluate data as code

conversion between code and data

Dynamic languages like Lisp(quoted code) and javascript(tostring,eval) make it easy to toggle code and data. In Scala it's different since macros are also statically typed.

The data is called quoted code '{ ... } (like string "") and the process of converting data back to code is called splice ${ ... }(like ${} inside string). To insert AST(Expr[T]) into quoted code '{ ... }, we can use the syntax $expr or ${ expr }

import scala.quoted.* // imports Quotes, Expr

def inspectImpl(x: Expr[Any])(using Quotes): Expr[Any] =
  println(x.show)
  x
inline def inspect(inline x: Any): Any = ${ inspectImpl('x) }

inspectImpl goes from AST to AST as a normal Scala function, while inline def inspect has more magic, converting code into AST and invoking inspectImpl.

using Quotes contains extra info about Expr[_]. Depending on the desired manipulations for AST(called Expr[_] here), other APIs like using Type[T] can also be added like below:

def getTyped[T](x: Expr[T])(using Type[T], Quotes): Expr[T]

The Expr.value, Expr.valueOrAbort, and Expr.unapply methods turns the AST Expr to the value(code) if possible.

Idris Elaborator Reflection:

In Idris, a dependently typed language, the directive %runElab takes data and turn it into code. The monadic do block of type Elab a construct the AST:

idNat : Nat -> Nat
idNat = %runElab (do intro `{{x}}
                     fill (Var `{{x}})
                     solve)

for more details visit https://docs.idris-lang.org/en/latest/elaboratorReflection/elaborator-reflection.html#elaborator-reflection

Operations on AST

Expr[t] and Term

Expr[T] can be seen as wrappers around a Term for expressions, where T is the statically-known type of the term. Below, we use the extension method asTerm to transform an expression into a term

Type and TypeRepr

access type for term : t.Underlying

def evalAndUse[T](x: Expr[T])(using t: Type[T])(using Quotes) = '{
  val x2: t.Underlying = $x // eval AST Expr[T] into x2:T
}

Similarly, we can also see Type[T] as a wrapper over TypeRepr.

def f(x: Expr[Int])(using Quotes): Expr[Int] =
  import quotes.reflect.*
  val tree: Term = x.asTerm

def g[T: Type](using Quotes) =
  import quotes.reflect.*
  val tpe: TypeRepr = TypeRepr.of[T]

Both Terms and TypeReprs (and therefore Exprs and Types) have an associated symbol, the underlying untyped AST,exposing similar api as java's reflection:

• declaredFields and declaredMethods : fields ,members and methods inside a class def

• flags allows you to check multiple properties of a symbol

• companionClass and companionModule jump to and from the companion object/class

• TypeRepr.baseClasses list of symbols of classes extended by a type, like sealed trait.

• Symbol.pos the position where the symbol is defined, the source code of the definition, the filename where the symbol is defined,etc

get extra info from AST child node

sometimes we want to get the type of member of a class:

boxTpe.memberType(leafSym)

here we need the parent type boxTpe for a child symbol leafSym.

More details at https://docs.scala-lang.org/scala3/guides/macros/best-practices.html

Organize code

While working on the AST data structure, the heavy use of path dependent types for type safety adds extra complexity, so more care is needed when referring to types of the AST:

def getDecls(using Quotes)(rootType: quotes.reflect.TypeRepr) = {
    import quotes.reflect.*
    val typeSybs: Symbol = rootType.typeSymbol
    val decl: List[Symbol] = typeSybs.declarations
  }

quotes here is not an object, but a method with implicit parameter that can be used in import, which is a huge jump from Scala 2:

transparent inline def quotes(using inline q: Quotes): q.type = q

for keywords inline and transparent, check https://docs.scala-lang.org/scala3/guides/macros/inline.html

If you want to avoid this fancy inline transparent thing:

  def getDecls(using q: Quotes)(rootType: q.reflect.TypeRepr) = {}

conclusion

In this guide, I provide a more theoretical perspective compared to the official guide while covering less material. Although Scala 3 macros are no longer experimental, it's still a research area and thus under-documented. When combining the new dependent typing, the interaction is nontrivial. In addition, an open problem is: to what extent can we achieve full dependent types with macros?

I recommend the resources below while I'm also trying to understand more about macros :

https://github.com/nicolasstucki/

https://martinfriedrichberger.net/ecoop17.html

metals is the new Scala IDE with supreme support of Scala 3. Killer Features include worksheet :

that eval code on the air instantly . In my opinion, this way of combining the Haskell REPL and python's jupyter notebook is taking functional programming to the next level of productivity!

Another surprise is that running code like below:

takes only 1s thanks to the incremental compilation, which means it's even more convenient than writing scripts!

However, I find a small annoying thing: when expanding selections in comments, it's too wide so the whole file will be selected:https://github.com/scalameta/metals/issues/3615#issuecomment-1031257600,because the presentation compiler ignores comments.

Into the metals code

It's a bit complicated to navigate the metals codebase,but thanks to the help from active metals developer Tomasz Godzik I learned the whole process of testing metals.

testing

run test with sbt

It's convenient to test in sbt first. For my case, the relevant file for selection expansion is "SelectionRangeProvider" in subproject "cross", and the command corresponding test is in "cross/testOnly tests.pc.SelectionRangeSuite"(note the cross prefix! otherwise there'll be lots of errors). We can use println or pprint.log for debugging,which will also write in the metals.log file in .metals folder under project directory when going through manual test later.

manual test in vscode

After the initial success, It's time to test in the real world!

First, if you didn't change mtags project, then publishLocal is enough. otherwise if you changed mtags(here I only added this feature in for Scala 3 ) :

publishLocal;++3.2.1 mtags/publishLocal

"++3.2.1 mtags/publishLocal" is important, otherwise it will take long time to publish for all versions (and also generate lots of errors.. ).

Then, change the user config json in vscode(look for the publish version in previous steps ):

"metals.serverVersion": "0.11.13-SNAPSHOT"

Lastly, restart server in vscode command palette, and wait for metals to reload and check the metals.log .

misc

I recommend the below resources to get started:

https://www.chris-kipp.io/blog/an-intro-to-the-scala-presentation-compiler

https://github.com/scalameta/metals/blob/main/architecture.md

https://scalameta.org/metals/docs/contributors/getting-started

For those who are curious about where's the metals binary, here's the answer from https://github.com/scalameta/metals/issues/4920:

 there is no binary location or anything. It simply puts together the necessary Metals classpath and runs it uses coursier.