Update README.md

README.md

@@ -1,15 +1,31 @@
 # Helion-OSC
 
-**DeepXR/Helion-OSC** is a coding language model with strong mathematical reasoning capabilities.
+## 1. Introduction
 
-## What It Does
+Helion-OSC (Optimized Semantic Compiler) is a specialized language model designed for code generation and mathematical reasoning. Unlike traditional coding models that focus solely on generating correct outputs, Helion-OSC emphasizes verifiable reasoning processes and rigorous step-by-step derivations. The model combines deep mathematical understanding with practical programming capabilities across multiple languages.
 
-- Code generation across multiple programming languages
-- Mathematical problem solving
+Helion-OSC addresses a fundamental challenge in AI-assisted programming: correct code doesn't always mean correct reasoning. By focusing on both the solution and the logical path to reach it, the model provides transparent, verifiable code generation that developers can trust and understand. This makes it particularly suitable for complex algorithmic tasks, mathematical computing, and applications where code correctness and maintainability are critical.
+
+The model demonstrates strong capabilities in:
+- Multi-language code generation (Python, JavaScript, C++, Java, Rust, Go, SQL)
+- Mathematical problem solving and theorem proving
 - Algorithm design and optimization
-- Code debugging and improvement
+- Code debugging with detailed explanations
+- Step-by-step reasoning for complex problems
+
+## 2. Capabilities
+
+Helion-OSC excels at:
+
+**Code Generation**: Produces syntactically correct and logically sound code across multiple programming languages with emphasis on readability and best practices.
+
+**Mathematical Reasoning**: Solves mathematical problems through verifiable step-by-step derivations, supporting everything from basic arithmetic to advanced calculus and discrete mathematics.
+
+**Algorithm Design**: Creates efficient algorithms with detailed explanations of time and space complexity, making it ideal for competitive programming and technical interviews.
 
-## Usage
+**Code Optimization**: Analyzes existing code and suggests improvements for performance, readability, and maintainability while preserving functionality.
+
+## 3. Quick Start
 
 ```python
 from transformers import AutoTokenizer, AutoModelForCausalLM
@@ -18,26 +34,35 @@ model_name = "DeepXR/Helion-OSC"
 tokenizer = AutoTokenizer.from_pretrained(model_name)
 model = AutoModelForCausalLM.from_pretrained(model_name)
 
-prompt = "Write a Python function to calculate Fibonacci numbers:"
+# Code generation example
+prompt = "Write a Python function to implement quicksort with detailed comments:"
 inputs = tokenizer(prompt, return_tensors="pt")
-outputs = model.generate(**inputs, max_length=200)
+outputs = model.generate(**inputs, max_length=512)
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
 
-## Model Details
+For advanced inference configurations and optimization, refer to the `inference.py` script included in this repository.
+
+## 4. Model Details
 
 - **Developed by**: DeepXR
-- **Model Type**: Coding Language Model
-- **Languages**: Python, JavaScript, C++, Java, Rust, and more
+- **Model Type**: Causal Language Model (Coding-Specialized)
+- **Languages Supported**: Python, JavaScript, TypeScript, C++, Java, Rust, Go, SQL
+- **Context Length**: 8192 tokens
+- **License**: Apache License, Version 2.0
+
+## 5. License
 
-## Citation
+This repository and the model weights are licensed under the Apache License, Version 2.0 (Apache 2.0).
+
+## 6. Citation
 
 ```bibtex
 @misc{helion-osc-2025,
   author = {DeepXR},
-  title = {Helion-OSC: Coding Language Model},
+  title = {Helion-OSC: Optimized Semantic Compiler for Code Generation and Mathematical Reasoning},
   year = {2025},
   publisher = {HuggingFace},
   url = {https://huggingface.co/DeepXR/Helion-OSC}
 }
-```
+```