monogate-forge 0.2.0__tar.gz

monogate_forge-0.2.0/LICENSE

@@ -0,0 +1,32 @@
+MIT License
+
+Copyright (c) 2026 Monogate Research
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Note: While this implementation is licensed under MIT, specific algorithmic
+methods used by Monogate Forge are covered by patents held by Monogate Research
+(see `patents/index.md`). The MIT license grants you the right to use, modify,
+and distribute THIS implementation. Independent re-implementations of patented
+methods may require licensing — contact the project maintainers for details.
+
+This is the same model used by GCC + the x86 instruction set: the compiler
+is open, but specific microarchitectural techniques may be patented.

monogate_forge-0.2.0/PKG-INFO

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: monogate-forge
+Version: 0.2.0
+Summary: EML language and compiler for verified mathematical computation. 31 backends spanning software, GPU shaders, hardware (FPGA/ASIC), formal verification, and safety-critical systems.
+Author: Mosa Creates LLC
+Author-email: "Arturo R. Almaguer" <almaguer1986@gmail.com>
+Maintainer-email: "Arturo R. Almaguer" <almaguer1986@gmail.com>
+License: MIT
+Project-URL: Homepage, https://monogateforge.com
+Project-URL: Documentation, https://monogate.dev/learn/eml/intro
+Project-URL: Repository, https://github.com/agent-maestro/forge
+Project-URL: Issues, https://github.com/agent-maestro/forge/issues
+Project-URL: Changelog, https://github.com/agent-maestro/forge/blob/master/CHANGELOG.md
+Project-URL: VS Code Extension, https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang
+Project-URL: Research, https://monogate.org
+Project-URL: MachLib, https://machlib.org
+Keywords: compiler,programming-language,formal-verification,lean,fpga,hdl,verilog,vhdl,safety-critical,embedded,math,shader,hlsl,metal,wgsl,eml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: eml-cost>=0.19.0
+Requires-Dist: cryptography>=42
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Provides-Extra: lsp
+Requires-Dist: pygls>=2.0; extra == "lsp"
+Requires-Dist: lsprotocol>=2024.0.0b1; extra == "lsp"
+Dynamic: license-file
+
+# Monogate Forge
+
+[![CI](https://github.com/agent-maestro/forge/actions/workflows/ci.yml/badge.svg)](https://github.com/agent-maestro/forge/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/monogate-forge.svg)](https://pypi.org/project/monogate-forge/)
+[![VS Code Marketplace](https://img.shields.io/visual-studio-marketplace/v/monogate.eml-lang?label=VS%20Code)](https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/monogate-forge.svg)](https://pypi.org/project/monogate-forge/)
+
+**Forge is the EML language and compiler. Write a math kernel once, compile it to 32 different targets — software, GPU shaders, FPGA RTL, formal-verification proofs, and safety-critical avionics — with chain-order analysis and Lean-checkable contracts on every function.**
+
+---
+
+## Quick start
+
+```bash
+pip install monogate-forge
+```
+
+Create `hello.eml`:
+
+```eml
+module hello;
+
+fn pid(error: Real, integral: Real, derivative: Real) -> Real
+    where chain_order <= 0
+    requires (-1.0 <= error && error <= 1.0)
+    ensures  (-1.5 * 1.0 <= result && result <= 1.5 * 1.0)
+{
+    let kp = 1.0;
+    let ki = 0.2;
+    let kd = 0.3;
+    kp * error + ki * integral + kd * derivative
+}
+```
+
+Compile to every target at once:
+
+```bash
+eml-compile hello.eml --target all -o build/
+```
+
+You now have `build/hello.c`, `build/hello.rs`, `build/hello.py`, `build/hello.lean`, `build/hello.v`, `build/hello.hlsl`, `build/hello.metal`, `build/hello.swift`, … one file per target. Pick a single target instead:
+
+```bash
+eml-compile hello.eml --target rust -o hello.rs
+eml-compile hello.eml --target c    -o hello.c
+eml-compile hello.eml --target lean -o Hello.lean
+```
+
+A snippet of `hello.rs`:
+
+```rust
+#[inline(always)]
+pub fn pid(error: f64, integral: f64, derivative: f64) -> f64 {
+    debug_assert!((-1.0_f64) <= error && error <= 1.0_f64);
+    let kp: f64 = 1.0;
+    let ki: f64 = 0.2;
+    let kd: f64 = 0.3;
+    kp * error + ki * integral + kd * derivative
+}
+```
+
+Five-minute tour: [`docs/quickstart.md`](docs/quickstart.md). Full tutorial: [monogate.dev/learn/eml/intro](https://monogate.dev/learn/eml/intro).
+
+---
+
+## What you get
+
+**32 backends.** Every kernel compiles to all of these from the same source.
+
+### Software (general-purpose)
+| Target | Flag | Tier |
+|---|---|---|
+| C99 | `--target c` | Free |
+| C++17 | `--target cpp` | Free |
+| Rust | `--target rust` | Free |
+| Python 3 | `--target python` | Free |
+| Go | `--target go` | Free |
+| Java | `--target java` | Free |
+| Kotlin | `--target kotlin` | Free |
+| C# | `--target csharp` | Free |
+| JavaScript | `--target javascript` | Free |
+| MATLAB | `--target matlab` | Free |
+| Swift | `--target swift` | Pro |
+
+### Compiler IRs
+| Target | Flag | Tier |
+|---|---|---|
+| WebAssembly | `--target wasm` | Free |
+| LLVM IR | `--target llvm` | Pro |
+
+### GPU shaders
+| Target | Flag | Tier |
+|---|---|---|
+| HLSL (DirectX) | `--target hlsl` | Pro |
+| GLSL (desktop) | `--target glsl` | Pro |
+| GLSL ES | `--target glsles` | Pro |
+| WGSL (WebGPU) | `--target wgsl` | Pro |
+| Metal (Apple) | `--target metal` | Pro |
+
+### Hardware (FPGA / ASIC)
+| Target | Flag | Tier |
+|---|---|---|
+| Verilog | `--target verilog` | Pro |
+| SystemVerilog | `--target systemverilog` | Pro |
+| VHDL | `--target vhdl` | Pro |
+| Chisel / FIRRTL | `--target chisel` | Pro |
+
+### Formal verification
+| Target | Flag | Tier |
+|---|---|---|
+| Lean 4 | `--target lean` | Free |
+| Coq | `--target coq` | Pro |
+| Isabelle/HOL | `--target isabelle` | Pro |
+
+### Safety-critical
+| Target | Flag | Tier |
+|---|---|---|
+| Ada/SPARK | `--target ada` | Pro |
+| AUTOSAR C | `--target autosar` | Pro |
+| AADL | `--target aadl` | Pro |
+| ROS 2 / C++ | `--target ros2` | Pro |
+
+### Gaming
+| Target | Flag | Tier |
+|---|---|---|
+| Luau (Roblox) | `--target luau` | Pro |
+| GDScript (Godot) | `--target gdscript` | Pro |
+
+### Blockchain
+| Target | Flag | Tier |
+|---|---|---|
+| Solidity (PRBMath SD59x18) | `--target solidity` | Pro |
+
+The Free tier — 12 targets covering general-purpose software (C, C++, Rust, Python, Go, Java, Kotlin, C#, JavaScript), web/edge runtimes (WebAssembly), MATLAB, and Lean 4 proofs — is enough to take any EML kernel from your laptop to the browser to a formal proof without a license. A Pro license unlocks the remaining 20: hardware (Verilog, VHDL, SystemVerilog, Chisel, LLVM IR), GPU shaders (HLSL, GLSL, GLSL ES, WGSL, Metal), Apple Swift, safety-critical (Ada, AUTOSAR, AADL, ROS 2), Coq, Isabelle/HOL, Solidity, and gaming (Luau, GDScript). Get a license at [monogateforge.com/get-started](https://monogateforge.com/get-started).
+
+---
+
+## VS Code extension
+
+[![Install](https://img.shields.io/visual-studio-marketplace/d/monogate.eml-lang?label=installs)](https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang)
+
+```
+ext install monogate.eml-lang
+```
+
+LSP features:
+
+- **Chain-order on hover** — every function shows its profiled chain order, cost class, and node count.
+- **Completions** — keywords (`fn`, `let`, `where`, `requires`, `ensures`, `module`, `use`), builtins (`exp`, `ln`, `sin`, `cos`, `sqrt`, `tanh`, `pow`, `clamp`, `eml`, …), stdlib modules.
+- **Diagnostics** — type errors, unbound identifiers, chain-order violations, contract failures.
+- **FPGA status bar** — for any function annotated `@target(fpga)`, the status bar shows estimated LUT / DSP / latency for the selected device.
+- **Format on save** — canonical layout via `eml-fmt`.
+
+Marketplace listing: [monogate.eml-lang](https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang).
+
+---
+
+## Why Forge
+
+Industrial automation today is stuck on ladder logic — Boolean rungs from the 1960s that can't express transcendental functions, can't prove correctness, can't optimize node count, and treat PID loops as black boxes. Structured Text is marginally better but still opaque. MATLAB/Simulink + HDL Coder will get you to FPGA, but the math hides inside vendor library calls and you have no formal proof of precision.
+
+**EML makes every mathematical operation visible, measurable, optimizable, and formally verifiable.** Every expression is an EML tree, every function carries a chain order, every contract becomes a Lean theorem. The same source compiles to your laptop, your microcontroller, your FPGA, your Solidity contract, and your formal proof — and the cross-target equivalence harness verifies they agree to the bit.
+
+---
+
+## Documentation
+
+- [Quickstart](docs/quickstart.md) — pip install to first compile in 5 minutes.
+- [Language reference](docs/language-reference.md) — every keyword, builtin, type, and annotation.
+- [Backends](docs/backends.md) — every compilation target with its CLI flag, file extension, and tier.
+- [Verify guide](docs/verify-guide.md) — `@verify`, `requires`/`ensures`, Lean output, MachLib integration.
+- [FPGA guide](docs/fpga-guide.md) — `@target(fpga)`, LUT/DSP estimates, precision selection, vendor support.
+
+External:
+
+- [monogate.dev/learn/eml/intro](https://monogate.dev/learn/eml/intro) — guided beginner tutorial.
+- [monogate.dev/learn/eml/engineering](https://monogate.dev/learn/eml/engineering) — intermediate engineering course (chain orders, contracts, FPGA targeting, Lean verification).
+- [monogateforge.com/get-started](https://monogateforge.com/get-started) — install the CLI and pick a tier.
+- [monogate.org](https://monogate.org) — research papers and theory.
+- [machlib.org](https://machlib.org) — formal library of mathematical kernels with Lean proofs.
+- [arXiv preprint](https://arxiv.org/) — the EML cost conjecture and Pfaffian profile.
+
+---
+
+## Contributing
+
+See [`CONTRIBUTING.md`](CONTRIBUTING.md). Bug reports and feature requests via GitHub issues.
+
+## License
+
+Compiler is MIT (see [`LICENSE`](LICENSE)). Specific algorithmic methods covered by patents — open implementation, but commercial re-implementations may need a license. See `patents/index.md`.
+
+Built by [Mosa Creates LLC](https://monogateforge.com).

monogate_forge-0.2.0/README.md

@@ -0,0 +1,194 @@
+# Monogate Forge
+
+[![CI](https://github.com/agent-maestro/forge/actions/workflows/ci.yml/badge.svg)](https://github.com/agent-maestro/forge/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/monogate-forge.svg)](https://pypi.org/project/monogate-forge/)
+[![VS Code Marketplace](https://img.shields.io/visual-studio-marketplace/v/monogate.eml-lang?label=VS%20Code)](https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/pypi/pyversions/monogate-forge.svg)](https://pypi.org/project/monogate-forge/)
+
+**Forge is the EML language and compiler. Write a math kernel once, compile it to 32 different targets — software, GPU shaders, FPGA RTL, formal-verification proofs, and safety-critical avionics — with chain-order analysis and Lean-checkable contracts on every function.**
+
+---
+
+## Quick start
+
+```bash
+pip install monogate-forge
+```
+
+Create `hello.eml`:
+
+```eml
+module hello;
+
+fn pid(error: Real, integral: Real, derivative: Real) -> Real
+    where chain_order <= 0
+    requires (-1.0 <= error && error <= 1.0)
+    ensures  (-1.5 * 1.0 <= result && result <= 1.5 * 1.0)
+{
+    let kp = 1.0;
+    let ki = 0.2;
+    let kd = 0.3;
+    kp * error + ki * integral + kd * derivative
+}
+```
+
+Compile to every target at once:
+
+```bash
+eml-compile hello.eml --target all -o build/
+```
+
+You now have `build/hello.c`, `build/hello.rs`, `build/hello.py`, `build/hello.lean`, `build/hello.v`, `build/hello.hlsl`, `build/hello.metal`, `build/hello.swift`, … one file per target. Pick a single target instead:
+
+```bash
+eml-compile hello.eml --target rust -o hello.rs
+eml-compile hello.eml --target c    -o hello.c
+eml-compile hello.eml --target lean -o Hello.lean
+```
+
+A snippet of `hello.rs`:
+
+```rust
+#[inline(always)]
+pub fn pid(error: f64, integral: f64, derivative: f64) -> f64 {
+    debug_assert!((-1.0_f64) <= error && error <= 1.0_f64);
+    let kp: f64 = 1.0;
+    let ki: f64 = 0.2;
+    let kd: f64 = 0.3;
+    kp * error + ki * integral + kd * derivative
+}
+```
+
+Five-minute tour: [`docs/quickstart.md`](docs/quickstart.md). Full tutorial: [monogate.dev/learn/eml/intro](https://monogate.dev/learn/eml/intro).
+
+---
+
+## What you get
+
+**32 backends.** Every kernel compiles to all of these from the same source.
+
+### Software (general-purpose)
+| Target | Flag | Tier |
+|---|---|---|
+| C99 | `--target c` | Free |
+| C++17 | `--target cpp` | Free |
+| Rust | `--target rust` | Free |
+| Python 3 | `--target python` | Free |
+| Go | `--target go` | Free |
+| Java | `--target java` | Free |
+| Kotlin | `--target kotlin` | Free |
+| C# | `--target csharp` | Free |
+| JavaScript | `--target javascript` | Free |
+| MATLAB | `--target matlab` | Free |
+| Swift | `--target swift` | Pro |
+
+### Compiler IRs
+| Target | Flag | Tier |
+|---|---|---|
+| WebAssembly | `--target wasm` | Free |
+| LLVM IR | `--target llvm` | Pro |
+
+### GPU shaders
+| Target | Flag | Tier |
+|---|---|---|
+| HLSL (DirectX) | `--target hlsl` | Pro |
+| GLSL (desktop) | `--target glsl` | Pro |
+| GLSL ES | `--target glsles` | Pro |
+| WGSL (WebGPU) | `--target wgsl` | Pro |
+| Metal (Apple) | `--target metal` | Pro |
+
+### Hardware (FPGA / ASIC)
+| Target | Flag | Tier |
+|---|---|---|
+| Verilog | `--target verilog` | Pro |
+| SystemVerilog | `--target systemverilog` | Pro |
+| VHDL | `--target vhdl` | Pro |
+| Chisel / FIRRTL | `--target chisel` | Pro |
+
+### Formal verification
+| Target | Flag | Tier |
+|---|---|---|
+| Lean 4 | `--target lean` | Free |
+| Coq | `--target coq` | Pro |
+| Isabelle/HOL | `--target isabelle` | Pro |
+
+### Safety-critical
+| Target | Flag | Tier |
+|---|---|---|
+| Ada/SPARK | `--target ada` | Pro |
+| AUTOSAR C | `--target autosar` | Pro |
+| AADL | `--target aadl` | Pro |
+| ROS 2 / C++ | `--target ros2` | Pro |
+
+### Gaming
+| Target | Flag | Tier |
+|---|---|---|
+| Luau (Roblox) | `--target luau` | Pro |
+| GDScript (Godot) | `--target gdscript` | Pro |
+
+### Blockchain
+| Target | Flag | Tier |
+|---|---|---|
+| Solidity (PRBMath SD59x18) | `--target solidity` | Pro |
+
+The Free tier — 12 targets covering general-purpose software (C, C++, Rust, Python, Go, Java, Kotlin, C#, JavaScript), web/edge runtimes (WebAssembly), MATLAB, and Lean 4 proofs — is enough to take any EML kernel from your laptop to the browser to a formal proof without a license. A Pro license unlocks the remaining 20: hardware (Verilog, VHDL, SystemVerilog, Chisel, LLVM IR), GPU shaders (HLSL, GLSL, GLSL ES, WGSL, Metal), Apple Swift, safety-critical (Ada, AUTOSAR, AADL, ROS 2), Coq, Isabelle/HOL, Solidity, and gaming (Luau, GDScript). Get a license at [monogateforge.com/get-started](https://monogateforge.com/get-started).
+
+---
+
+## VS Code extension
+
+[![Install](https://img.shields.io/visual-studio-marketplace/d/monogate.eml-lang?label=installs)](https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang)
+
+```
+ext install monogate.eml-lang
+```
+
+LSP features:
+
+- **Chain-order on hover** — every function shows its profiled chain order, cost class, and node count.
+- **Completions** — keywords (`fn`, `let`, `where`, `requires`, `ensures`, `module`, `use`), builtins (`exp`, `ln`, `sin`, `cos`, `sqrt`, `tanh`, `pow`, `clamp`, `eml`, …), stdlib modules.
+- **Diagnostics** — type errors, unbound identifiers, chain-order violations, contract failures.
+- **FPGA status bar** — for any function annotated `@target(fpga)`, the status bar shows estimated LUT / DSP / latency for the selected device.
+- **Format on save** — canonical layout via `eml-fmt`.
+
+Marketplace listing: [monogate.eml-lang](https://marketplace.visualstudio.com/items?itemName=monogate.eml-lang).
+
+---
+
+## Why Forge
+
+Industrial automation today is stuck on ladder logic — Boolean rungs from the 1960s that can't express transcendental functions, can't prove correctness, can't optimize node count, and treat PID loops as black boxes. Structured Text is marginally better but still opaque. MATLAB/Simulink + HDL Coder will get you to FPGA, but the math hides inside vendor library calls and you have no formal proof of precision.
+
+**EML makes every mathematical operation visible, measurable, optimizable, and formally verifiable.** Every expression is an EML tree, every function carries a chain order, every contract becomes a Lean theorem. The same source compiles to your laptop, your microcontroller, your FPGA, your Solidity contract, and your formal proof — and the cross-target equivalence harness verifies they agree to the bit.
+
+---
+
+## Documentation
+
+- [Quickstart](docs/quickstart.md) — pip install to first compile in 5 minutes.
+- [Language reference](docs/language-reference.md) — every keyword, builtin, type, and annotation.
+- [Backends](docs/backends.md) — every compilation target with its CLI flag, file extension, and tier.
+- [Verify guide](docs/verify-guide.md) — `@verify`, `requires`/`ensures`, Lean output, MachLib integration.
+- [FPGA guide](docs/fpga-guide.md) — `@target(fpga)`, LUT/DSP estimates, precision selection, vendor support.
+
+External:
+
+- [monogate.dev/learn/eml/intro](https://monogate.dev/learn/eml/intro) — guided beginner tutorial.
+- [monogate.dev/learn/eml/engineering](https://monogate.dev/learn/eml/engineering) — intermediate engineering course (chain orders, contracts, FPGA targeting, Lean verification).
+- [monogateforge.com/get-started](https://monogateforge.com/get-started) — install the CLI and pick a tier.
+- [monogate.org](https://monogate.org) — research papers and theory.
+- [machlib.org](https://machlib.org) — formal library of mathematical kernels with Lean proofs.
+- [arXiv preprint](https://arxiv.org/) — the EML cost conjecture and Pfaffian profile.
+
+---
+
+## Contributing
+
+See [`CONTRIBUTING.md`](CONTRIBUTING.md). Bug reports and feature requests via GitHub issues.
+
+## License
+
+Compiler is MIT (see [`LICENSE`](LICENSE)). Specific algorithmic methods covered by patents — open implementation, but commercial re-implementations may need a license. See `patents/index.md`.
+
+Built by [Mosa Creates LLC](https://monogateforge.com).

monogate_forge-0.2.0/examples/README.md

@@ -0,0 +1,49 @@
+# Forge examples
+
+Small, public `.eml` files that demonstrate language features
+without revealing proprietary kernel content. Ship with the
+PyPI wheel; reference these from the README, docs, and live
+demo gallery.
+
+## Quick tour
+
+| File | Chain order | Teaches |
+|---|---:|---|
+| `hello.eml` | 0 | Module declaration, function, literal return |
+| `lerp.eml` | 0 | Polynomial body, multiple inputs |
+| `quadratic.eml` | 0 | `a*x^2 + b*x + c` — the canonical chain-0 polynomial |
+| `pid_controller.eml` | 0 | `requires` / `ensures` clamp contract |
+| `clamp_bounded.eml` | 0 | `clamp` builtin + `@verify` postcondition |
+| `verified_add.eml` | 0 | The smallest `@verify` shape (two `requires`, one `ensures`) |
+| `smoothstep.eml` | 0 | Polynomial smoothing curve with `@verify` |
+| `exponential_decay.eml` | 1 | `exp(-k*t)` — the chain-1 archetype |
+| `sine_oscillator.eml` | 1 | `sin(omega*t)` with amplitude `@verify` |
+| `gaussian.eml` | 1 | `exp(-(x-mu)^2/...)` — the bell curve |
+| `sigmoid.eml` | 2 | `1 / (1 + exp(-x))` — the chain-2 ML activation |
+| `damped_wave.eml` | 2 | `exp(-zeta*t) * sin(omega*t)` — the chain-2 archetype |
+
+## Running
+
+Every file compiles to every backend in your tier:
+
+```bash
+# Free tier — 12 backends
+eml-compile examples/hello.eml --target python
+eml-compile examples/pid_controller.eml --target rust
+eml-compile examples/sigmoid.eml --target lean
+
+# Compile all Free targets at once
+eml-compile examples/damped_wave.eml --target all
+```
+
+## What's not here
+
+The full kernel library — aerospace flight control, automotive
+powertrain, medical infusion, robotics, crypto, gaming, and a
+dozen more domains — is the proprietary product. It ships with
+Forge Pro plans at <https://monogateforge.com/get-started>.
+
+The compiler is open. The kernels are the product. Anyone can
+write their own `.eml`, profile it with `eml-cost`, and compile
+to any of the 32 backends. The pre-verified domain library is
+what's gated.

monogate_forge-0.2.0/examples/__init__.py

@@ -0,0 +1,17 @@
+"""Forge example .eml files (bundled with the PyPI wheel).
+
+This package exists only so setuptools.find can pick up the
+examples/ directory and ship its .eml content alongside the
+compiler. There is no Python code here -- treat the .eml
+files as data, accessible via importlib.resources:
+
+    from importlib.resources import files
+    eml_text = files("examples").joinpath("hello.eml").read_text()
+
+For interactive use, just:
+
+    eml-compile examples/hello.eml --target python
+
+from a Forge checkout, or copy the files out of the wheel
+install path.
+"""

monogate_forge-0.2.0/examples/clamp_bounded.eml

@@ -0,0 +1,20 @@
+// clamp_bounded.eml -- clamp a real to a fixed interval and
+// prove the output lives there. The simplest non-trivial
+// `@verify` example: a precondition-free contract whose
+// postcondition follows from the body's structure.
+//
+// Chain order 0 -- `clamp` is a builtin rational primitive.
+
+module clamp_bounded;
+
+const LO: Real = -1.0
+const HI: Real =  1.0
+
+@verify(lean, theorem = "clamp_in_unit_interval")
+fn clamp_unit(x: Real) -> Real
+    where chain_order <= 0
+    ensures  (result >= LO)
+    ensures  (result <= HI)
+{
+    clamp(x, LO, HI)
+}

monogate_forge-0.2.0/examples/damped_wave.eml

@@ -0,0 +1,20 @@
+// damped_wave.eml -- exp * sin, the chain-2 archetype.
+//
+//   y(t) = exp(-zeta * t) * sin(omega * t)
+//
+// The bedrock damped oscillation. Two transcendentals nested
+// over polynomial arguments -- chain order 2. This shape
+// describes a settling spring, a reverb tail, a relaxation
+// curve, and the impulse response of a second-order linear
+// system.
+
+module damped_wave;
+
+fn damped_wave(zeta: Real, omega: Real, t: Real) -> Real
+    where chain_order <= 2
+    requires (zeta  >= 0.0)
+    requires (omega >= 0.0)
+    requires (t     >= 0.0)
+{
+    exp(-zeta * t) * sin(omega * t)
+}

monogate_forge-0.2.0/examples/exponential_decay.eml

@@ -0,0 +1,18 @@
+// exponential_decay.eml -- the canonical chain-1 example.
+//
+//   y(t) = exp(-k * t)
+//
+// One transcendental (exp) wrapped around a polynomial argument:
+// chain order 1. The same shape governs RC discharge, radioactive
+// decay, lossy reverb tails, and Adam's first-moment bias term --
+// the structural class is the same across every domain.
+
+module exponential_decay;
+
+fn decay(k: Real, t: Real) -> Real
+    where chain_order <= 1
+    requires (k >= 0.0)
+    requires (t >= 0.0)
+{
+    exp(-k * t)
+}

monogate_forge-0.2.0/examples/gaussian.eml

@@ -0,0 +1,18 @@
+// gaussian.eml -- the bell curve.
+//
+//   p(x; mu, sigma) = (1/sigma) * exp(-((x-mu)^2 / (2*sigma^2)))
+//
+// Chain order 1 in EML's structural sense: one transcendental
+// (exp) wrapping a polynomial argument. Shows up in statistics,
+// ML loss landscapes, image filters, antenna patterns, and
+// quantum harmonic oscillators -- the same EML genome each time.
+
+module gaussian;
+
+fn gaussian(mu: Real, sigma: Real, x: Real) -> Real
+    where chain_order <= 1
+    requires (sigma > 0.0)
+{
+    let dx = x - mu;
+    exp(-dx * dx / (2.0 * sigma * sigma)) / sigma
+}

monogate_forge-0.2.0/examples/hello.eml

@@ -0,0 +1,17 @@
+// hello.eml -- the smallest possible Forge program.
+//
+// One module, one function, no inputs, returns a constant.
+// Chain order 0 because the body is a literal.
+//
+// Compile this to anything:
+//   eml-compile examples/hello.eml --target python
+//   eml-compile examples/hello.eml --target rust
+//   eml-compile examples/hello.eml --target verilog
+
+module hello;
+
+fn answer() -> Real
+    where chain_order <= 0
+{
+    42.0
+}

monogate_forge-0.2.0/examples/lerp.eml

@@ -0,0 +1,14 @@
+// lerp.eml -- linear interpolation. The "hello world" of math
+// in graphics, animation, and signal processing.
+//
+//   lerp(a, b, t) = a + t * (b - a)
+//
+// Chain order 0: the body is a polynomial in the inputs.
+
+module lerp;
+
+fn lerp(a: Real, b: Real, t: Real) -> Real
+    where chain_order <= 0
+{
+    a + t * (b - a)
+}

monogate_forge-0.2.0/examples/pid_controller.eml

@@ -0,0 +1,30 @@
+// pid_controller.eml -- the textbook PID controller.
+//
+//   output = Kp * error + Ki * integral + Kd * derivative
+//
+// Universal control loop: heating, motors, robots, drones,
+// rockets. Chain order 0 (a linear combination of the inputs).
+// The interesting part is the @verify contract: the output is
+// always clamped to the actuator's physical range.
+
+module pid_controller;
+
+const Kp: Real = 1.5
+const Ki: Real = 0.4
+const Kd: Real = 0.05
+
+const OUT_MIN: Real = -1.0
+const OUT_MAX: Real =  1.0
+
+@verify(lean, theorem = "pid_output_clamped")
+fn pid(error: Real, integral: Real, derivative: Real) -> Real
+    where chain_order <= 0
+    requires (abs(error)      <= 100.0)
+    requires (abs(integral)   <= 100.0)
+    requires (abs(derivative) <= 100.0)
+    ensures  (result >= OUT_MIN)
+    ensures  (result <= OUT_MAX)
+{
+    let raw = Kp * error + Ki * integral + Kd * derivative;
+    clamp(raw, OUT_MIN, OUT_MAX)
+}