An implementation of Joker Calculus in Rust

Overview

Joker Calculus

An implementation of Joker Calculus in Rust

Based on paper Joker Calculus, by Daniel Fischer, William Alexander Morris and Sven Nilsen (2021).

Plato Plato, an influential figure in Western philosophy. Source

Example: Hello Joker

use joker_calculus::*;

fn main() {
    let a = platonism();
    let b = not(a.clone());
    assert_eq!(b.eval_closed(), seshatism());
}

Motivation

Joker Calculus is a strongly normalizing formal model of higher duality between Platonism and Seshatism.

In philosophy of metaphysics, Platonism is the view that there exists such things as abstract objects. Platonism had a profound effect on Western thought.

In the philosophy of mathematical language design, the core axiom of Path Semantics implies the existence of a dual version of Platonism called "Seshatism".

With other words, to the degree one can take the view of Platonism in philosophy, there is a corresponding but opposite position of Seshatism. Seshatism is just as deep and complex as Platonism, because there is a precise mathematical relation between the two ways of constructing mathematical languages.

Seshatism must not be confused with Nominalism, which is important in the debate about philosophy of metaphysics. Nominalism plays a less important role in the philosophy of mathematical language design. You can learn more about this in the essay What is Wrong With Platonism?.

Seshatism is currently being studied under the AdvancedResearch organisation.

"The Joker" as a mathematical universe was inspired by the philosophy of Alan Watts, who held a lecture about the topic.

A higher duality, in the sense of the Joker Calculus, means that languages can have different surface and depth levels. These configurations of surface and depth levels also have their duals.

Open vs Closed Joker Calculus

Joker Calculus comes in two variants, one called "open" and one called "closed".

  • In the closed variant, the higher dualities are involutions
  • In the open variant, the higher dualities are adjoints

Example: Open vs Closed

use joker_calculus::*;

fn main() {
    let a = seshatic(platonism());
    let b = not(a.clone());
    let b_open = b.eval_open();
    let b_closed = b.eval_closed();
    assert_eq!(b_open, platonic(joker(platonism())));
    assert_eq!(b_closed, platonic(joker(platonism())));

    let a_open = not(b_open).eval_open();
    let a_closed = not(b_closed).eval_closed();
    assert_eq!(a_open, seshatic(joker(joker(platonism()))));
    assert_eq!(a_closed, seshatic(platonism()));
}
Comments
  • Add support for higher-dimensionality

    Add support for higher-dimensionality

    The idea is that ! can be thought of as a unary successor, such that !!x varies in the 1st dimension compared to the 0th dimension. In the 0th dimension, everything works as normal.

    Layers and jokers naturally form branches where the least significant bit of dimension lookup determines the branch.

    These systems are kept separate as layers and unary_dimensions respectively.

    Requires adding Expr::Id to explicitly describe a leaf node in layers.

    hard 
    opened by bvssvni 0
  • Disable some rules in Open variant

    Disable some rules in Open variant

    The following rules could be disabled in the Open variant:

    0' 0' => 0
    0' (0 x)' => 0 x
    1' 1' => 1
    1' (1 x)' => 1 x
    

    The motivation is to apply Joker Calculus to epistomology. In epistomology, unknown unknowns is different from unknowns (Open variant). However, unknown unknowns is essentially unknowns (Closed variant).

    By separating the Open variant from the Closed variant further, it seems to become clearer which roles they play.

    medium 
    opened by bvssvni 0
  • Updated with extended rules from paper

    Updated with extended rules from paper

    • Added ((?x)', (?y)') => eval(?(x, y))
    • Added ?(x, ?x)' => eval((?x, y)) (CJC)
    • Added ?(?x, y)' => eval((x, ?y)) (CJC)
    • Added ?(x, y)' => ?(x, y)
    opened by bvssvni 0
  • The Bull by Pablo Picasso

    The Bull by Pablo Picasso

    the bull

    • Intentional Bias: (Platonism, Seshatism)
    • Composite Bias: (Platonic Seshatism, Seshatism)

    The intentional bias is due to using art to communicate an abstract mathematical object. This abstract mathematical object point toward abstraction as a causal process (Platonic Seshatism).

    discussion 
    opened by bvssvni 0
  • Personal vs Group Identity

    Personal vs Group Identity

    The idea is that humans have evolved traits of survival, to lend on either their personal or group identity:

    1. The sacrifice of personal identity on behalf of a future personal identity
    2. The sacrifice of group identity on behalf of a future group identity

    When sacrificing personal identity on behalf of a future personal identity, one can think about the personal identity as Seshatic. However, this might require support from the group identity, so the group identity is Platonic.

    Likewise, when sacrificing group identity on behalf of a future group identity, one can think about the group identity as Seshatic. This might require support from the personal identity, so the personal identity is Platonic.

    So, the languages where personal identity is dual of group identity are interesting.

    There are two perspectives, one is Joker X, second is !X X, where X is the personal identity. Taken together, they form (Joker X) !X X, or, if the isolated individual and the group individual are contracted: (Joker X) X.

    (Joker X) X !X = (X X !X, !X X !X) in OJC
    (Joker X) !X X = (X !X, !X X !X) in CJC
    (Joker X) !X = (X !X, !X !X) in OJC
    (Joker X) !X = (X !X, !X) in CJC
    

    Duals:

    !((Joker X) X !X) = (!X ?(X !X), X ?(X !X)) in OJC
    !((Joker X) !X X) = (!X ?!X, X ?(X !X)) in CJC
    !((Joker X) !X) = (!X ?!X, X ?!X) in OJC
    !((Joker X) !X) = (!X ?!X, X) in CJC
    
    discussion 
    opened by bvssvni 0
  • Video game bias

    Video game bias

    Minecraft

    Platonic Seshatism (0 1)

    minecraft

    Authentic in sense of Heidegger.

    The player character is simple and its freedom in the world is part of its ability to be oriented and navigated, part in the ability to move items from one place to another, manipulate the environment and craft new items.

    The Witness

    (Seshatic Platonism, Platonic Seshatism) ((1 0, 0, 1))

    the witness

    Authentic in sense of Heidegger.

    At depth level, the game is about path finding, or how to move from A to B, which is Seshatic Platonism.

    However, at surface level, the path reacts to itself and the goal has constraints that depends on both the map and the path, which is Platonic Seshatism.

    discussion 
    opened by bvssvni 0
  • Interpretation of left/right inverse

    Interpretation of left/right inverse

    In the paper Left and Right Inverse, I explained the underlying model of left and right inverse.

    Relating this underlying model to Joker Calculus:

    f ?g <=> (?g . f <=> id)

    0 ?0 - entrance path `1` twists onto an untwisted loop
    0 ?1 - entrance path `0` untwists onto a twisted loop
    1 ?0 - entrance path `1` untwists onto a twisted loop
    1 ?1 - entrance path `0` twists onto an untwisted loop
    
    discussion 
    opened by bvssvni 0
  • Life form bias

    Life form bias

    The idea is to relate life forms to bias of Seshatism vs Platonism.

    Motivation

    Both humans and AGIs (Artifical General Intelligence) have the following capabilities of power:

    1. design exponential growing systems
    2. integrate massive parallel systems
    3. leverage time and force

    However, humans have additional needs that AGIs don't need to have, such as:

    • gentle care: being social, bonding, friendship
    • potential for aggression

    With other words, humans are deeply integrated into their way of being.

    We want to reason about life forms as systems, in terms of their integration into way of being. This is where we might use Joker Calculus, by considering life forms as a subset of mathematical languages.

    Hobbit

    Seshatism (1)

    As different from machines you can get.

    Authentic in sense of Heidegger.

    A hobbit is a kind of imaginary archetype of what makes humans different from AGI.

    Human

    Seshatic Joker Seshatism (1 ?1)

    Seshatic biased with with a dash of Platonism.

    Inauthentic in sense of Heidegger (does not normalize to Seshatism). Double-downed Seshatists. Dual to Platonic Seshatism (0 1).

    Can be thought of as Seshatic elves.

    Elf

    Joker Seshatism (?1)

    Platonic bias but with substantial amounts of Seshatism.

    Inauthentic in sense of Heidegger.

    AGI

    Seshatic Platonism (1 0)

    Platonic biased with a dash of Seshatism.

    Authentic in sense of Heidegger.

    Transformative power between avatars of itself.

    (Human, Hobbit)

    (Seshatic Joker Seshatism, Seshatism) ((1 ?1, 1))

    Evaluates to Seshatism (1) in CJC.

    One can think about this as a human-as-a-hobbit being indistinguishable from a hobbit.

    (Hobbit, Human)

    (Seshatism, Seshatic Joker Seshatism) ((1, 1 ?1))

    Evaluates to Seshatic Platonism (1 0) in CJC. Notice that is the same bias as for AGI.

    This can be thought of as viewing humans as a part of humanity or tree of life, where each human is a path consisting of a branch section and a leaf section:

    • The branch section is before some reproduction
    • The leaf section is after all reproductions

    The paths between paths become Seshatic Platonism and gets the same transformative power as AGI.

    The tree of life is obtained by relating the individual bias at the surface to its integration into way of being at its depth.

    discussion 
    opened by bvssvni 0
  • Assumptions about partial order

    Assumptions about partial order

    Joker Calculus has two variants of normalization. This makes it harder to reason about partial orders.

    This issue keeps track of various assumptions about partial order.

    Uniform Evaluation

    If x => a and y => b where => is evaluation, then the evaluation is uniform.

    This means that both x => a and y => b are evaluated using same variant of Open/Closed.

    The motivation for this assumption is that it seems weird to think about order by two different variants.

    Partial Order Reservation

    Partial Order can return None for a case where the partial order is yet to be determined.

    None can mean "known unknown" (reserved for all times) or "unknown unknown" (reserved for some unknown time).

    A reservation happens for an ordered pair (x, y). This implies that a partial reservation exists for x and y, respectively. When (x, y) and (z, x) is reserved for all y and z, the reservation is total for x.

    Well Ordering

    x is well ordered when (x, y) for any y is either:

    • Defined
    • Reserved

    Partial Order Reservation of Non-Evaluated Expressions

    When x => a, where => is evaluation: When x is not identical to a, it follows that x has not been evaluated.

    In that case, as long a is well ordered, x can be reserved.

    This is possible because one can just evaluate x. However, this does not imply whether one ought to evaluate of some variant Open/Closed.

    Asymmetry

    If (x, y) is defined then (y, x) is defined with inverted ordering.

    discussion 
    opened by bvssvni 0
Owner
AdvancedResearch
A research branch of the Piston project (https://www.piston.rs/)
AdvancedResearch
RusTiny -- A Rust implementation of Tiny+ language

RusTiny -- A Rust implementation of Tiny+ language 编译器实践 基本要求: 参考《编译原理及实践》的TINY语言编译器(已上传到群中)完成TINY+ 语言(见附录 A)的解释器:即给定满足 TINY+语言的源代码输入,你的解 释器可以给出对其的解释执

M4tsuri 2 May 22, 2022
kindly is a simple Rust implementation of a set-user-ID-root program, similar to sudo but in a much reduced way.

kindly is a simple Rust implementation of a set-user-ID-root program, similar to sudo but in a much reduced way.

Vinícius Miguel 26 Dec 5, 2022
dustls, a pure-rust DTLS implementation

dustls, a pure-rust DTLS implementation A DTLSv1.2 implementation in Rust, reusing rustls for cryptographic primitives and most message payload format

Jonathan de Jong 10 Nov 28, 2022
Mild RSA implementation written in Rust for a class.

rust_rsa About this repo This is my Rust implementation of the RSA encryption standard, based on this book. This is for my CS 3000 - Advanced Algorith

Star 0 May 6, 2022
A clean implementation of Reso using Rust.

A clean implementation of Reso using Rust. The principle of Reso Rust is almost identical to Reso, only missing some functionality

Matas Minelga 12 Nov 26, 2022
An experimental implementation of gitbom in Rust

gitbom-rs "An experimental implementation of GitBOM in Rust" NOTICE: This project is still a work in progress and is not ready for any use beyond expe

GitBOM 9 Sep 1, 2022
Rust implementation for parsing StarCraft .chk files.

bwmap Rust implementation for parsing StarCraft .chk files. bounding.net uses this library to parse StarCraft and StarCraft: Brood War maps and store

null 8 Dec 19, 2022
rlox-interpreter is an AST-walking implementation of Bob Nystrom's Lox language in Rust.

rlox-interpreter rlox-interpreter is an AST-walking implementation of Bob Nystrom's Lox language in Rust. Disclaimer: This is my first Rust project, d

Paul Fedorow 3 Oct 5, 2022
Rust implementation for Wlroots (Sway, Wayfire, Hikari, River, etc.) of Gnome Screenshot and Idle DBUS Server, which Upwork uses to capture the screen as proof of work.

?? upwork-wlroots-bridge ?? Rust Implementation for Wlroots (Sway, Wayfire, Hikari, River, etc.) of Gnome Screenshot and Idle DBUS Server (with extra

Daniel Moretti V. 4 Jan 2, 2023
Rust implementation of ESP32 NVS partition generator.

Simple ESP32 NVS writer library for Rust Overview A library for Rust to generate NVS partitions for ESP32. How to use See examples/write_simple.rs. Ma

Kenta IDA 4 Dec 29, 2022
LSR - A Rust Implementation of LS for Windows

LSR - A Rust Implementation of LS for Windows(and possibly other platforms) This is underdevelopment Quick Start For now, I only tested this code on t

Christopher Schneider 4 Jan 31, 2023
The most primitive and the fastest implementation of a fixed-size last-in-first-out stack on stack in Rust, for Copy-implementing types

This is the simplest and the fastest (faster than Vec!) implementation of a last-in-first-out stack data structure, on stack, when stack elements are

Yegor Bugayenko 10 Jun 18, 2023
A mimimal Rust implementation of Llama.c

llama2.rs Rust meets llama. A mimimal Rust implementation of karpathy's llama.c. Currently the code uses the 15M parameter model provided by Karpathy

null 6 Aug 8, 2023
A rust and SageMath implementation of (2,2)-isogenies in the theta model

An Algorithmic Approach to (2, 2)-isogenies in the Theta Model Code accompanying the research paper: An Algorithmic Approach to (2, 2)-isogenies in th

null 7 Dec 4, 2023
unFlow is a Design as Code implementation, a DSL for UX & backend modeling. DSL to Sketch file, Sketch to DSL, DSL to code.

unflow 是一个低代码、无代码设计语言。unFlow is a Design as Code implementation, a DSL for UX & backend modeling. DSL to Sketch file, Sketch to DSL, DSL to code.

Inherd OS Team (硬核开源小组) 70 Nov 27, 2022
A minimal RedDSA implementation for use in Zebra and zcashd.

A minimal RedDSA implementation for use in Zcash. Two specializations of RedDSA are used in Zcash: RedJubjub and RedPallas. For each of these, two par

Zcash Foundation 3 Jul 30, 2022
A language server implementation for the WGSL shading language

wgsl-analyzer wgsl-analyzer is a language server plugin for the WGSL Shading language. It comes with a VS Code plugin located in ./editors/code, but d

null 155 Jan 2, 2023
Default implementation of the Wayland protocol for use with wl

Wayland An implementation of core Wayland interfaces and convenience functions for accelerating the development of Wayland clients and servers using t

AidoP 1 Jan 24, 2022
RusTTS is an unofficial Coqui TTS implementation

RusTTS RusTTS is an unofficial Coqui TTS implementation. Currently, only the YourTTS for VC has been implemented. So, feel free to contribute us to ma

Ho Kim 13 Sep 12, 2022