nng

server/nng/.gitignore

@@ -1 +0,0 @@
-build

server/nng/NNG.lean

@@ -15,16 +15,45 @@ Game "NNG"
 Title "Natural Number Game"
 Introduction
 "
-[intro text missing]
+# Natural Number Game
+
+##### version 2.0.1
+
+Welcome to the natural number game -- a game which shows the power of induction.
+
+In this game, you get own version of the natural numbers, in an interactive
+theorem prover called Lean. Your version of the natural numbers satisfies something called
+the principle of mathematical induction, and a couple of other things too (Peano's axioms).
+Unfortunately, nobody has proved any theorems about these
+natural numbers yet! For example, addition will be defined for you,
+but nobody has proved that `x + y = y + x` yet. This is your job. You're going to
+prove mathematical theorems using the Lean theorem prover. In other words, you're going to solve
+levels in a computer game.
+
+You're going to prove these theorems using *tactics*. The introductory world, Tutorial World,
+will take you through some of these tactics. During your proofs, the assistant shows your
+\"goal\" (i.e. what you're supposed to be proving) and keeps track of the state of your proof.
+
+Click on the blue \"Tutorial World\" to start your journey!
+
+## Save progress
+
+The game stores your progress locally in your browser storage.
+If you delete it, your progress will be lost!
+
+(usually the *website data* gets deleted together with cookies.)
 
 ## Credits
-* Content and Lean3-version: Kevin Buzzard, Mohammad Pedramfar
+
-* Game Engine: Alexander Bentkamp, Jon Eugster, Patrick Massot
+* **Content and Lean3-version:** Kevin Buzzard, Mohammad Pedramfar
-* Port to Lean 4: Chris Lovett
+* **Game Engine:** Alexander Bentkamp, Jon Eugster, Patrick Massot
 
 ## Resources
+
+* The [Lean Zulip chat] forum
 * [Original Lean3 version](https://www.ma.imperial.ac.uk/~buzzard/xena/natural_number_game/)
-* [Chris' translation to lean4](https://lovettsoftware.com/NaturalNumbers/TutorialWorld/Level1.lean.html)
+* [A textbook-style (lean4) version of the NN-game](https://lovettsoftware.com/NaturalNumbers/TutorialWorld/Level1.lean.html)
+
 "
 
 Path Tutorial → Addition → Function → Proposition → AdvProposition → AdvAddition
@@ -32,4 +61,4 @@ Path AdvAddition → AdvMultiplication → Inequality
 Path Addition → Multiplication → AdvMultiplication
 Path Multiplication → Power
 
-MakeGame
+MakeGame

server/nng/NNG/Levels/Addition/Level_2.lean

@@ -8,7 +8,9 @@ Title "add_assoc (associativity of addition)"
 
 open MyNat
 
-theorem MyNat.zero_add (n : ℕ) : 0 + n = n := by
+namespace AdditionWorld
+
+theorem zero_add (n : ℕ) : 0 + n = n := by
   induction n with n hn
   · rw [add_zero]
     rfl

server/nng/NNG/Levels/Addition/Level_3.lean

@@ -9,7 +9,9 @@ Title "succ_add"
 
 open MyNat
 
-theorem MyNat.add_assoc (a b c : ℕ) : (a + b) + c = a + (b + c)  := by
+namespace AdditionWorld
+
+theorem add_assoc (a b c : ℕ) : (a + b) + c = a + (b + c)  := by
   induction c with c hc
   · rw [add_zero]
     rw [add_zero]
@@ -20,7 +22,6 @@ theorem MyNat.add_assoc (a b c : ℕ) : (a + b) + c = a + (b + c)  := by
     rw [hc]
     rfl
 
-
 Introduction
 "
 Oh no! On the way to `add_comm`, a wild `succ_add` appears. `succ_add`
@@ -52,6 +53,7 @@ $ \\operatorname{succ}(a) + b = \\operatorname{succ}(a + b)$."
     Hint "Induction on `a` will not work."
   induction b with d hd
   · rw [add_zero]
+    rw [add_zero]
     rfl
   · rw [add_succ]
     rw [hd]

server/nng/NNG/Levels/Addition/Level_4.lean

@@ -9,9 +9,12 @@ Title "`add_comm` (boss level)"
 
 open MyNat
 
-theorem MyNat.succ_add (a b : ℕ) : succ a + b = succ (a + b)  := by
+namespace AdditionWorld
+
+theorem succ_add (a b : ℕ) : succ a + b = succ (a + b)  := by
   induction b with d hd
   · rw [add_zero]
+    rw [add_zero]
     rfl
   · rw [add_succ]
     rw [hd]

server/nng/NNG/Levels/Addition/Level_5.lean

@@ -9,7 +9,9 @@ Title "succ_eq_add_one"
 
 open MyNat
 
-theorem MyNat.add_comm (a b : ℕ) : a + b = b + a := by
+namespace AdditionWorld
+
+theorem add_comm (a b : ℕ) : a + b = b + a := by
   induction b with d hd
   · rw [zero_add]
     rw [add_zero]
@@ -19,8 +21,7 @@ theorem MyNat.add_comm (a b : ℕ) : a + b = b + a := by
     rw [succ_add]
     rfl
 
-theorem MyNat.one_eq_succ_zero : (1 : ℕ) = succ 0 := by
+theorem one_eq_succ_zero : (1 : ℕ) = succ 0 := by simp only
-  rfl
 
 NewLemma MyNat.add_comm MyNat.one_eq_succ_zero
 

server/nng/NNG/Levels/Addition/Level_6.lean

@@ -9,11 +9,13 @@ Title "add_right_comm"
 
 open MyNat
 
+namespace AdditionWorld
+
 Introduction
 "
 Lean sometimes writes `a + b + c`. What does it mean? The convention is
 that if there are no brackets displayed in an addition formula, the brackets
-are around the left most `+` (Lean's addition is \"left associative\"). 
+are around the left most `+` (Lean's addition is \"left associative\").
 So the goal in this level is `(a + b) + c = (a + c) + b`. This isn't
 quite `add_assoc` or `add_comm`, it's something you'll have to prove
 by putting these two theorems together.

server/nng/NNG/Levels/Function/Level_8.lean

@@ -15,7 +15,7 @@ Introduction
 
 Statement
 ""
-    (P Q : Type) : (P → Q) → ((Q → empty) → (P → empty)) := by
+    (P Q : Type) : (P → Q) → ((Q → Empty) → (P → Empty)) := by
   intros f h p
   apply h
   apply f

server/nng/NNG/Levels/Proposition/Level_2.lean

@@ -15,7 +15,7 @@ Introduction
 
 Statement
 ""
-    : P → P := by
+    {P : Prop} : P → P := by
   intro p
   exact p
 

server/nng/NNG/Levels/Proposition/Level_5.lean

@@ -19,7 +19,6 @@ Statement
   intro p
   intro q
   exact p
-  rfl
 
 Conclusion
 "

server/nng/NNG/MyNat/Theorems/Addition.lean

@@ -25,6 +25,7 @@ theorem MyNat.add_assoc (a b c : ℕ) : (a + b) + c = a + (b + c)  := by
 theorem MyNat.succ_add (a b : ℕ) : succ a + b = succ (a + b)  := by
   induction b with d hd
   · rw [add_zero]
+    rw [add_zero]
     rfl
   · rw [add_succ]
     rw [hd]
@@ -42,4 +43,4 @@ theorem MyNat.add_comm (a b : ℕ) : a + b = b + a := by
     rfl
 
 theorem MyNat.one_eq_succ_zero : (1 : ℕ) = succ 0 := by
-  rfl
+  simp only

server/nng/build/ir/NNG.c

@@ -0,0 +1,73 @@
+// Lean compiler output
+// Module: NNG
+// Imports: Init GameServer.Commands NNG.Levels.Tutorial NNG.Levels.Addition NNG.Levels.Multiplication NNG.Levels.Power NNG.Levels.Function NNG.Levels.Proposition NNG.Levels.AdvProposition NNG.Levels.AdvAddition NNG.Levels.AdvMultiplication NNG.Levels.Inequality
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_GameServer_Commands(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Tutorial(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Multiplication(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Power(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Proposition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvMultiplication(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Inequality(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_GameServer_Commands(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Tutorial(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Multiplication(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Power(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Proposition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvMultiplication(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Inequality(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG.c.trace

@@ -0,0 +1 @@
+7356427851528760174

server/nng/build/ir/NNG/Doc/Definitions.c

@@ -0,0 +1,33 @@
+// Lean compiler output
+// Module: NNG.Doc.Definitions
+// Imports: Init GameServer.Commands
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_GameServer_Commands(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Doc_Definitions(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_GameServer_Commands(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Doc/Definitions.c.trace

@@ -0,0 +1 @@
+2922655963706979749

server/nng/build/ir/NNG/Doc/Lemmas.c

@@ -0,0 +1,33 @@
+// Lean compiler output
+// Module: NNG.Doc.Lemmas
+// Imports: Init GameServer.Commands
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_GameServer_Commands(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Doc_Lemmas(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_GameServer_Commands(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Doc/Lemmas.c.trace

@@ -0,0 +1 @@
+16771103639053061509

server/nng/build/ir/NNG/Doc/Tactics.c

@@ -0,0 +1,33 @@
+// Lean compiler output
+// Module: NNG.Doc.Tactics
+// Imports: Init GameServer.Commands
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_GameServer_Commands(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Doc_Tactics(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_GameServer_Commands(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Doc/Tactics.c.trace

@@ -0,0 +1 @@
+5348243054589539109

server/nng/build/ir/NNG/Levels/Addition.c

@@ -0,0 +1,53 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition
+// Imports: Init NNG.Levels.Addition.Level_1 NNG.Levels.Addition.Level_2 NNG.Levels.Addition.Level_3 NNG.Levels.Addition.Level_4 NNG.Levels.Addition.Level_5 NNG.Levels.Addition.Level_6
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__1(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__2(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__3(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__4(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__5(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__6(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__1(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__2(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__3(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__4(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__5(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__6(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition.c.trace

@@ -0,0 +1 @@
+2084978910118405033

server/nng/build/ir/NNG/Levels/Addition/Level_1.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition.Level_1
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition_Level__1(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition/Level_1.c.trace

@@ -0,0 +1 @@
+5269099431713252405

server/nng/build/ir/NNG/Levels/Addition/Level_2.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition.Level_2
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition_Level__2(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition/Level_2.c.trace

@@ -0,0 +1 @@
+17690234639472501785

server/nng/build/ir/NNG/Levels/Addition/Level_3.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition.Level_3
+// Imports: Init NNG.Metadata NNG.MyNat.Addition NNG.Levels.Addition.Level_2
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__2(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition_Level__3(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__2(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition/Level_3.c.trace

@@ -0,0 +1 @@
+18302928042269315295

server/nng/build/ir/NNG/Levels/Addition/Level_4.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition.Level_4
+// Imports: Init NNG.Metadata NNG.MyNat.Addition NNG.Levels.Addition.Level_3
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__3(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition_Level__4(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__3(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition/Level_4.c.trace

@@ -0,0 +1 @@
+12154535057277385306

server/nng/build/ir/NNG/Levels/Addition/Level_5.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition.Level_5
+// Imports: Init NNG.Metadata NNG.MyNat.Addition NNG.Levels.Addition.Level_4
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__4(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition_Level__5(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__4(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition/Level_5.c.trace

@@ -0,0 +1 @@
+9679823460697032654

server/nng/build/ir/NNG/Levels/Addition/Level_6.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Addition.Level_6
+// Imports: Init NNG.Metadata NNG.MyNat.Addition NNG.Levels.Addition.Level_5
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Addition_Level__5(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Addition_Level__6(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Addition_Level__5(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Addition/Level_6.c.trace

@@ -0,0 +1 @@
+17709657049698654137

server/nng/build/ir/NNG/Levels/AdvAddition.c

@@ -0,0 +1,81 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition
+// Imports: Init NNG.Levels.AdvAddition.Level_1 NNG.Levels.AdvAddition.Level_2 NNG.Levels.AdvAddition.Level_3 NNG.Levels.AdvAddition.Level_4 NNG.Levels.AdvAddition.Level_5 NNG.Levels.AdvAddition.Level_6 NNG.Levels.AdvAddition.Level_7 NNG.Levels.AdvAddition.Level_8 NNG.Levels.AdvAddition.Level_9 NNG.Levels.AdvAddition.Level_10 NNG.Levels.AdvAddition.Level_11 NNG.Levels.AdvAddition.Level_12 NNG.Levels.AdvAddition.Level_13
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__1(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__2(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__3(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__4(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__5(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__6(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__7(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__8(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__9(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__10(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__11(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__12(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvAddition_Level__13(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__1(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__2(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__3(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__4(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__5(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__6(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__7(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__8(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__9(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__10(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__11(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__12(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvAddition_Level__13(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition.c.trace

@@ -0,0 +1 @@
+7852774950450280612

server/nng/build/ir/NNG/Levels/AdvAddition/Level_1.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_1
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__1(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_1.c.trace

@@ -0,0 +1 @@
+9336372057508599589

server/nng/build/ir/NNG/Levels/AdvAddition/Level_10.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_10
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__10(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_10.c.trace

@@ -0,0 +1 @@
+4008453200266032081

server/nng/build/ir/NNG/Levels/AdvAddition/Level_11.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_11
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__11(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_11.c.trace

@@ -0,0 +1 @@
+10015610238961501552

server/nng/build/ir/NNG/Levels/AdvAddition/Level_12.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_12
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__12(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_12.c.trace

@@ -0,0 +1 @@
+5389173862524826914

server/nng/build/ir/NNG/Levels/AdvAddition/Level_13.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_13
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__13(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_13.c.trace

@@ -0,0 +1 @@
+185528048873600791

server/nng/build/ir/NNG/Levels/AdvAddition/Level_2.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_2
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__2(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_2.c.trace

@@ -0,0 +1 @@
+3507750203879559481

server/nng/build/ir/NNG/Levels/AdvAddition/Level_3.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_3
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__3(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_3.c.trace

@@ -0,0 +1 @@
+18314890376638277065

server/nng/build/ir/NNG/Levels/AdvAddition/Level_4.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_4
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__4(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_4.c.trace

@@ -0,0 +1 @@
+2092365143561121648

server/nng/build/ir/NNG/Levels/AdvAddition/Level_5.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_5
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__5(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_5.c.trace

@@ -0,0 +1 @@
+17123810049702200014

server/nng/build/ir/NNG/Levels/AdvAddition/Level_6.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_6
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__6(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_6.c.trace

@@ -0,0 +1 @@
+9314509491732931710

server/nng/build/ir/NNG/Levels/AdvAddition/Level_7.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_7
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__7(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_7.c.trace

@@ -0,0 +1 @@
+13172030794097753806

server/nng/build/ir/NNG/Levels/AdvAddition/Level_8.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_8
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__8(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_8.c.trace

@@ -0,0 +1 @@
+10314181165617171139

server/nng/build/ir/NNG/Levels/AdvAddition/Level_9.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvAddition.Level_9
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvAddition_Level__9(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvAddition/Level_9.c.trace

@@ -0,0 +1 @@
+8205318715931175597

server/nng/build/ir/NNG/Levels/AdvMultiplication.c

@@ -0,0 +1,45 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvMultiplication
+// Imports: Init NNG.Levels.AdvMultiplication.Level_1 NNG.Levels.AdvMultiplication.Level_2 NNG.Levels.AdvMultiplication.Level_3 NNG.Levels.AdvMultiplication.Level_4
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvMultiplication_Level__1(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvMultiplication_Level__2(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvMultiplication_Level__3(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvMultiplication_Level__4(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvMultiplication(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvMultiplication_Level__1(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvMultiplication_Level__2(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvMultiplication_Level__3(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvMultiplication_Level__4(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvMultiplication.c.trace

@@ -0,0 +1 @@
+5627580921265871323

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_1.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvMultiplication.Level_1
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvMultiplication_Level__1(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_1.c.trace

@@ -0,0 +1 @@
+5496292641504121726

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_2.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvMultiplication.Level_2
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvMultiplication_Level__2(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_2.c.trace

@@ -0,0 +1 @@
+3065456568864785697

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_3.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvMultiplication.Level_3
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvMultiplication_Level__3(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_3.c.trace

@@ -0,0 +1 @@
+11074674160667156308

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_4.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvMultiplication.Level_4
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvMultiplication_Level__4(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvMultiplication/Level_4.c.trace

@@ -0,0 +1 @@
+5171635906789131558

server/nng/build/ir/NNG/Levels/AdvProposition.c

@@ -0,0 +1,69 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition
+// Imports: Init NNG.Levels.AdvProposition.Level_1 NNG.Levels.AdvProposition.Level_2 NNG.Levels.AdvProposition.Level_3 NNG.Levels.AdvProposition.Level_4 NNG.Levels.AdvProposition.Level_5 NNG.Levels.AdvProposition.Level_6 NNG.Levels.AdvProposition.Level_7 NNG.Levels.AdvProposition.Level_8 NNG.Levels.AdvProposition.Level_9 NNG.Levels.AdvProposition.Level_10
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__1(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__2(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__3(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__4(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__5(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__6(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__7(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__8(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__9(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_AdvProposition_Level__10(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__1(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__2(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__3(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__4(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__5(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__6(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__7(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__8(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__9(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_AdvProposition_Level__10(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition.c.trace

@@ -0,0 +1 @@
+9478676650839776721

server/nng/build/ir/NNG/Levels/AdvProposition/Level_1.c

@@ -0,0 +1,37 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_1
+// Imports: Init NNG.Metadata NNG.MyNat.Addition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__1(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_1.c.trace

@@ -0,0 +1 @@
+13140666477521992594

server/nng/build/ir/NNG/Levels/AdvProposition/Level_10.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_10
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__10(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_10.c.trace

@@ -0,0 +1 @@
+18203712100298108367

server/nng/build/ir/NNG/Levels/AdvProposition/Level_2.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_2
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__2(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_2.c.trace

@@ -0,0 +1 @@
+10022829939796104452

server/nng/build/ir/NNG/Levels/AdvProposition/Level_3.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_3
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__3(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_3.c.trace

@@ -0,0 +1 @@
+1967301918816512059

server/nng/build/ir/NNG/Levels/AdvProposition/Level_4.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_4
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__4(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_4.c.trace

@@ -0,0 +1 @@
+16129653996493781623

server/nng/build/ir/NNG/Levels/AdvProposition/Level_5.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_5
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__5(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_5.c.trace

@@ -0,0 +1 @@
+16436512257645906503

server/nng/build/ir/NNG/Levels/AdvProposition/Level_6.c

@@ -0,0 +1,45 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_6
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases Mathlib.Tactic.LeftRight
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+lean_object* initialize_Mathlib_Tactic_LeftRight(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__6(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Mathlib_Tactic_LeftRight(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_6.c.trace

@@ -0,0 +1 @@
+14208111587323885963

server/nng/build/ir/NNG/Levels/AdvProposition/Level_7.c

@@ -0,0 +1,45 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_7
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases Mathlib.Tactic.LeftRight
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+lean_object* initialize_Mathlib_Tactic_LeftRight(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__7(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Mathlib_Tactic_LeftRight(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_7.c.trace

@@ -0,0 +1 @@
+8730344058151551457

server/nng/build/ir/NNG/Levels/AdvProposition/Level_8.c

@@ -0,0 +1,45 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_8
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases Mathlib.Tactic.LeftRight
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+lean_object* initialize_Mathlib_Tactic_LeftRight(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__8(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Mathlib_Tactic_LeftRight(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_8.c.trace

@@ -0,0 +1 @@
+14257091850430971994

server/nng/build/ir/NNG/Levels/AdvProposition/Level_9.c

@@ -0,0 +1,45 @@
+// Lean compiler output
+// Module: NNG.Levels.AdvProposition.Level_9
+// Imports: Init NNG.Metadata NNG.MyNat.Addition Std.Tactic.RCases NNG.MyNat.Theorems.Proposition
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_Std_Tactic_RCases(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Theorems_Proposition(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_AdvProposition_Level__9(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_Std_Tactic_RCases(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Theorems_Proposition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/AdvProposition/Level_9.c.trace

@@ -0,0 +1 @@
+14967413771991349992

server/nng/build/ir/NNG/Levels/Function.c

@@ -0,0 +1,65 @@
+// Lean compiler output
+// Module: NNG.Levels.Function
+// Imports: Init NNG.Levels.Function.Level_1 NNG.Levels.Function.Level_2 NNG.Levels.Function.Level_3 NNG.Levels.Function.Level_4 NNG.Levels.Function.Level_5 NNG.Levels.Function.Level_6 NNG.Levels.Function.Level_7 NNG.Levels.Function.Level_8 NNG.Levels.Function.Level_9
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__1(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__2(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__3(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__4(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__5(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__6(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__7(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__8(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Levels_Function_Level__9(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Function(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__1(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__2(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__3(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__4(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__5(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__6(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__7(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__8(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Levels_Function_Level__9(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Function.c.trace

@@ -0,0 +1 @@
+4955068752717367929

server/nng/build/ir/NNG/Levels/Function/Level_1.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Function.Level_1
+// Imports: Init NNG.Metadata NNG.MyNat.Theorems.Addition NNG.MyNat.Multiplication
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Theorems_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Multiplication(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Function_Level__1(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Theorems_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Multiplication(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Function/Level_1.c.trace

@@ -0,0 +1 @@
+11635906400192042058

server/nng/build/ir/NNG/Levels/Function/Level_2.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Function.Level_2
+// Imports: Init NNG.Metadata NNG.MyNat.Theorems.Addition NNG.MyNat.Multiplication
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Theorems_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Multiplication(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Function_Level__2(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Theorems_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Multiplication(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif

server/nng/build/ir/NNG/Levels/Function/Level_2.c.trace

@@ -0,0 +1 @@
+5739902419023245944

server/nng/build/ir/NNG/Levels/Function/Level_3.c

@@ -0,0 +1,41 @@
+// Lean compiler output
+// Module: NNG.Levels.Function.Level_3
+// Imports: Init NNG.Metadata NNG.MyNat.Theorems.Addition NNG.MyNat.Multiplication
+#include <lean/lean.h>
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-parameter"
+#pragma clang diagnostic ignored "-Wunused-label"
+#elif defined(__GNUC__) && !defined(__CLANG__)
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#pragma GCC diagnostic ignored "-Wunused-label"
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+#ifdef __cplusplus
+extern "C" {
+#endif
+lean_object* initialize_Init(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_Metadata(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Theorems_Addition(uint8_t builtin, lean_object*);
+lean_object* initialize_NNG_MyNat_Multiplication(uint8_t builtin, lean_object*);
+static bool _G_initialized = false;
+LEAN_EXPORT lean_object* initialize_NNG_Levels_Function_Level__3(uint8_t builtin, lean_object* w) {
+lean_object * res;
+if (_G_initialized) return lean_io_result_mk_ok(lean_box(0));
+_G_initialized = true;
+res = initialize_Init(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_Metadata(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Theorems_Addition(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+res = initialize_NNG_MyNat_Multiplication(builtin, lean_io_mk_world());
+if (lean_io_result_is_error(res)) return res;
+lean_dec_ref(res);
+return lean_io_result_mk_ok(lean_box(0));
+}
+#ifdef __cplusplus
+}
+#endif