tric-proof

What the company appears to be: tric-proof is a self-reported standalone proof assistant built in C++. The author describes it as verifying readable proofs end-to-end with independent checking, replayable evidence, and precise diagnostics. It uses a novel mathematical substrate called Typed Ranked Incidence Complex (TRIC) and is part of a longer-term vision involving formal verification systems that connect source-code semantics, compiler transformations, proof obligations, and checked evidence.

What changed: The project evolved from academic research into a practical tool for theorem proving. It was developed collaboratively with AI models, using a non-traditional architecture that avoids conventional tokenizer–parser–AST pipelines in favor of direct-lowering design principles.

Single most important open question: Is there any evidence of traction, revenue, or customer adoption beyond the author's own development and self-description?

Note: This analysis is based entirely on the self-reported, unverified description provided by the author. No third-party corroboration, archived data, or independent verification exists for any claims made.

The description states that tric-proof is a standalone proof assistant that verifies proofs written in a readable surface language from end to end. It supports:

• Checking one or more proof files;
• Reporting precise source-positioned diagnostics;
• Formatting proof source;
• Publishing and replaying checked proof bundles;
• Querying verified theorems and their dependencies;
• Supporting controlled proof re-derivation.

The system uses a verification path involving:

1. Source → Coarse TRIC structure
2. Proof-specific lowering
3. Independent checking
4. Replayable evidence

It includes features such as dependent proof terms, equality reasoning, tactics, modules, notation, and a small generic constructor/eliminator framework for natural numbers and lists.

Evidence: The author describes the functionality in detail, but no external validation or usage data is provided.

The author positions tric-proof as a proof assistant that verifies readable proofs end to end, emphasizing independent checking, replayable evidence, and precise diagnostics. It is described as part of a broader vision for formal verification systems connecting compiler transformations and proof obligations.

Key claims include:

• The project builds on the Typed Ranked Incidence Complex (TRIC), a shared mathematical substrate.
• It aims to integrate with a C++ compiler frontend into a formal-verification system.
• The goal is to support agentic coding, where agents need trustworthy ways to understand, transform, and verify large software systems.

There is no indication of prior positioning or evolution beyond the current self-description.

Evidence: Claims are made by the author only; no evidence of market positioning, branding, or prior versions is available.

The description does not identify a specific target customer or Ideal Customer Profile (ICP). The author focuses on the technical architecture and theoretical underpinnings rather than user personas or use cases beyond academic or research contexts.

However, the author implies that the tool may be useful for:

• Developers working in formal verification;
• Researchers exploring TRIC-based systems;
• AI agents needing trustworthy proof-checking infrastructure.

No explicit customer segments, adoption metrics, or early users are mentioned.

Evidence: Not evidenced. The description lacks any reference to target customers or ICP.

There is no evidence in the description of a business model or pricing strategy. The author describes tric-proof as a standalone tool but does not indicate whether it will be offered for free, sold, licensed, or monetized in any way.

Evidence: Not evidenced.

The implementation is written in modern C++, and the architecture includes three focused layers:

1. TRIC layer (typed, ranked incidence substrate);
2. compiler-kit layer (grammarlet, fixed-point execution, lowering, structural analysis);
3. compiler-proof layer (coarse grammar, full grammar, candidate analysis).

Key technical design principles include:

• Avoiding traditional tokenizer–parser–AST pipeline;
• Using coarse grammarlets to recover structure, then proof-specific lowerers;
• Supporting controlled proof re-derivation;
• Ensuring independent checking of declarations, terms, environments, dependencies, certificates, and capabilities.

The author also mentions using AI models (GPT-5.5 and GPT-5.6) for development, including parallel research, review, and implementation roles.

Evidence: The description provides a detailed account of the technical stack and architecture, but no evidence of delivery performance or scalability.

There is no evidence of traction, revenue, customers, or adoption beyond the author’s own development efforts. The project is described as a personal research effort with a team size of one (Ognian Milanov). No external validation, user feedback, or product usage data are provided.

Evidence: Not evidenced.

The description does not mention competitors, nor does it place tric-proof within an existing marketplace or ecosystem. The author focuses on the unique theoretical foundation (TRIC) and architecture rather than comparing with other tools in the space.

Evidence: Not evidenced.

Several potential risks and red flags are present based on the self-reported description:

• Lack of traction or adoption: No evidence of users, customers, or revenue.
• Highly specialized domain: TRIC is a niche mathematical concept; limited mainstream applicability.
• Single-person development: With only one team member, scalability and long-term maintenance are uncertain.
• Unproven market fit: The author’s vision involves future integration with a C++ frontend, but no current commercial or practical deployment exists.
• AI dependency: Heavy reliance on AI models for development raises questions about reproducibility and control.

Inference: These points are drawn from the lack of evidence for key business signals and the highly experimental nature of the project as described.

1. What specific problems in formal verification or theorem proving does tric-proof aim to solve, and how do you know these problems exist?
2. Are there any early adopters or users who have tested the tool? If so, what feedback did they provide?
3. How is the TRIC-based architecture different from existing proof assistants like Coq, Lean, or Isabelle, and why would someone choose tric-proof over them?
4. What are the key milestones in your roadmap for integrating with a C++ compiler frontend?
5. Can you describe any concrete use cases where tric-proof has been applied beyond personal development?
6. How do you plan to scale beyond single-person development?
7. What is the expected timeline for reaching a production-ready version?