ddddd

README.md

@@ -1,7 +1,7 @@
 ---
-title: Mathematics Question Generator
-emoji: 🧮
-colorFrom: blue
+title: Math
+emoji: 🌍
+colorFrom: indigo
 colorTo: green
 sdk: gradio
 sdk_version: 5.29.0
@@ -9,36 +9,4 @@ app_file: app.py
 pinned: false
 ---
 
-# Mathematics Question Generator
-
-This application generates customized mathematics questions on any topic you specify. Simply enter a mathematics chapter or concept you want to practice, and the AI will create questions with step-by-step solutions.
-
-## Features
-
-- Generate mathematics questions on any topic
-- Choose the number of questions (1-10)
-- Select difficulty level (elementary to advanced)
-- View detailed step-by-step solutions
-
-## How to Use
-
-1. Enter a mathematics topic (e.g., "Linear Algebra: Eigenvalues", "Calculus: Integration")
-2. Adjust the number of questions and difficulty level as needed
-3. Click "Generate Questions"
-4. Study the generated questions and their solutions
-
-## Setup Requirements
-
-This application requires a Hugging Face API token with access to the DeepSeek models. To set up your token:
-
-1. Generate a Hugging Face API token with read access from [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
-2. Add this token to your Space as a secret with the key `HUGGINGFACE_TOKEN`
-   - Go to your Space settings
-   - Click on "Secrets"
-   - Add a new secret with name `HUGGINGFACE_TOKEN` and your token as the value
-
-## About
-
-This application uses DeepSeek's mathematics-focused language model to generate high-quality mathematics questions tailored to your learning needs.
-
-Created by Kamagelo Mosia
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,396 +1,403 @@
-import os
-import torch
+import gradio as gr
+import random
 import json
-import time
-import logging
+import tempfile
+import os
 from datetime import datetime
-from threading import Thread
-from queue import Queue
-from transformers import AutoTokenizer, AutoModelForCausalLM
 
-# Configuration
-PRIMARY_MODEL = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"  # First model to try
-SECONDARY_MODEL = "facebook/opt-1.3b"  # More powerful backup model
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-BATCH_SIZE = 5  # Process 5 chapters at a time
-MAX_RETRIES = 3
-OUTPUT_DIR = "calculus_textbook_output"
-LOG_FILE = "textbook_generation.log"
-
-# Setup logging
-os.makedirs(OUTPUT_DIR, exist_ok=True)
-logging.basicConfig(
-    filename=os.path.join(OUTPUT_DIR, LOG_FILE),
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
+# Define a comprehensive list of calculus topics based on James Stewart's textbook
+TOPICS = {
+    "Limits and Continuity": {
+        "formula": "For a function $f(x)$, $\\lim_{x \\to a} f(x) = L$",
+        "functions": {
+            "easy": [
+                {"func": "$\\lim_{x \\to 2} (3x+4)$", "domain": ["$x \\to 2$"], "solution": "$10$"},
+                {"func": "$\\lim_{x \\to 0} \\frac{\\sin(x)}{x}$", "domain": ["$x \\to 0$"], "solution": "$1$"},
+                {"func": "$\\lim_{x \\to 3} (x^2-5x+2)$", "domain": ["$x \\to 3$"], "solution": "$-4$"},
+                {"func": "$\\lim_{x \\to 1} \\frac{x^2-1}{x-1}$", "domain": ["$x \\to 1$"], "solution": "$2$"},
+                {"func": "$\\lim_{x \\to \\infty} \\frac{2x^2+3x-5}{x^2}$", "domain": ["$x \\to \\infty$"], "solution": "$2$"}
+            ],
+            "hard": [
+                {"func": "$\\lim_{x \\to 0} \\frac{1-\\cos(x)}{x^2}$", "domain": ["$x \\to 0$"], "solution": "$\\frac{1}{2}$"},
+                {"func": "$\\lim_{x \\to 0} (\\frac{1}{x} - \\frac{1}{\\sin(x)})$", "domain": ["$x \\to 0$"], "solution": "$0$"},
+                {"func": "$\\lim_{x \\to 0} \\frac{e^x-1-x}{x^2}$", "domain": ["$x \\to 0$"], "solution": "$\\frac{1}{2}$"},
+                {"func": "$\\lim_{x \\to \\infty} (1 + \\frac{1}{x})^x$", "domain": ["$x \\to \\infty$"], "solution": "$e$"},
+                {"func": "$\\lim_{x \\to 0^+} x^{\\alpha}\\ln(x)$ where $\\alpha > 0$", "domain": ["$x \\to 0^+$"], "solution": "$0$"}
+            ]
+        }
+    },
+    "Derivatives and Differentiation": {
+        "formula": "$f'(x) = \\lim_{h \\to 0} \\frac{f(x+h) - f(x)}{h}$",
+        "functions": {
+            "easy": [
+                {"func": "$f(x) = x^3 - 4x^2 + 7x - 2$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = 3x^2 - 8x + 7$"},
+                {"func": "$f(x) = \\sin(2x)$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = 2\\cos(2x)$"},
+                {"func": "$f(x) = e^{3x}$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = 3e^{3x}$"},
+                {"func": "$f(x) = \\ln(x^2 + 1)$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = \\frac{2x}{x^2+1}$"},
+                {"func": "$f(x) = x^2 e^x$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = x^2 e^x + 2x e^x$"}
+            ],
+            "hard": [
+                {"func": "$f(x) = \\frac{\\sin(x)}{\\cos(x) + 2}$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = \\frac{\\cos(x)(\\cos(x) + 2) + \\sin^2(x)}{(\\cos(x) + 2)^2}$"},
+                {"func": "$f(x) = \\int_{0}^{x^2} \\sin(t^2) dt$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = 2x\\sin(x^4)$"},
+                {"func": "$f(x) = \\arctan(e^x)$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = \\frac{e^x}{1 + e^{2x}}$"},
+                {"func": "$f(x) = x^{\\sin(x)}$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = x^{\\sin(x)}(\\cos(x)\\ln(x) + \\frac{\\sin(x)}{x})$"},
+                {"func": "$f(x) = \\ln(\\sin(x))$", "domain": ["Find $f'(x)$"], "solution": "$f'(x) = \\cot(x)$"}
+            ]
+        }
+    },
+    "Applications of Derivatives": {
+        "formula": "Related Rates, Optimization, L'Hôpital's Rule",
+        "functions": {
+            "easy": [
+                {"func": "A particle moves according to $s(t) = t^3 - 6t^2 + 9t$. Find its velocity at $t = 2$", "domain": ["$t = 2$"], "solution": "$v(2) = -3$ units/sec"},
+                {"func": "Find the critical points of $f(x) = x^3 - 3x^2 - 9x + 5$", "domain": ["$x \\in \\mathbb{R}$"], "solution": "$x = -1$ and $x = 3$"},
+                {"func": "Find the absolute maximum and minimum of $f(x) = x^2 - 4x + 3$ on $[0, 3]$", "domain": ["$[0, 3]$"], "solution": "Maximum: $f(0) = 3$, Minimum: $f(2) = -1$"},
+                {"func": "Use L'Hôpital's Rule to evaluate $\\lim_{x \\to 0} \\frac{\\tan(3x)}{x}$", "domain": ["$x \\to 0$"], "solution": "$3$"},
+                {"func": "Find the equation of the tangent line to $f(x) = x^2 + 2x - 3$ at $x = 1$", "domain": ["$x = 1$"], "solution": "$y = 4x - 2$"}
+            ],
+            "hard": [
+                {"func": "A ladder 10 feet long leans against a wall. If the bottom slides away at 2 ft/s, how fast is the top sliding down when it's 6 feet above ground?", "domain": ["Rate problem"], "solution": "$\\frac{3}{2}$ ft/s"},
+                {"func": "Find the dimensions of the rectangle with perimeter 100 m that has the maximum area", "domain": ["Optimization"], "solution": "25 m × 25 m square"},
+                {"func": "Use Newton's method to approximate a root of $f(x) = x^3 - 2x - 5$ starting with $x_1 = 2$", "domain": ["Newton's Method"], "solution": "$x \\approx 2.0946$ after 3 iterations"},
+                {"func": "Find the absolute extrema of $f(x) = xe^{-x^2}$ on $[0, \\infty)$", "domain": ["$[0, \\infty)$"], "solution": "Maximum: $f(\\frac{1}{\\sqrt{2}}) = \\frac{1}{\\sqrt{2e}}$, Minimum: $f(0) = f(\\infty) = 0$"},
+                {"func": "Use implicit differentiation to find $\\frac{dy}{dx}$ for $x^3 + y^3 = 6xy$", "domain": ["Implicit"], "solution": "$\\frac{dy}{dx} = \\frac{6y - 3x^2}{3y^2 - 6x}$"}
+            ]
+        }
+    },
+    "Integration Techniques": {
+        "formula": "$\\int f(x) dx$ using various methods",
+        "functions": {
+            "easy": [
+                {"func": "$\\int x^3(x^2+1)^4 dx$", "domain": ["Use Substitution"], "solution": "$\\frac{1}{10}(x^2+1)^5 - \\frac{1}{6}(x^2+1)^3 + C$"},
+                {"func": "$\\int \\frac{1}{x^2-4} dx$", "domain": ["Use Partial Fractions"], "solution": "$\\frac{1}{4}\\ln|\\frac{x-2}{x+2}| + C$"},
+                {"func": "$\\int x\\sin(x) dx$", "domain": ["Use Integration by Parts"], "solution": "$\\sin(x) - x\\cos(x) + C$"},
+                {"func": "$\\int \\sec^2(3x) dx$", "domain": ["Trigonometric"], "solution": "$\\frac{1}{3}\\tan(3x) + C$"},
+                {"func": "$\\int \\frac{5}{3x+6} dx$", "domain": ["Substitution"], "solution": "$\\frac{5}{3}\\ln|3x+6| + C$"}
+            ],
+            "hard": [
+                {"func": "$\\int \\frac{x^2}{\\sqrt{1-x^2}} dx$", "domain": ["Trigonometric Substitution"], "solution": "$-\\frac{x\\sqrt{1-x^2}}{2} - \\frac{\\arcsin(x)}{2} + C$"},
+                {"func": "$\\int \\frac{\\ln(x)}{x^2} dx$", "domain": ["Integration by Parts"], "solution": "$-\\frac{\\ln(x)}{x} - \\frac{1}{x} + C$"},
+                {"func": "$\\int e^x\\sin(x) dx$", "domain": ["Integration by Parts twice"], "solution": "$\\frac{e^x(\\sin(x)-\\cos(x))}{2} + C$"},
+                {"func": "$\\int \\frac{1}{x^2-x-6} dx$", "domain": ["Partial Fractions"], "solution": "$\\frac{1}{5}\\ln|\\frac{x+2}{x-3}| + C$"},
+                {"func": "$\\int \\frac{1}{\\sqrt{x^2-a^2}} dx$", "domain": ["$a > 0$"], "solution": "$\\ln|x + \\sqrt{x^2-a^2}| + C$"}
+            ]
+        }
+    },
+    "Average Value": {
+        "formula": "$f_{avg} = \\frac{1}{b-a} \\int_{a}^{b} f(x) dx$",
+        "functions": {
+            "easy": [
+                {"func": "$x^2$", "domain": [0, 2], "solution": "$\\frac{4}{3}$"},
+                {"func": "$\\sin(x)$", "domain": [0, "π"], "solution": "$\\frac{2}{\\pi}$"},
+                {"func": "$e^x$", "domain": [0, 1], "solution": "$(e-1)$"},
+                {"func": "$x$", "domain": [1, 4], "solution": "$\\frac{5}{2}$"},
+                {"func": "$x^3$", "domain": [0, 1], "solution": "$\\frac{1}{4}$"}
+            ],
+            "hard": [
+                {"func": "$x\\sin(x)$", "domain": [0, "π"], "solution": "$\\frac{\\pi}{2}$"},
+                {"func": "$\\ln(x)$", "domain": [1, "e"], "solution": "$1-\\frac{1}{e}$"},
+                {"func": "$x^2e^x$", "domain": [0, 1], "solution": "$2e-2$"},
+                {"func": "$\\frac{1}{1+x^2}$", "domain": [0, 1], "solution": "$\\frac{\\pi}{4}$"},
+                {"func": "$\\sqrt{x}$", "domain": [0, 4], "solution": "$\\frac{4}{3}$"}
+            ]
+        }
+    },
+    "Arc Length": {
+        "formula": "$L = \\int_{a}^{b} \\sqrt{1 + (f'(x))^2} dx$",
+        "functions": {
+            "easy": [
+                {"func": "$x^2$", "domain": [0, 1], "solution": "$\\approx 1.4789$"},
+                {"func": "$x^{3/2}$", "domain": [0, 1], "solution": "$\\approx 1.1919$"},
+                {"func": "$2x+1$", "domain": [0, 2], "solution": "$2\\sqrt{5}$"},
+                {"func": "$x^3$", "domain": [0, 1], "solution": "$\\approx 1.0801$"},
+                {"func": "$\\sin(x)$", "domain": [0, "π/2"], "solution": "$\\approx 1.9118$"}
+            ],
+            "hard": [
+                {"func": "$\\ln(x)$", "domain": [1, 3], "solution": "$\\approx 2.3861$"},
+                {"func": "$e^x$", "domain": [0, 1], "solution": "$\\approx 1.1752$"},
+                {"func": "$\\cosh(x)$", "domain": [0, 1], "solution": "$\\sinh(1)$"},
+                {"func": "$x^2 - \\ln(x)$", "domain": [1, 2], "solution": "$\\approx 3.1623$"},
+                {"func": "$x = \\cos(t)$, $y = \\sin(t)$ for $t\\in[0,\\pi]$", "domain": [0, "π"], "solution": "$\\pi$"}
+            ]
+        }
+    },
+    "Surface Area": {
+        "formula": "$S = 2\\pi \\int_{a}^{b} f(x) \\sqrt{1 + (f'(x))^2} dx$",
+        "functions": {
+            "easy": [
+                {"func": "$x$", "domain": [0, 3], "solution": "$2\\pi \\cdot 4.5$"},
+                {"func": "$x^2$", "domain": [0, 1], "solution": "$\\approx 2\\pi \\cdot 0.7169$"},
+                {"func": "$\\sqrt{x}$", "domain": [0, 4], "solution": "$\\approx 2\\pi \\cdot 4.5177$"},
+                {"func": "$1$", "domain": [0, 2], "solution": "$2\\pi \\cdot 2$"},
+                {"func": "$\\frac{x}{2}$", "domain": [0, 4], "solution": "$2\\pi \\cdot 4.1231$"}
+            ],
+            "hard": [
+                {"func": "$x^3$", "domain": [0, 1], "solution": "$\\approx 2\\pi \\cdot 0.6004$"},
+                {"func": "$e^x$", "domain": [0, 1], "solution": "$\\approx 2\\pi \\cdot 1.1793$"},
+                {"func": "$\\sin(x)$", "domain": [0, "π/2"], "solution": "$\\approx 2\\pi \\cdot 0.6366$"},
+                {"func": "$\\frac{1}{x}$", "domain": [1, 2], "solution": "$\\approx 2\\pi \\cdot 1.1478$"},
+                {"func": "$\\ln(x)$", "domain": [1, 2], "solution": "$\\approx 2\\pi \\cdot 0.5593$"}
+            ]
+        }
+    },
+    "Differential Equations": {
+        "formula": "Various types",
+        "functions": {
+            "easy": [
+                {"func": "$\\frac{dy}{dx} = 2x$", "domain": ["$y(0)=1$"], "solution": "$y = x^2 + 1$"},
+                {"func": "$\\frac{dy}{dx} = y$", "domain": ["$y(0)=1$"], "solution": "$y = e^x$"},
+                {"func": "$\\frac{dy}{dx} = 3x^2$", "domain": ["$y(0)=2$"], "solution": "$y = x^3 + 2$"},
+                {"func": "$\\frac{dy}{dx} = -y$", "domain": ["$y(0)=4$"], "solution": "$y = 4e^{-x}$"},
+                {"func": "$\\frac{dy}{dx} = x+1$", "domain": ["$y(0)=-2$"], "solution": "$y = \\frac{x^2}{2} + x - 2$"}
+            ],
+            "hard": [
+                {"func": "$y'' + 4y = 0$", "domain": ["$y(0)=1$, $y'(0)=0$"], "solution": "$y = \\cos(2x)$"},
+                {"func": "$y'' - y = x$", "domain": ["$y(0)=0$, $y'(0)=1$"], "solution": "$y = \\frac{e^x}{2} - \\frac{e^{-x}}{2} - x$"},
+                {"func": "$y' + y = e^x$", "domain": ["$y(0)=0$"], "solution": "$y = xe^x$"},
+                {"func": "$y'' + 2y' + y = 0$", "domain": ["$y(0)=1$, $y'(0)=-1$"], "solution": "$y = (1-x)e^{-x}$"},
+                {"func": "$y'' - 2y' + y = x^2$", "domain": ["$y(0)=1$, $y'(0)=1$"], "solution": "$y = \\frac{x^2}{2} + 2x + 1$"}
+            ]
+        }
+    },
+    "Area and Volume": {
+        "formula": "$A = \\int_{a}^{b} f(x) dx$, $V = \\pi \\int_{a}^{b} [f(x)]^2 dx$",
+        "functions": {
+            "easy": [
+                {"func": "$f(x) = x^2$, find area under the curve", "domain": [0, 3], "solution": "$9$"},
+                {"func": "$f(x) = \\sin(x)$, find area under the curve", "domain": [0, "π"], "solution": "$2$"},
+                {"func": "$f(x) = 4-x^2$, find area under the curve", "domain": [-2, 2], "solution": "$\\frac{16}{3}$"},
+                {"func": "$f(x) = \\sqrt{x}$, find volume of revolution around x-axis", "domain": [0, 4], "solution": "$\\frac{16\\pi}{3}$"},
+                {"func": "$f(x) = x$, find volume of revolution around x-axis", "domain": [0, 2], "solution": "$\\frac{8\\pi}{3}$"}
+            ],
+            "hard": [
+                {"func": "Area between $f(x) = x^2$ and $g(x) = x^3$", "domain": [0, 1], "solution": "$\\frac{1}{12}$"},
+                {"func": "Volume of solid bounded by $z = 4-x^2-y^2$ and $z = 0$", "domain": ["$x^2+y^2\\leq 4$"], "solution": "$8\\pi$"},
+                {"func": "Volume of solid formed by rotating region bounded by $y = x^2$, $y = 0$, $x = 2$ around y-axis", "domain": [0, 2], "solution": "$\\frac{8\\pi}{5}$"},
+                {"func": "Area between $f(x) = \\sin(x)$ and $g(x) = \\cos(x)$", "domain": [0, "π/4"], "solution": "$\\sqrt{2}-1$"},
+                {"func": "Volume of solid formed by rotating region bounded by $y = e^x$, $y = 0$, $x = 0$, $x = 1$ around x-axis", "domain": [0, 1], "solution": "$\\frac{\\pi(e^2-1)}{2}$"}
+            ]
+        }
+    },
+    "Parametric Curves and Equations": {
+        "formula": "$x = x(t)$, $y = y(t)$, Arc length = $\\int_{a}^{b} \\sqrt{(\\frac{dx}{dt})^2 + (\\frac{dy}{dt})^2} dt$",
+        "functions": {
+            "easy": [
+                {"func": "$x = t$, $y = t^2$, find $\\frac{dy}{dx}$", "domain": ["$t$"], "solution": "$\\frac{dy}{dx} = 2t$"},
+                {"func": "$x = \\cos(t)$, $y = \\sin(t)$, find the arc length", "domain": [0, "π/2"], "solution": "$\\frac{\\pi}{2}$"},
+                {"func": "$x = t^2$, $y = t^3$, find $\\frac{dy}{dx}$", "domain": ["$t$"], "solution": "$\\frac{dy}{dx} = \\frac{3t}{2}$"},
+                {"func": "$x = 2t$, $y = t^2$, find the area under the curve", "domain": [0, 2], "solution": "$\\frac{4}{3}$"},
+                {"func": "$x = t$, $y = \\sin(t)$, find $\\frac{dy}{dx}$", "domain": ["$t$"], "solution": "$\\frac{dy}{dx} = \\cos(t)$"}
+            ],
+            "hard": [
+                {"func": "$x = e^t\\cos(t)$, $y = e^t\\sin(t)$, find $\\frac{dy}{dx}$", "domain": ["$t$"], "solution": "$\\frac{dy}{dx} = \\tan(t) + 1$"},
+                {"func": "$x = t-\\sin(t)$, $y = 1-\\cos(t)$, find the arc length", "domain": [0, "2π"], "solution": "$8$"},
+                {"func": "$x = \\ln(\\sec(t))$, $y = \\tan(t)$, find $\\frac{dy}{dx}$", "domain": ["$t$"], "solution": "$\\frac{dy}{dx} = \\sec^2(t)$"},
+                {"func": "$x = \\cos^3(t)$, $y = \\sin^3(t)$, find the area enclosed", "domain": [0, "2π"], "solution": "$\\frac{3\\pi}{8}$"},
+                {"func": "$x = \\cos(t)+t\\sin(t)$, $y = \\sin(t)-t\\cos(t)$, find the arc length", "domain": [0, "2π"], "solution": "$2\\pi\\sqrt{1+4\\pi^2}$"}
+            ]
+        }
+    },
+    "Infinite Sequences and Series": {
+        "formula": "$\\sum_{n=1}^{\\infty} a_n = a_1 + a_2 + a_3 + ...$",
+        "functions": {
+            "easy": [
+                {"func": "Determine if the sequence $a_n = \\frac{n+3}{2n+1}$ converges and find its limit", "domain": ["$n \\to \\infty$"], "solution": "Converges to $\\frac{1}{2}$"},
+                {"func": "Find the sum of the geometric series $\\sum_{n=0}^{\\infty} \\frac{1}{3^n}$", "domain": ["Geometric Series"], "solution": "$\\frac{3}{2}$"},
+                {"func": "Determine if the series $\\sum_{n=1}^{\\infty} \\frac{1}{n^2}$ converges", "domain": ["p-series"], "solution": "Converges (p-series with $p=2 > 1$)"},
+                {"func": "Find the first three non-zero terms in the Taylor series for $f(x) = e^x$ centered at $a = 0$", "domain": ["Taylor Series"], "solution": "$1 + x + \\frac{x^2}{2} + ...$"},
+                {"func": "Find the radius of convergence of the power series $\\sum_{n=1}^{\\infty} \\frac{x^n}{n}$", "domain": ["Power Series"], "solution": "$R = 1$"}
+            ],
+            "hard": [
+                {"func": "Test the convergence of the alternating series $\\sum_{n=1}^{\\infty} (-1)^{n+1}\\frac{\\ln(n)}{n}$", "domain": ["Alternating Series"], "solution": "Converges by the Alternating Series Test"},
+                {"func": "Find the radius and interval of convergence for $\\sum_{n=1}^{\\infty} \\frac{n^2 x^n}{3^n}$", "domain": ["Power Series"], "solution": "$R = 3$, interval of convergence is $(-3, 3)$"},
+                {"func": "Determine if the series $\\sum_{n=2}^{\\infty} \\frac{1}{n\\ln(n)}$ converges", "domain": ["Integral Test"], "solution": "Diverges by the Integral Test"},
+                {"func": "Find the sum of the series $\\sum_{n=1}^{\\infty} \\frac{1}{n(n+1)}$", "domain": ["Telescoping Series"], "solution": "$1$"},
+                {"func": "Find the Taylor series of $f(x) = \\ln(1+x)$ and its radius of convergence", "domain": ["Taylor Series"], "solution": "$\\sum_{n=1}^{\\infty} \\frac{(-1)^{n+1}x^n}{n}$, $R = 1$"}
+            ]
+        }
+    },
+    "Polar Coordinates": {
+        "formula": "$x = r\\cos(\\theta)$, $y = r\\sin(\\theta)$, Area = $\\frac{1}{2}\\int_{\\alpha}^{\\beta} r^2 d\\theta$",
+        "functions": {
+            "easy": [
+                {"func": "Convert the Cartesian point $(1, \\sqrt{3})$ to polar coordinates", "domain": ["Conversion"], "solution": "$r = 2$, $\\theta = \\frac{\\pi}{3}$"},
+                {"func": "Find the area enclosed by the circle $r = 3\\sin(\\theta)$", "domain": ["Polar Area"], "solution": "$\\frac{9\\pi}{2}$"},
+                {"func": "Convert the polar equation $r = 2$ to Cartesian form", "domain": ["Conversion"], "solution": "$x^2 + y^2 = 4$"},
+                {"func": "Find the area enclosed by $r = 2\\cos(\\theta)$", "domain": ["Polar Area"], "solution": "$2\\pi$"},
+                {"func": "Convert the Cartesian equation $x^2 + y^2 = 4y$ to polar form", "domain": ["Conversion"], "solution": "$r = 4\\sin(\\theta)$"}
+            ],
+            "hard": [
+                {"func": "Find the area of the region enclosed by the lemniscate $r^2 = 4\\cos(2\\theta)$", "domain": ["Polar Area"], "solution": "$4$"},
+                {"func": "Find the area of the region inside $r = 1 + \\cos(\\theta)$ and outside $r = 1$", "domain": ["Polar Area"], "solution": "$\\frac{\\pi}{2}$"},
+                {"func": "Find the points of intersection of the polar curves $r = 1 + \\sin(\\theta)$ and $r = 1 - \\sin(\\theta)$", "domain": ["Polar Curves"], "solution": "$(0, 0)$ and $(1, \\frac{\\pi}{2})$, $(1, \\frac{3\\pi}{2})$"},
+                {"func": "Find the area of the region enclosed by the cardioid $r = 1 + \\cos(\\theta)$", "domain": ["Polar Area"], "solution": "$\\frac{3\\pi}{2}$"},
+                {"func": "Find the length of the spiral $r = \\theta$ for $0 \\leq \\theta \\leq 2\\pi$", "domain": ["Polar Arc Length"], "solution": "$\\frac{1}{2}\\sqrt{1+4\\pi^2} + \\frac{1}{2}\\ln(2\\pi + \\sqrt{1+4\\pi^2})$"}
+            ]
+        }
+    },
+    "Vector Calculus": {
+        "formula": "$\\vec{r}(t) = x(t)\\vec{i} + y(t)\\vec{j} + z(t)\\vec{k}$, $\\vec{v}(t) = \\vec{r}'(t)$, $\\vec{a}(t) = \\vec{v}'(t)$",
+        "functions": {
+            "easy": [
+                {"func": "Find the derivative of the vector function $\\vec{r}(t) = t^2\\vec{i} + \\sin(t)\\vec{j} + e^t\\vec{k}$", "domain": ["Vector Function"], "solution": "$\\vec{r}'(t) = 2t\\vec{i} + \\cos(t)\\vec{j} + e^t\\vec{k}$"},
+                {"func": "Find the unit tangent vector of $\\vec{r}(t) = \\cos(t)\\vec{i} + \\sin(t)\\vec{j}$ at $t = 0$", "domain": ["$t = 0$"], "solution": "$\\vec{T}(0) = \\vec{j}$"},
+                {"func": "Calculate $\\nabla f$ where $f(x,y,z) = x^2y + yz^2$", "domain": ["Gradient"], "solution": "$\\nabla f = 2xy\\vec{i} + (x^2 + z^2)\\vec{j} + 2yz\\vec{k}$"},
+                {"func": "Find the divergence of the vector field $\\vec{F}(x,y,z) = x^2\\vec{i} + 2xy\\vec{j} + yz\\vec{k}$", "domain": ["Divergence"], "solution": "$\\nabla \\cdot \\vec{F} = 2x + 2x + z = 4x + z$"},
+                {"func": "Find the curl of $\\vec{F}(x,y,z) = y\\vec{i} + z\\vec{j} + x\\vec{k}$", "domain": ["Curl"], "solution": "$\\nabla \\times \\vec{F} = (1-0)\\vec{i} + (1-0)\\vec{j} + (1-0)\\vec{k} = \\vec{i} + \\vec{j} + \\vec{k}$"}
+            ],
+            "hard": [
+                {"func": "Find the curvature of $\\vec{r}(t) = t\\vec{i} + t^2\\vec{j} + t^3\\vec{k}$ at $t = 1$", "domain": ["Curvature at $t = 1$"], "solution": "$\\kappa = \\frac{2\\sqrt{37}}{49\\sqrt{3}}$"},
+                {"func": "Verify Stokes' Theorem for $\\vec{F} = x^2\\vec{i} + xy\\vec{j} + z^2\\vec{k}$ on the hemisphere $z = \\sqrt{1-x^2-y^2}$, $z \\geq 0$", "domain": ["Stokes' Theorem"], "solution": "Both integrals equal $\\frac{\\pi}{2}$"},
+                {"func": "Use the Divergence Theorem to evaluate $\\iint_S \\vec{F} \\cdot \\vec{n} \\, dS$ where $\\vec{F}(x,y,z) = x\\vec{i} + y\\vec{j} + z\\vec{k}$ and $S$ is the sphere $x^2+y^2+z^2=4$", "domain": ["Divergence Theorem"], "solution": "$\\iint_S \\vec{F} \\cdot \\vec{n} \\, dS = \\iiint_V 3 \\, dV = 3 \\cdot \\frac{4}{3}\\pi \\cdot 4^{3/2} = 16\\pi$"},
+                {"func": "Find the potential function $f$ for the conservative vector field $\\vec{F} = (2x+y)\\vec{i} + (x+2z)\\vec{j} + (2y)\\vec{k}$", "domain": ["Potential Function"], "solution": "$f(x,y,z) = x^2 + xy + 2yz + C$"},
+                {"func": "Use Green's Theorem to evaluate $\\oint_C (y^2\\,dx + x^2\\,dy)$ where $C$ is the boundary of the region enclosed by $y = x^2$ and $y = 4$", "domain": ["Green's Theorem"], "solution": "$\\frac{256}{15}$"}
+            ]
+        }
+    },
+    "Partial Derivatives and Multiple Integrals": {
+        "formula": "$\\frac{\\partial f}{\\partial x}$, $\\frac{\\partial f}{\\partial y}$, $\\iint_D f(x,y) \\, dA$, $\\iiint_E f(x,y,z) \\, dV$",
+        "functions": {
+            "easy": [
+                {"func": "Find $\\frac{\\partial z}{\\partial x}$ and $\\frac{\\partial z}{\\partial y}$ for $z = x^2 + 3xy - y^3$", "domain": ["Partial Derivatives"], "solution": "$\\frac{\\partial z}{\\partial x} = 2x + 3y$, $\\frac{\\partial z}{\\partial y} = 3x - 3y^2$"},
+                {"func": "Evaluate $\\iint_D (x + y) \\, dA$ where $D = \\{(x, y) | 0 \\leq x \\leq 1, 0 \\leq y \\leq 2\\}$", "domain": ["Double Integral"], "solution": "$3$"},
+                {"func": "Find all critical points of $f(x,y) = x^2 + y^2 - 4x - 6y + 12$", "domain": ["Critical Points"], "solution": "$(2, 3)$"},
+                {"func": "Convert the double integral $\\iint_D x^2y \\, dA$ to polar coordinates where $D$ is the disc $x^2 + y^2 \\leq 4$", "domain": ["Change to Polar"], "solution": "$\\int_0^{2\\pi} \\int_0^2 r^3 \\cos^2(\\theta)\\sin(\\theta) \\, dr \\, d\\theta$"},
+                {"func": "Evaluate $\\iint_D xy \\, dA$ where $D$ is the triangle with vertices $(0,0)$, $(1,0)$, and $(0,1)$", "domain": ["Double Integral"], "solution": "$\\frac{1}{24}$"}
+            ],
+            "hard": [
+                {"func": "Find the absolute maximum and minimum values of $f(x,y) = 2x^2 + y^2 - 4x + 6y + 10$ on the closed disc $x^2 + y^2 \\leq 25$", "domain": ["Extrema on Region"], "solution": "Maximum: $135$ at $(5,0)$, Minimum: $1$ at $(1,-3)$"},
+                {"func": "Evaluate $\\iiint_E xy^2z^3 \\, dV$ where $E$ is the solid bounded by $x=0$, $y=0$, $z=0$, $x+y+z=1$", "domain": ["Triple Integral"], "solution": "$\\frac{1}{840}$"},
+                {"func": "Use Lagrange multipliers to find the maximum value of $f(x,y) = xy$ subject to the constraint $x^2 + y^2 = 8$", "domain": ["Lagrange Multipliers"], "solution": "$4$ at $(\\pm 2, \\pm 2)$"},
+                {"func": "Change the order of integration in $\\int_0^1 \\int_y^1 e^{xy} \\, dx \\, dy$", "domain": ["Change of Order"], "solution": "$\\int_0^1 \\int_0^x e^{xy} \\, dy \\, dx$"},
+                {"func": "Evaluate $\\iint_D \\frac{1}{1+x^2+y^2} \\, dA$ where $D = \\{(x,y) | x^2 + y^2 \\leq 4\\}$", "domain": ["Double Integral"], "solution": "$\\pi\\ln(5)$"}
+            ]
+        }
+    }
+}
 
-class ModelManager:
-    """Manages loading and switching between language models for text generation."""
+# Function to generate a question for a given topic and difficulty
+def generate_question(topic_name, difficulty):
+    topic_data = TOPICS[topic_name]
+    formula = topic_data["formula"]
     
-    def __init__(self):
-        self.models = {}
-        self.tokenizers = {}
-        self.current_model = None
-        
-    def load_model(self, model_name):
-        """Load a model and its tokenizer if not already loaded."""
-        if model_name not in self.models:
-            try:
-                logging.info(f"Loading model: {model_name}")
-                tokenizer = AutoTokenizer.from_pretrained(model_name)
-                model = AutoModelForCausalLM.from_pretrained(
-                    model_name,
-                    torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
-                    device_map="auto" if DEVICE == "cuda" else None
-                )
-                model.eval()
-                
-                self.models[model_name] = model
-                self.tokenizers[model_name] = tokenizer
-                logging.info(f"Successfully loaded model: {model_name}")
-                return True
-            except Exception as e:
-                logging.error(f"Failed to load model {model_name}: {str(e)}")
-                return False
-        return True
+    # Select a random function from the available ones for this topic and difficulty
+    function_data = random.choice(topic_data["functions"][difficulty])
+    func = function_data["func"]
+    domain = function_data["domain"]
+    solution = function_data["solution"]
     
-    def set_current_model(self, model_name):
-        """Set the current model to use for generation."""
-        if model_name not in self.models and not self.load_model(model_name):
-            return False
-        self.current_model = model_name
-        return True
+    # Format domain for display
+    if isinstance(domain, list) and len(domain) == 2:
+        domain_str = f"[{domain[0]}, {domain[1]}]"
+    else:
+        domain_str = str(domain)
     
-    def generate_text(self, prompt, max_length=1024):
-        """Generate text using the current model."""
-        if not self.current_model:
-            raise ValueError("No model selected. Call set_current_model first.")
-        
-        model = self.models[self.current_model]
-        tokenizer = self.tokenizers[self.current_model]
-        
-        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-        
-        # Generate with some randomness for creativity
-        with torch.no_grad():
-            outputs = model.generate(
-                **inputs,
-                max_length=max_length,
-                temperature=0.7,
-                top_p=0.9,
-                do_sample=True,
-                pad_token_id=tokenizer.eos_token_id
-            )
-            
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        # Extract only the generated part
-        generated_text = response[len(tokenizer.decode(inputs['input_ids'][0], skip_special_tokens=True)):].strip()
-        return generated_text
-
-class CalculusTextbookGenerator:
-    """Generates a complete calculus textbook with questions and solutions."""
+    # Create question and solution based on difficulty
+    if difficulty == "easy":
+        question = f"Find the {topic_name.lower()} of {func} over the domain {domain_str}."
+        solution_text = f"Step 1: Apply the formula for {topic_name.lower()}: {formula}\n\n"
+        solution_text += f"Step 2: Substitute $f(x) = {func}$ and evaluate over {domain_str}\n\n"
+        solution_text += f"Step 3: Solve the resulting integral or calculation\n\n"
+        solution_text += f"Final Answer: {solution}"
+    else:
+        question = f"Compute the {topic_name.lower()} for {func} over {domain_str}."
+        solution_text = f"Step 1: Apply the formula for {topic_name.lower()}: {formula}\n\n"
+        solution_text += f"Step 2: For {func}, substitute into the formula and evaluate over {domain_str}\n\n"
+        solution_text += f"Step 3: This requires advanced integration techniques or careful analysis\n\n"
+        solution_text += f"Final Answer: {solution}"
     
-    def __init__(self):
-        self.model_manager = ModelManager()
-        self.textbook_data = self.create_initial_textbook_structure()
-        
-    def create_initial_textbook_structure(self):
-        """Create the initial structure of the calculus textbook."""
-        return {
-            "books": [
-                {
-                    "name": "Calculus 1: Early Transcendentals",
-                    "details": "Introduction to single-variable calculus including limits, derivatives, and basic integration techniques.",
-                    "chapters": [
-                        {
-                            "chapterTitle": "Chapter 6: Applications of Integration",
-                            "subChapters": [
-                                "6.1: Areas Between Curves", 
-                                "6.2: Volumes", 
-                                "6.3: Volumes by Cylindrical Shells",
-                                "6.4: Work",
-                                "6.5: Average Value of a Function"
-                            ],
-                            "questions": []  # Will be filled with generated questions
-                        },
-                        {
-                            "chapterTitle": "Chapter 8: Further Applications of Integration",
-                            "subChapters": [
-                                "8.1: Arc Length",
-                                "8.2: Area of a Surface of Revolution",
-                                "8.3: Applications to Physics and Engineering",
-                                "8.4: Applications to Economics and Biology",
-                                "8.5: Probability"
-                            ],
-                            "questions": []
-                        },
-                        {
-                            "chapterTitle": "Chapter 9: Differential Equations",
-                            "subChapters": [
-                                "9.1: Modeling with Differential Equations",
-                                "9.2: Direction Fields and Euler's Method",
-                                "9.3: Separable Equations",
-                                "9.4: Models for Population Growth",
-                                "9.5: Linear Equations",
-                                "9.6: Predator–Prey Systems"
-                            ],
-                            "questions": []
-                        },
-                        {
-                            "chapterTitle": "Chapter 10: Parametric Equations and Polar Coordinates",
-                            "subChapters": [
-                                "10.1: Curves Defined by Parametric Equations",
-                                "10.2: Calculus with Parametric Curves",
-                                "10.3: Polar Coordinates",
-                                "10.4: Calculus in Polar Coordinates",
-                                "10.5: Conic Sections",
-                                "10.6: Conic Sections in Polar Coordinates"
-                            ],
-                            "questions": []
-                        },
-                        {
-                            "chapterTitle": "Chapter 11: Sequences, Series, and Power Series",
-                            "subChapters": [
-                                "11.1: Sequences",
-                                "11.2: Series",
-                                "11.3: The Integral Test and Estimates of Sums",
-                                "11.4: The Comparison Tests",
-                                "11.5: Alternating Series and Absolute Convergence",
-                                "11.6: The Ratio and Root Tests",
-                                "11.7: Power Series"
-                            ],
-                            "questions": []
-                        }
-                    ]
-                },
-                {
-                    "name": "Calculus 2: Advanced Concepts",
-                    "details": "Advances into series, sequences, techniques of integration, and vector calculus.",
-                    "chapters": [
-                        {
-                            "chapterTitle": "Chapter 12: Vectors and the Geometry of Space",
-                            "subChapters": [
-                                "12.1: Three-Dimensional Coordinate Systems",
-                                "12.2: Vectors",
-                                "12.3: The Dot Product",
-                                "12.4: The Cross Product",
-                                "12.5: Equations of Lines and Planes",
-                                "12.6: Cylinders and Quadric Surfaces"
-                            ],
-                            "questions": []
-                        },
-                        {
-                            "chapterTitle": "Chapter 13: Vector Functions",
-                            "subChapters": [
-                                "13.1: Vector Functions and Space Curves",
-                                "13.2: Derivatives and Integrals of Vector Functions",
-                                "13.3: Arc Length and Curvature",
-                                "13.4: Motion in Space: Velocity and Acceleration"
-                            ],
-                            "questions": []
-                        },
-                        {
-                            "chapterTitle": "Chapter 14: Partial Derivatives",
-                            "subChapters": [
-                                "14.1: Functions of Several Variables",
-                                "14.2: Limits and Continuity",
-                                "14.3: Partial Derivatives",
-                                "14.4: Tangent Planes and Linear Approximation",
-                                "14.5: The Chain Rule"
-                            ],
-                            "questions": []
-                        }
-                    ]
-                }
-            ]
-        }
-        
-    def generate_question_set(self, chapter_title, subchapter_titles, num_questions=3):
-        """Generate a set of questions with step-by-step solutions for a chapter."""
-        
-        # Try the primary model first
-        self.model_manager.set_current_model(PRIMARY_MODEL)
-        
-        prompt = f"""Create {num_questions} calculus questions with detailed step-by-step solutions for:
-{chapter_title}
-
-The questions should cover these subchapters:
-{', '.join(subchapter_titles)}
+    return {
+        "topic": topic_name,
+        "difficulty": difficulty,
+        "question": question,
+        "solution": solution_text
+    }
 
-For each question:
-1. Write a clear, university-level calculus problem
-2. Provide a comprehensive step-by-step solution with all math steps shown
-3. Include a final answer
+# Store the latest generated questions
+latest_questions = []
 
-Format each question as:
-QUESTION: [Problem statement]
-SOLUTION:
-Step 1: [First step with explanation]
-Step 2: [Next step]
-...
-Final Answer: [The solution]
-
-Make sure to use proper mathematical notation and include a variety of question types.
-"""
+# Generate questions function for Gradio
+def generate_calculus_questions(topic, difficulty, count):
+    global latest_questions
+    latest_questions = []
+    
+    for _ in range(int(count)):
+        question_data = generate_question(topic, difficulty)
+        latest_questions.append(question_data)
+    
+    # Format the output for display
+    result = ""
+    for i, q in enumerate(latest_questions):
+        result += f"Question {i+1}: {q['question']}\n\n"
+        result += f"Solution {i+1}: {q['solution']}\n\n"
+        result += "-" * 40 + "\n\n"
+    
+    return result
 
-        try:
-            generated_content = self.model_manager.generate_text(prompt, max_length=2048)
-            
-            # Check if the content looks good
-            if len(generated_content) < 200 or "QUESTION" not in generated_content:
-                # Try the secondary model if the primary one gave poor results
-                logging.warning(f"Primary model gave insufficient results for {chapter_title}. Trying secondary model.")
-                self.model_manager.set_current_model(SECONDARY_MODEL)
-                generated_content = self.model_manager.generate_text(prompt, max_length=2048)
-            
-            # Parse the generated content into question objects
-            questions = self.parse_questions(generated_content)
-            
-            if not questions or len(questions) == 0:
-                logging.warning(f"Failed to parse any questions from content for {chapter_title}")
-                return []
-                
-            return questions
-            
-        except Exception as e:
-            logging.error(f"Error generating questions for {chapter_title}: {str(e)}")
-            return []
-            
-    def parse_questions(self, content):
-        """Parse the generated content into structured question objects."""
-        questions = []
-        
-        # Split by "QUESTION:" or similar markers
-        parts = content.split("QUESTION:")
-        
-        for i, part in enumerate(parts):
-            if i == 0:
-                continue  # Skip the first part (before the first QUESTION:)
-                
-            try:
-                # Split into question and solution
-                if "SOLUTION:" in part:
-                    question_text, solution = part.split("SOLUTION:", 1)
-                else:
-                    # Try alternative formats
-                    for marker in ["Solution:", "STEPS:", "Steps:"]:
-                        if marker in part:
-                            question_text, solution = part.split(marker, 1)
-                            break
-                    else:
-                        question_text = part
-                        solution = ""
-                
-                questions.append({
-                    "question": question_text.strip(),
-                    "solution": solution.strip()
-                })
-            except Exception as e:
-                logging.error(f"Error parsing question {i}: {str(e)}")
-                continue
-                
-        return questions
+# Function to export questions to JSON
+def export_to_json():
+    if not latest_questions:
+        return None
     
-    def worker_function(self, queue, results):
-        """Worker thread function to process chapters from queue."""
-        while True:
-            item = queue.get()
-            if item is None:  # None signals to exit
-                queue.task_done()
-                break
-            
-            book_idx, chapter_idx, chapter = item
-            chapter_title = chapter["chapterTitle"]
-            subchapters = chapter.get("subChapters", [])
-            
-            logging.info(f"Processing: {chapter_title}")
-            
-            # Try to generate questions with retries
-            for attempt in range(MAX_RETRIES):
-                try:
-                    questions = self.generate_question_set(chapter_title, subchapters, num_questions=4)
-                    if questions:
-                        # Save the questions to the chapter
-                        self.textbook_data["books"][book_idx]["chapters"][chapter_idx]["questions"] = questions
-                        
-                        logging.info(f"✓ Generated {len(questions)} questions for {chapter_title}")
-                        break  # Success, exit retry loop
-                    else:
-                        logging.warning(f"No questions generated for {chapter_title} on attempt {attempt+1}")
-                        
-                except Exception as e:
-                    logging.error(f"Attempt {attempt+1}/{MAX_RETRIES} failed for {chapter_title}: {str(e)}")
-                    time.sleep(2)  # Wait before retrying
-            
-            # Save current state to file
-            self.save_current_state()
-            queue.task_done()
+    # Create a JSON file
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    json_data = {
+        "generated_at": timestamp,
+        "questions": latest_questions
+    }
     
-    def save_current_state(self):
-        """Save the current state of the textbook generation."""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        with open(os.path.join(OUTPUT_DIR, f"textbook_state_{timestamp}.json"), "w") as f:
-            json.dump(self.textbook_data, f, indent=2)
-        
-        # Also save to a fixed filename for the latest state
-        with open(os.path.join(OUTPUT_DIR, "textbook_latest.json"), "w") as f:
-            json.dump(self.textbook_data, f, indent=2)
+    # Create a temporary file
+    with tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".json") as temp_file:
+        json.dump(json_data, temp_file, indent=2)
+        temp_file_path = temp_file.name
     
-    def process_in_batches(self):
-        """Process all chapters in batches."""
-        queue = Queue()
-        
-        # Queue all chapters for processing
-        for book_idx, book in enumerate(self.textbook_data["books"]):
-            for chapter_idx, chapter in enumerate(book["chapters"]):
-                queue.put((book_idx, chapter_idx, chapter))
-        
-        # Create and start worker thread
-        worker = Thread(target=self.worker_function, args=(queue, None))
-        worker.daemon = True  # Allow the program to exit even if the thread is running
-        worker.start()
-        
-        # Process in batches
-        total_chapters = queue.qsize()
-        processed = 0
-        
-        while processed < total_chapters:
-            # Wait for the batch to be processed
-            start_size = queue.qsize()
-            batch_size = min(BATCH_SIZE, start_size)
-            
-            logging.info(f"Processing batch of {batch_size} chapters. {start_size} remaining.")
-            
-            # Wait until this batch is done
-            while queue.qsize() > start_size - batch_size:
-                time.sleep(2)
-            
-            processed += batch_size
-            logging.info(f"Batch complete. {processed}/{total_chapters} chapters processed.")
-            
-            # Save current state
-            self.save_current_state()
-        
-        # Signal worker to exit
-        queue.put(None)
-        worker.join()
-        
-        # Save final state
-        self.save_current_state()
-        logging.info("All chapters processed. Textbook generation complete.")
+    return temp_file_path
 
-def main():
-    start_time = datetime.now()
-    logging.info(f"Starting textbook generation at {start_time}")
+# Create the Gradio interface
+with gr.Blocks(title="Math Mento - Calculus Questions Generator") as demo:
+    gr.Markdown("# Math Mento - Calculus Questions Generator")
+    gr.Markdown("Generate LaTeX-formatted calculus practice questions with solutions based on James Stewart's calculus textbook")
+    
+    with gr.Row():
+        with gr.Column():
+            topic = gr.Dropdown(
+                choices=list(TOPICS.keys()),
+                label="Calculus Topic",
+                value="Limits and Continuity"
+            )
+            difficulty = gr.Radio(
+                choices=["easy", "hard"],
+                label="Difficulty",
+                value="easy"
+            )
+            count = gr.Slider(
+                minimum=1,
+                maximum=10,
+                step=1,
+                value=3,
+                label="Number of Questions"
+            )
+            generate_button = gr.Button("Generate Questions")
+            export_button = gr.Button("Export to JSON")
+        
+        with gr.Column():
+            output = gr.Markdown()
+            json_file = gr.File(label="Exported JSON")
+    
+    generate_button.click(
+        generate_calculus_questions,
+        inputs=[topic, difficulty, count],
+        outputs=output
+    )
     
-    generator = CalculusTextbookGenerator()
-    generator.process_in_batches()
+    export_button.click(
+        export_to_json,
+        inputs=[],
+        outputs=json_file
+    )
     
-    end_time = datetime.now()
-    duration = end_time - start_time
-    logging.info(f"Textbook generation completed in {duration}")
-    logging.info(f"Final textbook saved to {os.path.join(OUTPUT_DIR, 'textbook_latest.json')}")
+    gr.Markdown("### Created by Kamogelo Mosia | Math Mento © 2025")
 
+# Launch the app
 if __name__ == "__main__":
-    main()
+    demo.launch()

requirements.txt

@@ -1,2 +0,0 @@
-torch
-transformers