Data

Tools

Indexes

Applications

Experiments

Awesome

An open API service indexing awesome lists of open source software.

https://github.com/groupoid/axio

🧊 Методологія верифікації теорем
https://github.com/groupoid/axio

Last synced: 4 months ago
JSON representation

🧊 Методологія верифікації теорем

Awesome Lists containing this project

README 

          
AXIO/1


Artificial Experienced Intelligent Ontology v10.0 (2025)



    

      
  • Українською: Штучна Досвідчена Інтелектуальна Онтологія
    • 

      
  • Тибетською: བཟོ་བཀོད་ཀྱི་ཉམས་ཡོད་པའི་རིག་པའི་ངོ་བོ་ལུགས། (bzo bkod kyi nyams yod pa'i rig pa'i ngo bo lugs)
    • 




Table of Contents (དཀར་ཆག dkar chag)


    

        
  • Introduction
    • 

        
  • Process
    • 

        
  • Components
    • 

        
  • Operators
    • 

        
  • Refinments
    • 

        
  • Goals
    • 

        
  • Runtime Languages
    • 

        
  • Higher Languages
    • 




1. Introduction (ངོ་སྤྲོད ngo sprod)


The AXIO/1 Framework is a layered system for infinite reasoning, structured into:


    

        
  • 

    Runtime Languages: Execute computations and manage concurrency.
    • 

        
  • 

    Higher Languages: Handle theorem proving and formal verification.
    • 



This framework operates as a cyclic, iterative system for formal reasoning,

   where an operator (human, AI, or hybrid) directs a process that continuously refines itself.



2. Process (ལས་ཀ las ka)


AXIO/1 follows a structured flow:


    

        
  1. 

    Conditions: Foundational elements (Axioms, Definitions, Types, Propositions, Syntax).
    2. 

        
  2. 

    Environment: The structured setting (Model, Consistency, Completeness, Library).
    3. 

        
  3. 

    Thinking: Reasoning mechanisms (Hypotheses, Computation, Deduction, Conjecture, Inference Rules, General Induction).
    4. 

        
  4. 

    Fruit: Logical results (Proof, Judgment, Theorem).
    5. 

        
  5. 

    Insight: Higher-level understanding (Semantics, Categorical Frameworks, Abstraction).
    6. 




3. Components (ཆ་ཤས cha shas)



Condition (C) རྐྱེན Умова rkyen



    C = (A, D, T, P, X)



    

        
  • 

    Axioms (A): Fundamental truths.
    • 

        
  • 

    Definitions (D): Precise descriptions of entities.
    • 

        
  • 

    Types (T): Categorization of objects.
    • 

        
  • 

    Syntax (X): Structural rules.
    • 




Environment (E) ཁོར་ཡུག Середовище khor yug 



    E = (M, C, K, L)



    

        
  • 

    Model (M): Formal representation of the system.
    • 

        
  • 

    Consistency (C): No contradictions within the system.
    • 

        
  • 

    Completeness (K): The extent to which all truths can be derived.
    • 

        
  • 

    Library (L): Repository of known results.
    • 




Reason (T) རྒྱུ Причина rgyu 



    T = (J, H, C, D, G)



    

        
  • 

    Judgment (J): Logical assertions.
    • 

        
  • 

    Hypotheses (H): Presupposition, Assumption, Supposition, Proposition.
    • 

        
  • 

    Computation (C): Lambda Calculus, Pi-Calculus.
    • 

        
  • 

    Deduction (D): Inference Rules, General Induction.
    • 

        
  • 

    Conjecture/Assertion (G): Formulation of potential truths.
    • 




Fruit (F) འབྲས་བུ Плід 'bras bu



    F = (⊢,Θ)



    

        
  • 

    Proof ⊢ Verified propositions.
    • 

        
  • 

    Theorem Θ Established truths.
    • 




Insight (I) ལྟ་བའི་ཤེས་པ lta ba'i shes pa



    I = (S, C, A)



    

        
  • 

    Semantics Σ: Meaning assignment.
    • 

        
  • 

    Categorical Frameworks  C: High-level abstractions..
    • 

        
  • 

    Abstraction A: Generalization of concepts.
    • 




3. Operators (བཀོལ་སྤྱོད་པ bkol spyod pa) 


Three types of operators drive the system:


    

        
  • 

    Human: Chooses propositions, interprets insights, and guides conjectures.
    • 

        
  • 

    Machine: Automates computations, checks consistency, and suggests hypotheses.
    • 

        
  • 

    Hybrid: Human sets goals, machine executes reasoning steps.
    • 




4. Refinements (ལེགས་བཅོས legs bcos) 


Ensuring correctness and progression:


    

        
  • 

    Infinite Thinking: Achieved via iteration Sₙ → ∞.
    • 

        
  • 

    Finite Steps: Each step is discrete, Sₙ → Sₙ₊₁.
    • 

        
  • 

    Operator-Driven: The direction of reasoning is controlled by O.
    • 




The cycle repeats indefinitely, refining knowledge.



    S₀ → S₁ → S₂ → ... → Sₙ → Sₙ₊₁ → ...



Where:


    

        
  • 

    Sₙ is a finite reasoning step.
    • 

        
  • 

    Sₙ₊₁ builds upon Sₙ, ensuring refinement.
    • 

        
  • 

    Limit process: lim (n → ∞) Sₙ represents infinite reasoning.
    • 




5. Design Goals (དམིགས་ཡུལ dmigs yul)


    

        
  • 

    Runtime Languages: Handle computation and concurrency.
    • 

        
  • 

    Higher Languages: Ensure theorem proving and soundness.
    • 

        
  • 

    Infinite Thinking: Achieved via refinements cycles.
    • 

        
  • 

    Operator-Driven: Collaboration between humans and machines.
    • 




## Runtime Languages (ལག་ལེན་གྱི་སྐད lag len gyi skad)



### Joe



Role: Certified bytecode stack interpreter and compiler to Intel/ARM.

Features: Executes Lambda Calculus terms as bytecode, compiles to native code.

Fit: Computes concrete results. Certified for reliability.

Use Case: Operator runs algebraic steps or tests hypotheses on hardware.



### Bob



Role: Parallel, concurrent, non-blocking, zero-copy runtime with CAS cursors (compare-and-swap).

Features: Implements Pi-Calculus-style concurrency, optimized for matrix operations (BLAS-like).

Fit: Manages distributed validation across nodes, computes in parallel (e.g., parity table cases).

Use Case: Operator coordinates multi-threaded proof checks or simulations.



### Alice



Role: Linear types calculus with partial fractions for BLAS level 3 programming.

Features: Ensures resource safety (linear types), optimizes matrix computations (e.g., tensor products).

Fit: Handles complex (e.g., matrix-based proofs), enforces no redundant copies.

Use Case: Operator proves theorems involving linear algebra or tensor structures.



## Higher Languages (མཐོ་རིམ་གྱི་སྐད mtho rim gyi skad)



### Henk



Role: Pure Type System (PTS-91), Calculus of Constructions (CoC-88), infinite universes, AUTOMATH-68 syntax.

Features: Flexible typing.

Use Case: Operator formalizes recursive or foundational proofs.

Rationale: Henk subsumes Alonzo’s STLC with richer types, making it a strong starting point.



### Per



Role: ΠΣ (MLTT-72) prover with CoC, identity types (MLTT-75), well-founded trees (MLTT-80).

Features: Dependent types, equality proofs.

Fit: Proves (e.g., "parity preservation"), ensures consistency.

Use Case: Operator handles equality or model-specific theorems.



### Frank



Role: Pure Lambda (CoC-88, PTS-91) + Inductive Constructions (CIC-89).

Features: Dependent types, equality proofs.

Fit: Proves (e.g., "parity preservation"), ensures consistency.

Use Case: Operator handles equality or model-specific theorems.



### Christine



Role: ΠΣ (MLTT-72) prover with CoC, identity types (MLTT-75), extended to CIC (IND-89).

Features: Dependent types, equality proofs.

Fit: Proves (e.g., "parity preservation"), ensures consistency.

Use Case: Operator handles equality or model-specific theorems.



### Anders



Role: Homotopy Type System (HTS-2013) with Strict Equality and Cubical Agda (CCHM-2016).

Features: Higher-dimensional types, paths, cubical primitives.

Fit: Extracts (e.g., "parity as a homotopy group"), builds cat.

Use Case: Operator abstracts to categorical or topological structures.



### Dan



Role: Simplicial CCHM-based system, replacing Rzk/GAP.

Features: Simplicial types, primitives (Simplex, Chain, Monoid, Category, Group).

Fit: Formalizes cat (e.g., "parity as a monoid"), verifies geometric proofs.

Use Case: Operator proves simplicial or algebraic topology insights.



### Jack 



Role: A Framework for Chromatic Homotopy Theory and K-Theory.

Features: Hopf Fibrations, Suspensions, Truncations, Π, Σ, Id, ℕ, ℕ∞.

Use Case: Operator links proofs to topological or physical systems.



### Urs



Role: A Framework for Supergeometry in Cohesive Topos.

Features: Hopf Fibrations, Suspensions, Truncations, Π, Σ, Id, ℕ, ℕ∞.

Use Case: Operator links proofs to topological or physical systems.



### Fabien



Role: Motivic A^1-Homotopy Theory.

Featues: Π,Σ,Path,𝑘:𝑈,0_𝑘,1_𝑘,point_𝑘,𝐴^1:U,point:𝑘→𝐴^1., a1contr, 𝐿_{A^1}:U→𝑈, 𝜂_{A^1}, rec_{A^1}, n-Trunc, 𝑁, Suspension,S^{1,1}.

Use case: derives all structural theorems of A^1-Homotopy Theory—such as A^1-connectivity (X×A^1)≅π_n(A^1), contractibility

of 𝐴^1, and unstable connectivity — while providing a foundation for stable A^1-homotopy via suspensions and motivic spheres.



### Laurent



Role: Mathematical and Functional Analysis, Calculus.

Features: ℝ, C, Nat, Boo, Forall, Exists, Set, Measure, Lebesgue. Seq, Inf, Sup, Lim.

Use case: Real Analysis, Functional Analysis.



### Ernst 



Role: ZFC LEM theories.

Features: 𝑉, Pow(𝐴), 𝑥 ∈ 𝐴, 𝐴 ⊆ 𝐵; LEM: ⊢ 𝑃 ∨ ¬𝑃

Use case: Classical Logic Support.



### Paul 



Role: Forced Cardinals.

Features: ⊢ 𝜅 : Card, inaccessible(𝜅), measurable(𝜅), Force(𝑃, 𝐺) : 𝑉 → 𝑉, 𝑝 ⊩ 𝜙

Use case: Generic filter 𝐺 over a poset 𝑃, yielding a new model 𝑉[𝐺], adjoin reals and control cardinalities or axioms.



## AXIOSIS



Axiomatic Extended Integrated Ordered System for Infinite Structures is a novel type theory engineered

to mechanically verify all existing theorems across mathematics, from classical analysis to modern set

theory and homotopy. Building on top of advanced frameworks:



* **Henk Barendregt** Type Theory for Pure Dependent Lambda Calculus,

* **Per Martin-Löf** Type Theory for Fibrational setting and inductive types,

* **Anders Mörtberg** Type Theory for CCHM/CHM/HTS bootstrap,

* **Dan Kan** Simplicial HoTT,

* **Jack Morava** Type Theory for Chromatic Homotopy Theory and K-Theory,

* **Urs Schreiber** Type Theory for Equivariant Supergeometry,

* **Fabien Morel** Type Theory for A¹-homotopy theory,

* **Laurent Schwartz** Type Theory for Functional Analysis and Calculus,

* **Ernst Zermelo** Type Theory for ZFC with LEM, and

* **Paul Cohen** Type Theory for cardinals system incorporating large cardinals and forcing



this system synthesis unifies synthetic homotopy, stable homotopy spectra, cohesive geometry, real analysis,

and set-theoretic foundations into a single, computationally verifiable formalism. We demonstrate its

power through key theorems:



* Number Theory: Prime Number Theorem

* Fundamental Theorem of Calculus (Analysis):

* Analysis: Lebesgue Dominated Convergence Theorem

* Topology: Poincaré Conjecture (3D)

* Algebra: Classification of Finite Simple Groups

* Set Theory: Independence of the Continuum Hypothesis (CH)

* Category Theory: Adjoint Functor Theorem

* Homotopy Theory: Adams Conjecture (via K-theory)

* Consistency of ZFC with Large Cardinals

* Fermat’s Last Theorem

* Large Cardinal Theorem: Martin’s Maximum



showcasing its ability to span algebraic, analytic, topological, and

foundational domains. AXIOSIS stands as a candidate for a universal mechanized mathematics platform,

rivaling systems like Cubical Type Theory while extending their scope.



AXIOSIS achieves a landmark synthesis, unifying synthetic and classical mathematics in a mechanically

verifiable framework. Its type formers—spanning simplicial ∞-categories, stable spectra, cohesive modalities,

reals, ZFC, large cardinals, and forcing — cover all known mathematical domains as of 2025.



## Monography



* Compilation: https://axiosis.github.io/books/axio/axio.pdf

* Github Organization: https://github.com/groupoid/



## LaTeX 



```

$ cp *.ttf ~/.local/share/fonts

$ sudo apt install texlive-full

$ sudo fc-cache -f

$ fc-match Geometria

$ make

```



## Sole Copyright



Namdak Tonpa