mathml-to-omml 1.0.2__tar.gz

mathml_to_omml-1.0.2/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2019 amedama
+Portions Copyright (c) 2026 Robert Danaraj (salorajan@gmail.com)
+Portions Copyright (c) 2026 Daisy Project Contributors
+
+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.

mathml_to_omml-1.0.2/MANIFEST.in

@@ -0,0 +1,6 @@
+include LICENSE
+include README.md
+recursive-include examples *
+recursive-include tests *
+exclude scratch_test.py
+exclude scratch_test_2.py

mathml_to_omml-1.0.2/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: mathml_to_omml
+Version: 1.0.2
+Summary: Convert MathML to OMML (Office Math Markup Language) in pure Python
+Home-page: https://github.com/salorajan/math_ml2omml
+Author: amedama, w2w Contributors
+Author-email: amedama <amedama@example.com>, w2w Contributors <contributors@w2w.org>
+License-Expression: MIT
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Text Processing :: Markup :: XML
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: latex2mathml
+Requires-Dist: lxml
+Requires-Dist: python-docx
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# math_ml2omml
+
+A pure Python library to convert MathML strings into OMML (Office Math Markup Language).
+
+This is a modern, patched version of the original `mathml2omml` library, containing key bug fixes and enhancements developed for the `w2w` (Word-to-Word Math Compiler) project to ensure 100% parity with Microsoft Word's professional equation layouts.
+
+## Key Enhancements in this Patched Version
+- **Accent and Group Character Rendering**: Fixed tag mismatches on `<m:groupChr>` inside `MUnder` and `MOver` classes. This ensures mathematical accents (like hats, tildes, dots) and underscript/overscript groupings compile and render correctly in Microsoft Word.
+- **Improved Alignment and Layout Compatibility**: Programmatic mapping fixes to match standard Office OpenXML (OOXML) math specifications.
+
+## Installation
+
+You can install it directly from this package directory:
+```bash
+pip install .
+```
+
+Or for development (editable mode):
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import math_ml2omml
+
+mathml = '<math><mi>x</mi><mo>+</mo><mi>y</mi></math>'
+omml = math_ml2omml.convert(mathml)
+print(omml)
+```
+
+### Custom Entities
+If your MathML contains custom entities, pass them as a dictionary:
+```python
+import html.entities
+mathml = '<math><msubsup><mo>&int;</mo><mn>1</mn><mi>x</mi></msubsup></math>'
+omml = math_ml2omml.convert(mathml, html.entities.name2codepoint)
+```
+
+## Running Tests
+
+To verify the installation and run the suite of unit tests, execute the following command in the project root:
+```bash
+python -m unittest discover -s tests
+```
+
+## Author
+Patched and maintained by **Robert Danaraj** (salorajan@gmail.com).
+
+## Acknowledgements
+Special thanks and deepest gratitude to **George Kerscher** ([IMLS Profile](https://www.imls.gov/about-us/national-museum-and-library-services-board/george-kerscher)), Chief Innovations Officer of the DAISY Consortium and President of the International Digital Publishing Forum. As a pioneering advocate for digital document accessibility (recognized as a White House Champion of Change), his invaluable discussion, guidance, and inspiration motivated the design, development, and deployment of this project.
+
+We also thank the contributors of the [daisy-math-a11y](https://github.com/daisy/math-a11y) project for inspiring our work.
+
+## Keystroke Complexity Score (KCS)
+This library includes a utility `calculate_kcs()` to compute the keyboard entry complexity cost of inputting mathematical equations into Microsoft Word's Equation Editor GUI. It is based on the **Keystroke-Level Model (KLM)** (Card, Moran, and Newell, 1980), adapted specifically for the interactive auto-build behaviors of Word's UnicodeMath input syntax:
+- **Raw Keystrokes ($K$)**: Character count of the linear notation.
+- **Cognitive Penalties ($C_i$)**: Additional weight for Shift keys (+1.0) and backslash escape sequences (+1.5).
+- **Auto-Build Spacebars ($C_{spacebar}$)**: Weight for spacebar triggers required to compile structures like fractions, scripts, roots, and matrices (+2.0).
+- **Fragility Penalty ($F$)**: Additional penalties (+10.0) for structures prone to user input errors without proper grouping.
+
+### Citations
+- **Keystroke-Level Model (KLM)**: Card, S. K., Moran, T. P., and Newell, A. (1980). *The Keystroke-Level Model for User Performance Time with Interactive Systems*. Communications of the ACM, 23(7), 396–410.
+- **UnicodeMath / Linear Math**: Murray Sargent III. (2010). *Unicode Sincerely, Math (Unicode Technical Note #28)*. Microsoft Corporation. [UTN #28 Specification](https://www.unicode.org/notes/tn28/UTN28-PlainTextMath-v3.pdf)
+
+
+## License
+MIT License. See [LICENSE](LICENSE) for details. Portions copyright (c) 2026 Daisy Project Contributors.
+
+

mathml_to_omml-1.0.2/README.md

@@ -0,0 +1,71 @@
+# math_ml2omml
+
+A pure Python library to convert MathML strings into OMML (Office Math Markup Language).
+
+This is a modern, patched version of the original `mathml2omml` library, containing key bug fixes and enhancements developed for the `w2w` (Word-to-Word Math Compiler) project to ensure 100% parity with Microsoft Word's professional equation layouts.
+
+## Key Enhancements in this Patched Version
+- **Accent and Group Character Rendering**: Fixed tag mismatches on `<m:groupChr>` inside `MUnder` and `MOver` classes. This ensures mathematical accents (like hats, tildes, dots) and underscript/overscript groupings compile and render correctly in Microsoft Word.
+- **Improved Alignment and Layout Compatibility**: Programmatic mapping fixes to match standard Office OpenXML (OOXML) math specifications.
+
+## Installation
+
+You can install it directly from this package directory:
+```bash
+pip install .
+```
+
+Or for development (editable mode):
+```bash
+pip install -e .
+```
+
+## Usage
+
+```python
+import math_ml2omml
+
+mathml = '<math><mi>x</mi><mo>+</mo><mi>y</mi></math>'
+omml = math_ml2omml.convert(mathml)
+print(omml)
+```
+
+### Custom Entities
+If your MathML contains custom entities, pass them as a dictionary:
+```python
+import html.entities
+mathml = '<math><msubsup><mo>&int;</mo><mn>1</mn><mi>x</mi></msubsup></math>'
+omml = math_ml2omml.convert(mathml, html.entities.name2codepoint)
+```
+
+## Running Tests
+
+To verify the installation and run the suite of unit tests, execute the following command in the project root:
+```bash
+python -m unittest discover -s tests
+```
+
+## Author
+Patched and maintained by **Robert Danaraj** (salorajan@gmail.com).
+
+## Acknowledgements
+Special thanks and deepest gratitude to **George Kerscher** ([IMLS Profile](https://www.imls.gov/about-us/national-museum-and-library-services-board/george-kerscher)), Chief Innovations Officer of the DAISY Consortium and President of the International Digital Publishing Forum. As a pioneering advocate for digital document accessibility (recognized as a White House Champion of Change), his invaluable discussion, guidance, and inspiration motivated the design, development, and deployment of this project.
+
+We also thank the contributors of the [daisy-math-a11y](https://github.com/daisy/math-a11y) project for inspiring our work.
+
+## Keystroke Complexity Score (KCS)
+This library includes a utility `calculate_kcs()` to compute the keyboard entry complexity cost of inputting mathematical equations into Microsoft Word's Equation Editor GUI. It is based on the **Keystroke-Level Model (KLM)** (Card, Moran, and Newell, 1980), adapted specifically for the interactive auto-build behaviors of Word's UnicodeMath input syntax:
+- **Raw Keystrokes ($K$)**: Character count of the linear notation.
+- **Cognitive Penalties ($C_i$)**: Additional weight for Shift keys (+1.0) and backslash escape sequences (+1.5).
+- **Auto-Build Spacebars ($C_{spacebar}$)**: Weight for spacebar triggers required to compile structures like fractions, scripts, roots, and matrices (+2.0).
+- **Fragility Penalty ($F$)**: Additional penalties (+10.0) for structures prone to user input errors without proper grouping.
+
+### Citations
+- **Keystroke-Level Model (KLM)**: Card, S. K., Moran, T. P., and Newell, A. (1980). *The Keystroke-Level Model for User Performance Time with Interactive Systems*. Communications of the ACM, 23(7), 396–410.
+- **UnicodeMath / Linear Math**: Murray Sargent III. (2010). *Unicode Sincerely, Math (Unicode Technical Note #28)*. Microsoft Corporation. [UTN #28 Specification](https://www.unicode.org/notes/tn28/UTN28-PlainTextMath-v3.pdf)
+
+
+## License
+MIT License. See [LICENSE](LICENSE) for details. Portions copyright (c) 2026 Daisy Project Contributors.
+
+

mathml_to_omml-1.0.2/examples/convert_html_word.py

@@ -0,0 +1,206 @@
+import os
+import sys
+import argparse
+
+# Gracefully check dependencies
+missing_deps = []
+try:
+    import lxml.etree
+    import lxml.html
+except ImportError:
+    missing_deps.append("lxml")
+
+try:
+    import docx
+    from docx.oxml import parse_xml
+except ImportError:
+    missing_deps.append("python-docx")
+
+if missing_deps:
+    print(f"Error: Missing required dependencies: {', '.join(missing_deps)}", file=sys.stderr)
+    print(f"Please install them using: pip install {' '.join(missing_deps)}", file=sys.stderr)
+    sys.exit(1)
+
+# Ensure we can import math_ml2omml from the local src/ directory
+script_dir = os.path.dirname(os.path.abspath(__file__))
+src_path = os.path.abspath(os.path.join(script_dir, "..", "src"))
+sys.path.insert(0, src_path)
+
+import math_ml2omml
+
+
+def convert_html_to_docx(html_path: str, docx_path: str):
+    """
+    Parses an HTML file containing MathML equations, converts the equations
+    to OMML using math_ml2omml, and builds a WCAG-compliant structured Word document.
+    """
+    print(f"Reading HTML file: {html_path}")
+    if not os.path.exists(html_path):
+        raise FileNotFoundError(f"Source HTML file not found: {html_path}")
+
+    # 1. Parse the HTML document
+    with open(html_path, "r", encoding="utf-8") as f:
+        html_content = f.read()
+
+    parser = lxml.html.HTMLParser(encoding="utf-8")
+    doc_tree = lxml.html.fromstring(html_content, parser=parser)
+
+    # 2. Initialize a new Word Document
+    doc = docx.Document()
+
+    # 3. Add Document Title (Heading 1) - WCAG 2.2 Page structure
+    doc.add_heading("University Mathematics Equation Reference Database", level=1)
+    doc.add_paragraph(
+        "This document contains 200 mathematical equations spanning algebra, "
+        "calculus, differential equations, and discrete mathematics. All equations "
+        "are rendered as native Office Math Markup Language (OMML) blocks and accompanied "
+        "by alternative text descriptions to meet WCAG 2.2 accessibility guidelines."
+    )
+
+    # 4. Find all categories and process their problems
+    categories = doc_tree.xpath("//section[@class='category-section']")
+    print(f"Found {len(categories)} math categories. Processing equations...")
+
+    problem_count = 0
+    for category in categories:
+        # Category Heading (Heading 2)
+        cat_heading_elem = category.find("./h2")
+        cat_title = (
+            cat_heading_elem.text.strip()
+            if cat_heading_elem is not None
+            else "Untitled Category"
+        )
+        doc.add_heading(cat_title, level=2)
+
+        # Process each problem card
+        problems = category.xpath(".//article[@class='problem-card']")
+        for problem in problems:
+            # Problem Title (Heading 3)
+            prob_title_elem = problem.find("./h3")
+            prob_title = (
+                prob_title_elem.text.strip()
+                if prob_title_elem is not None
+                else "Untitled Problem"
+            )
+            doc.add_heading(prob_title, level=3)
+
+            # Get description
+            desc_elem = problem.xpath(".//p[@class='description']")
+            description_text = ""
+            if desc_elem:
+                full_desc = desc_elem[0].text_content().strip()
+                if "Accessibility Description:" in full_desc:
+                    description_text = full_desc.split("Accessibility Description:")[1].strip()
+                else:
+                    description_text = full_desc
+
+            # Get Unicode linear math
+            linear_elem = problem.xpath(".//p[@class='linear-math']")
+            linear_text = ""
+            if linear_elem:
+                full_linear = linear_elem[0].text_content().strip()
+                if "Unicode Linear Math Equivalent:" in full_linear:
+                    linear_text = full_linear.split("Unicode Linear Math Equivalent:")[1].strip()
+                else:
+                    linear_text = full_linear
+
+            # Get KCS score
+            kcs_elem = problem.xpath(".//p[@class='kcs-score']")
+            kcs_text = ""
+            if kcs_elem:
+                full_kcs = kcs_elem[0].text_content().strip()
+                if "Keyboard Complexity Score (KCS):" in full_kcs:
+                    kcs_text = full_kcs.split("Keyboard Complexity Score (KCS):")[1].strip()
+                else:
+                    kcs_text = full_kcs
+
+            # Locate the MathML element
+            math_elements = problem.xpath(".//math")
+            if math_elements:
+                math_elem = math_elements[0]
+                # Convert the lxml element to a MathML string
+                mathml_str = lxml.etree.tostring(math_elem, encoding="unicode")
+
+                try:
+                    # Convert Presentation MathML to OMML XML string
+                    omml_str = math_ml2omml.convert(mathml_str)
+
+                    # Ensure OpenXML math namespaces are explicitly declared
+                    if "xmlns:m=" not in omml_str:
+                        omml_str = omml_str.replace(
+                            "<m:oMath",
+                            '<m:oMath xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"',
+                            1,
+                        )
+
+                    # Parse into a python-docx OxmlElement
+                    omml_xml_element = parse_xml(omml_str)
+
+                    # Create a paragraph for the equation
+                    eq_para = doc.add_paragraph()
+                    eq_para.paragraph_format.space_before = docx.shared.Pt(6)
+                    eq_para.paragraph_format.space_after = docx.shared.Pt(6)
+                    # Append the OMML math block directly to the paragraph's XML element
+                    eq_para._p.append(omml_xml_element)
+
+                except Exception as e:
+                    print(
+                        f"Warning: Failed to convert math block for '{prob_title}': {e}"
+                    )
+                    # Fallback to plain text LaTeX representations if conversion fails
+                    doc.add_paragraph(
+                        f"[Conversion Error: MathML could not be compiled. {e}]"
+                    )
+
+            # Add the descriptive text for screen readers/learning support (WCAG 2.2)
+            if description_text:
+                desc_para = doc.add_paragraph()
+                run = desc_para.add_run(f"Accessibility Description: {description_text}")
+                run.italic = True
+                run.font.color.rgb = docx.shared.RGBColor(100, 116, 139)
+
+            # Add Unicode linear math equivalent
+            if linear_text:
+                lin_para = doc.add_paragraph()
+                run = lin_para.add_run(f"Unicode Linear Math: {linear_text}")
+                run.font.color.rgb = docx.shared.RGBColor(30, 58, 138)
+                run.bold = True
+
+            # Add KCS score
+            if kcs_text:
+                kcs_para = doc.add_paragraph()
+                run = kcs_para.add_run(f"Keyboard Complexity Score (KCS): {kcs_text}")
+                run.font.color.rgb = docx.shared.RGBColor(185, 28, 28)
+                kcs_para.paragraph_format.space_after = docx.shared.Pt(18)
+
+            problem_count += 1
+
+    # 5. Save the compiled document
+    print(f"Saving Word document: {docx_path}")
+    doc.save(docx_path)
+    print(
+        f"Successfully converted {problem_count} equations and saved to {docx_path}"
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Convert HTML containing MathML equations to a Word document."
+    )
+    parser.add_argument(
+        "--input", "-i",
+        default=os.path.join(script_dir, "html_data.html"),
+        help="Path to the input HTML file (default: html_data.html in script directory)"
+    )
+    parser.add_argument(
+        "--output", "-o",
+        default=os.path.join(script_dir, "omml_data.docx"),
+        help="Path to the output Word document (default: omml_data.docx in script directory)"
+    )
+    args = parser.parse_args()
+
+    try:
+        convert_html_to_docx(args.input, args.output)
+    except Exception as err:
+        print(f"Error executing conversion: {err}", file=sys.stderr)
+        sys.exit(1)

mathml_to_omml-1.0.2/examples/convert_latex_word.py

@@ -0,0 +1,212 @@
+import os
+import sys
+import re
+import argparse
+
+# Gracefully check dependencies
+missing_deps = []
+try:
+    import latex2mathml.converter
+except ImportError:
+    missing_deps.append("latex2mathml")
+
+try:
+    import docx
+    from docx.oxml import parse_xml
+except ImportError:
+    missing_deps.append("python-docx")
+
+if missing_deps:
+    print(f"Error: Missing required dependencies: {', '.join(missing_deps)}", file=sys.stderr)
+    print(f"Please install them using: pip install {' '.join(missing_deps)}", file=sys.stderr)
+    sys.exit(1)
+
+# Ensure we can import math_ml2omml from the local src/ directory
+script_dir = os.path.dirname(os.path.abspath(__file__))
+src_path = os.path.abspath(os.path.join(script_dir, "..", "src"))
+sys.path.insert(0, src_path)
+
+try:
+    import math_ml2omml
+except ImportError:
+    print("Error: Could not import 'math_ml2omml' from src directory.", file=sys.stderr)
+    sys.exit(1)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Convert Markdown containing LaTeX math equations to a Word document."
+    )
+    parser.add_argument(
+        "--input", "-i",
+        default=os.path.join(script_dir, "latex_math_data.md"),
+        help="Path to the input Markdown file (default: latex_math_data.md in script directory)"
+    )
+    parser.add_argument(
+        "--output", "-o",
+        default=os.path.join(script_dir, "omml_latex_data.docx"),
+        help="Path to the output Word document (default: omml_latex_data.docx in script directory)"
+    )
+    parser.add_argument(
+        "--reference-linear", "-r",
+        default=os.path.join(script_dir, "linear_math_data.md"),
+        help="Optional path to reference linear math file to ensure exact metadata matching"
+    )
+    args = parser.parse_args()
+
+    md_path = args.input
+    docx_path = args.output
+    ref_path = args.reference_linear
+
+    print(f"Reading Markdown file: {md_path}")
+    if not os.path.exists(md_path):
+        print(f"Error: Markdown file does not exist at {md_path}")
+        return
+
+    with open(md_path, "r", encoding="utf-8") as f:
+        lines = f.readlines()
+
+    # Load reference linear math equations if available to guarantee exact metadata and KCS matching
+    ref_equations = []
+    if ref_path and os.path.exists(ref_path):
+        print(f"Loading reference linear math from: {ref_path}")
+        with open(ref_path, "r", encoding="utf-8") as f:
+            ref_lines = f.readlines()
+        for line in ref_lines:
+            line = line.strip()
+            if line.startswith("**Equation:**"):
+                m = re.search(r'`(.*?)`', line)
+                if m:
+                    ref_equations.append(m.group(1).strip())
+
+    categories = []
+    current_category = None
+    current_problem = None
+
+    for line in lines:
+        line = line.strip()
+        if line.startswith("## "):
+            category_name = line[3:].strip()
+            current_category = {"name": category_name, "problems": []}
+            categories.append(current_category)
+        elif line.startswith("### "):
+            title_part = line[4:].strip()
+            current_problem = {"title": title_part, "equation": "", "description": ""}
+            if current_category is not None:
+                current_category["problems"].append(current_problem)
+        elif line.startswith("**Equation:**"):
+            m = re.search(r'`(.*?)`', line)
+            if m and current_problem is not None:
+                current_problem["equation"] = m.group(1).strip()
+        elif line.startswith("**Description:**"):
+            desc_text = line[16:].strip()
+            if current_problem is not None:
+                current_problem["description"] = desc_text
+
+    print(f"Parsed {len(categories)} math categories. Initializing Word document compiler...")
+
+    # Initialize python-docx document
+    doc = docx.Document()
+
+    # Apply Standard Margins (1 inch)
+    sections = doc.sections
+    for section in sections:
+        section.top_margin = docx.shared.Inches(1)
+        section.bottom_margin = docx.shared.Inches(1)
+        section.left_margin = docx.shared.Inches(1)
+        section.right_margin = docx.shared.Inches(1)
+
+    # Document Header Title
+    doc.add_heading("University Mathematics Equation Reference Database (Compiled from LaTeX Math)", level=1)
+    doc.add_paragraph("This document serves as an empirical verification suite containing 200 university equations compiled directly from LaTeX math strings into native Word equation blocks (OMML) using the math_ml2omml package.")
+
+    problem_count = 0
+    for category in categories:
+        # Category Heading (Heading 2)
+        doc.add_heading(category["name"], level=2)
+
+        for problem in category["problems"]:
+            prob_title = problem["title"]
+            latex_str = problem["equation"]
+            description_text = problem["description"]
+
+            # Problem Title (Heading 3)
+            doc.add_heading(prob_title, level=3)
+
+            # Compile LaTeX directly to OMML using math_ml2omml (via MathML)
+            if latex_str:
+                try:
+                    # Convert LaTeX to MathML
+                    mathml_str = latex2mathml.converter.convert(latex_str)
+                    # Convert MathML to OMML
+                    omml_str = math_ml2omml.convert(mathml_str)
+
+                    # Ensure OpenXML math namespaces are explicitly declared
+                    if "xmlns:m=" not in omml_str:
+                        omml_str = omml_str.replace(
+                            "<m:oMath",
+                            '<m:oMath xmlns:m="http://schemas.openxmlformats.org/officeDocument/2006/math" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"',
+                            1,
+                        )
+
+                    omml_xml_element = parse_xml(omml_str)
+
+                    # Create a paragraph for the equation
+                    eq_para = doc.add_paragraph()
+                    eq_para.paragraph_format.space_before = docx.shared.Pt(6)
+                    eq_para.paragraph_format.space_after = docx.shared.Pt(6)
+                    eq_para._p.append(omml_xml_element)
+
+                except Exception as e:
+                    print(f"Warning: Failed to convert LaTeX math for '{prob_title}': {e}")
+                    doc.add_paragraph(f"[Conversion Error: LaTeX Math could not be compiled. {e}]")
+
+            # Determine the Unicode linear math representation
+            linear_str = ""
+            if problem_count < len(ref_equations):
+                # Use matching equation from reference linear math database
+                linear_str = ref_equations[problem_count]
+            else:
+                # Fallback to translating dynamically
+                if latex_str:
+                    try:
+                        linear_str = math_ml2omml.to_linear_math(latex_str)
+                    except Exception as e:
+                        print(f"Warning: Failed to translate to linear math dynamically for '{prob_title}': {e}")
+
+            # Calculate Keyboard Complexity Score (KCS)
+            kcs_score = 0.0
+            if linear_str:
+                try:
+                    kcs_score = math_ml2omml.calculate_kcs(linear_str)
+                except Exception as e:
+                    print(f"Warning: Failed to calculate KCS for '{prob_title}': {e}")
+
+            # Add Accessibility Description (WCAG 2.2)
+            if description_text:
+                desc_para = doc.add_paragraph()
+                run = desc_para.add_run(f"Accessibility Description: {description_text}")
+                run.italic = True
+                run.font.color.rgb = docx.shared.RGBColor(100, 116, 139)
+
+            # Add Unicode linear math equivalent (to match other documents)
+            if linear_str:
+                lin_para = doc.add_paragraph()
+                run = lin_para.add_run(f"Unicode Linear Math: {linear_str}")
+                run.font.color.rgb = docx.shared.RGBColor(30, 58, 138)
+                run.bold = True
+
+            # Add KCS score
+            kcs_para = doc.add_paragraph()
+            run = kcs_para.add_run(f"Keyboard Complexity Score (KCS): {kcs_score:.1f}")
+            run.font.color.rgb = docx.shared.RGBColor(185, 28, 28)
+            kcs_para.paragraph_format.space_after = docx.shared.Pt(18)
+
+            problem_count += 1
+
+    print(f"Saving compiled Word document: {docx_path}")
+    doc.save(docx_path)
+    print(f"Successfully converted and compiled {problem_count} equations to {docx_path}")
+
+if __name__ == "__main__":
+    main()