update

Author: github-actions[bot]

2023/10/30/pgvector

@@ -0,0 +1,8 @@
+
+self as a quotient space of the universe.
+Self S/~ (universe U)
+
+Self/~ as a filter function of the universe. 
+
+quasi-quotation as a quasi - quotient as quasi-poly-morphism with different labeled factors, roots or indivisible parts which are a parameterized
+to construct an object

2024/02/11/donjon

@@ -0,0 +1,60 @@
+artificial superintelligence
+ai agents
+hyperon netamoto
+filecoin
+frameworks
+methods
+agi term
+research papers
+probablistic logical networks
+neurosymbolic ai
+
+* giza
+decentralized infrastucture
+defi
+zkml models
+decisions
+risk
+market conditions
+trades
+yields
+
+trust assumptions
+verifiability
+ai agents
+proof of reputation
+attestations
+
+mpc multi party computation
+deploy ml models and zkapps
+apps like rendering, ml
+scalable, because you dont need to replicate computation with zkml
+hide some of the data.
+scaling.
+submodules.
+privacy.
+verification.
+
+Fran Algaba, 13:42
+
+Sebastian Rod
+trust triangle
+agent may say things about itself, yourself,
+someone else says something about you,
+digital trust, organization, other users.
+Identifiable agent.
+ai ml applications will need attestations, on chain , zkp, reputation base on agents
+agents need to identify themselves. stable agent. give agent identifier.
+only for that agent.
+
+maintain a proof or trust over time.
+show me your id. verify id.
+chain of assumptions or trust.
+did the model change, training data.
+
+context:
+landscape of decentralized ai.
+what is zkml.
+
+alex balgirev.
+hosting the model on the nodes.

2024/09/06/vscode

@@ -0,0 +1,18 @@
+plan:
+dont write new code:
+search for open source (on github and in a local cache) projects to integrate
+read and understand them,
+index them, maybe vectorize them.
+Assume that all data can be expressed in a lisp like syntax.
+We assume that the prelude of the system looks something like this :
+Evaluate and learn from the world around you from the following input:
+Create an interactive typescript code that can generate and eval code
+and produce structured errors, like an lsp feedback system.
+so now we can generate valid syntax. we can see that the semantics
+are in tests or proofs.
+We can demonstrate the code is correct as a formal proof even.
+so we want to generate a proof and code to execute that proves it. a self carrying proof.
+we can imagine it as a type schema like (share(model(learn(introspect(act(decide(orient(observe(input x)))))))))
+
+
+

2024/09/10/octokit.js

@@ -0,0 +1,55 @@
+*** Intermediate Meta-Languages (IMMLs)
+
+*Intermediate Meta-Languages (IMMLs)* are languages that bridge the gap between high-level,
+ declarative programming languages and low-level, executable code. They offer a higher level of
+ abstraction than traditional intermediate languages like LLVM IR or bytecode but still remain
+ closer to the target execution environment than fully abstract meta-languages.
+
+*** Research Existing Meta-Languages
+
+1. *PPL (Programmable Programming Language)*:
+   - *Overview*: PPL is designed to enable programmers to write programs that can be executed and
+      modified dynamically.
+   - *Proximity to Executable Code*: PPL is closer to executable code than fully abstract languages
+      because it allows for direct manipulation of the program's execution state. However, it is
+      still a higher-level language compared to low-level IRs.
+   
+2. *APL (Array Processing Language)*:
+   - *Overview*: APL was designed for mathematical and logical array processing and is known for its
+      unique syntax and high-level nature.
+   - *Proximity to Executable Code*: APL is more abstract than fully executable languages but still
+      operates on arrays, which are a common data structure in many programs. It can be compiled
+      into low-level code but is not as direct as PPL or MetaOCaml.
+
+3. *MetaOCaml (a dialect of OCaml)*:
+   - *Overview*: MetaOCaml allows for the creation of programs that manipulate other programs as
+      data. It extends OCaml with features such as quotation, splicing, and first-class
+      continuations.
+   - *Proximity to Executable Code*: MetaOCaml is closer to executable code than fully abstract
+      languages because it enables dynamic manipulation of program structures. However, it is still
+      a higher-level language compared to low-level IRs.
+
+*** Determining IMMLs
+
+Based on the research, the following languages can serve as Intermediate Meta-Languages (IMMLs):
+
+1. *MetaOCaml*:
+   - *Reason*: MetaOCaml extends OCaml with powerful features for manipulating programs as data,
+      making it closer to executable code than fully abstract languages while still offering a
+      higher level of abstraction compared to traditional intermediate languages.
+
+2. *PPL*:
+   - *Reason*: PPL allows dynamic manipulation of the program's execution state, making it suitable
+      for creating IMMLs that are both powerful and close to executable code.
+
+3. *APL*:
+   - *Reason*: While more abstract than fully executable languages, APL operates on arrays, a common
+      data structure in many programs, and can be compiled into low-level code. It provides a high
+      level of abstraction but remains closer to executable code than other fully abstract
+      languages.
+
+*** Conclusion
+
+MetaOCaml is particularly well-suited for creating Intermediate Meta-Languages due to its ability to
+manipulate program structures dynamically. However, PPL and APL also have their merits in serving as
+IMMLs based on their proximity to executable code and the specific needs of the application domain.

2024/10/16/next-mdx-deck-o1js-perf

@@ -0,0 +1,123 @@
+The detailed step-by-step plan you've outlined is an excellent framework for systematically proving
+a goal using multiple iterative rewrites and various languages. Here's how it breaks down:
+
+*** 1. Define Intermediate Meta-Languages (IMMLs)
+*Task:* Identify and define the intermediate meta-languages that are closer to executable code than
+ the original document.
+- *Language:* Python, Haskell, OCaml
+- *Steps:*
+  - Research existing meta-languages such as PPL (Programmable Programming Language), APL (Array
+    Processing Language), or MetaOCaml (a dialect of OCaml).
+  - Determine which languages can serve as IMMLs based on their proximity to executable code.
+
+*** 2. Rewrite the Document Using Different LLMs
+*Task:* Write a script that feeds the document to different LLMs and increments the stack for each
+ iteration, resulting in new versions of the document in each IMML.
+- *Language:* Python with ~llama~
+- *Steps:*
+  - Implement a loop to iterate N times.
+  - In each iteration, use a different LLM (e.g., OpenAI's GPT-3, Hugging Face's Transformers) to
+    rewrite the document.
+  - Increment the stack by appending new layers or annotations.
+
+*** 3. Use Coq and MetaCoQ to Prove Properties
+*Task:* Apply formal verification techniques using Coq and MetaCoQ to prove properties of each
+ version and their relations to previous ones.
+- *Language:* Coq, Haskell, OCaml
+- *Steps:*
+  - Write Coq theories for each intermediate version.
+  - Extract proofs into Haskell and OCaml code.
+  - Use quickcheck to validate the properties.
+
+*** 4. Compile and Lift Code Using Template Haskell and Ppx
+*Task:* Use Template Haskell and OCaml Ppx to compile and lift the latest version of the document
+ into executable code in CakeML or a similar language.
+- *Language:* Template Haskell, OCaml Ppx, CakeML
+- *Steps:*
+  - Write Template Haskell code to generate CakeML syntax.
+  - Use OCaml Ppx to optimize and annotate the code.
+  - Compile the code using CakeML compiler.
+
+*** 5. Test the Compiled Code
+*Task:* Automate testing of the compiled code using quickcheck and other tools, ensuring correctness
+ and functional equivalence to the original document.
+- *Language:* Python with ~quickcheck~
+- *Steps:*
+  - Write test cases that validate the functionality of the compiled code.
+  - Run tests in an automated environment.
+
+*** 6. Load Hex Codes into MES Hex Loader
+*Task:* Load the hex codes generated from the compiled CakeML into the mes hex loader as an
+ assembler and execute them, same for wasm and even llvm.
+- *Language:* Bash, Mes, GCC, LLVM
+- *Steps:*
+  - Convert the hex codes to a format suitable for mes loader.
+  - Assemble the code using GCC.
+  - Execute the code in the mes hex loader.
+
+*** 7. Manage Packages and Dependencies
+*Task:* Use github, Rust crates, and Guix to manage packages and dependencies, ensuring
+ reproducibility and stability across platforms.
+- *Language:* Bash, Rust, Guix
+- *Steps:*
+  - Create a ~guix~ manifest file for project dependencies.
+  - Install necessary packages using guix package manager.
+  - Automate dependency management with scripts.
+
+*** 8. Integrate Emacs and the Ellama Package
+*Task:* Integrate Emacs and the ellama package for communicating with LLMs and automating code
+ review tasks.
+- *Language:* Emacs Lisp, Python
+- *Steps:*
+  - Write Emacs Lisp functions to interact with the ellama package.
+  - Implement Emacs key bindings for automated code review.
+  - Test the integration in an Emacs environment.
+
+*** 9. Compile Final Code Using GCC and Linux
+*Task:* Use GCC and Linux for compiling and executing the final code, taking advantage of their
+ optimizations and features.
+- *Language:* Bash, GCC, Python
+- *Steps:*
+  - Write a script to compile the final code using GCC.
+  - Run the compiled executable on the Linux system.
+  - Ensure compatibility across different hardware configurations.
+
+*** 10. Trace Executions and Construct Zero Knowledge Proof
+*Task:* Trace the executions of the code and construct zero knowledge proofs that summarize the
+ execution succinctly.
+- *Language:* Python, ZKP libraries
+- *Steps:*
+  - Write scripts to trace and record code execution.
+  - Use ZKP libraries to generate zero knowledge proofs for each execution.
+
+*** 11. Document Each Step and Version
+*Task:* Document each step, tool, and version using org babel for easy reference and collaboration.
+- *Language:* Org Mode
+- *Steps:*
+  - Write detailed documentation for each step of the process.
+  - Use org babel to create versioned notes and results.
+  - Share documentation with team members.
+
+*** 12. Continuously Refine and Improve the Process
+*Task:* Continuously refine and improve the process based on feedback, data, and insights from users
+ and experts in AI, programming, and linguistics.
+- *Language:* Python, Jupyter Notebook
+- *Steps:*
+  - Conduct regular reviews of the process.
+  - Gather feedback from users and experts.
+  - Use data to identify areas for improvement.
+  - Implement changes to enhance efficiency and effectiveness.
+
+*** 13. Split Larger Task into Smaller Tasks
+*Task:* Split the larger task into smaller tasks that require less context because this one it
+ getting too big.
+- *Language:* Python
+- *Steps:*
+  - Analyze the current task and identify sub-tasks.
+  - Define clear goals for each sub-task.
+  - Allocate resources and timelines for each sub-task.
+
+This structured approach ensures a systematic process from defining intermediate languages to final
+execution, with formal verification, testing, and documentation at every step.
+
+---