@@ -99,8 +99,45 @@ public void ControlWordDoesNotConsumeFollowingStar() {
     [Theory]
     [InlineData(@"\not=", "≠", @"\neq ")]
     [InlineData(@"\not<", "≮", @"\nless ")]
+    [InlineData(@"\not>", "≯", @"\ngtr ")]
     [InlineData(@"\not\leq", "≰", @"\nleq ")]
+    [InlineData(@"\not\le", "≰", @"\nleq ")]
+    [InlineData(@"\not\leqslant", "⩽\u0338", @"\nleqslant ")]
+    [InlineData(@"\not\leqq", "≦\u0338", @"\nleqq ")]
     [InlineData(@"\not\in", "∉", @"\notin ")]
+    [InlineData(@"\not\geq", "≱", @"\ngeq ")]
+    [InlineData(@"\not\ge", "≱", @"\ngeq ")]
+    [InlineData(@"\not\geqslant", "⩾\u0338", @"\ngeqslant ")]
+    [InlineData(@"\not\geqq", "≧\u0338", @"\ngeqq ")]
+    [InlineData(@"\not\prec", "⊀", @"\nprec ")]
+    [InlineData(@"\not\preceq", "⪯\u0338", @"\npreceq ")]
+    [InlineData(@"\not\preccurlyeq", "⋠", @"\npreccurlyeq ")]
+    [InlineData(@"\not\sim", "≁", @"\nsim ")]
+    [InlineData(@"\not\mid", "∤", @"\nshortmid ")]
+    [InlineData(@"\not\shortmid", "∤", @"\nshortmid ")]
+    [InlineData(@"\not\vdash", "⊬", @"\nvdash ")]
+    [InlineData(@"\not\vDash", "⊭", @"\nvDash ")]
+    [InlineData(@"\not\Vdash", "⊮", @"\nVdash ")]
+    [InlineData(@"\not\subseteq", "⊈", @"\nsubseteq ")]
+    [InlineData(@"\not\supseteq", "⊉", @"\nsupseteq ")]
+    [InlineData(@"\not\succ", "⊁", @"\nsucc ")]
+    [InlineData(@"\not\succeq", "⪰\u0338", @"\nsucceq ")]
+    [InlineData(@"\not\succcurlyeq", "⋡", @"\nsucccurlyeq ")]
+    [InlineData(@"\not\parallel", "∦", @"\nshortparallel ")]
+    [InlineData(@"\not\shortparallel", "∦", @"\nshortparallel ")]
+    [InlineData(@"\not\vartriangleleft", "⋪", @"\ntriangleleft ")]
+    [InlineData(@"\not\trianglelefteq", "⋬", @"\ntrianglelefteq ")]
+    [InlineData(@"\not\vartriangleright", "⋫", @"\ntriangleright ")]
+    [InlineData(@"\not\trianglerighteq", "⋭", @"\ntrianglerighteq ")]
+    [InlineData(@"\not\cong", "≇", @"\ncong ")]
+    [InlineData(@"\not\gets", "↚", @"\nleftarrow ")]
+    [InlineData(@"\not\leftarrow", "↚", @"\nleftarrow ")]
+    [InlineData(@"\not\Leftarrow", "⇍", @"\nLeftarrow ")]
+    [InlineData(@"\not\rightarrow", "↛", @"\nrightarrow ")]
+    [InlineData(@"\not\to", "↛", @"\nrightarrow ")]
+    [InlineData(@"\not\Rightarrow", "⇏", @"\nRightarrow ")]
+    [InlineData(@"\not\leftrightarrow", "↮", @"\nleftrightarrow ")]
+    [InlineData(@"\not\Leftrightarrow", "⇎", @"\nLeftrightarrow ")]
     public void NotNegatesRelation(string input, string nucleus, string output) {
       var list = ParseLaTeX(input);
 
@@ -119,26 +156,40 @@ public void NotRejectsNonRelation(string input) {
       Assert.Contains(@"\not must be followed by a relation", error);
     }
 
-    [Fact]
-    public void NotUsesCombiningOverlayForUnsupportedRelation() {
-      var list = ParseLaTeX(@"\not\approx");
+    [Theory]
+    [InlineData(@"\not\approx", "≉", @"\not \approx ")]
+    [InlineData(@"\not\equiv", "≢", @"\not \equiv ")]
+    [InlineData(@"\not\subset", "⊄", @"\not \subset ")]
+    [InlineData(@"\not\ni", "∌", @"\not \ni ")]
+    public void NotUsesUnicodePrecomposedNegationWhenAvailable(string input, string nucleus, string output) {
+      var list = ParseLaTeX(input);
+
+      var relation = Assert.IsType<Relation>(Assert.Single(list));
+      Assert.Equal(nucleus, relation.Nucleus);
+      var serialized = LaTeXParser.MathListToLaTeX(list).ToString();
+      Assert.Equal(output, serialized);
+      Assert.Equal(list, ParseLaTeX(serialized));
+    }
 
+    [Fact]
+    public void NotUsesCombiningOverlayWhenNoPrecomposedNegationExists() {
+      var list = ParseLaTeX(@"\not\propto");
       var relation = Assert.IsType<Relation>(Assert.Single(list));
-      Assert.Equal("≈\u0338", relation.Nucleus);
+      Assert.Equal("∝\u0338", relation.Nucleus);
       var serialized = LaTeXParser.MathListToLaTeX(list).ToString();
-      Assert.Equal(@"\not \approx ", serialized);
+      Assert.Equal(@"\not \propto ", serialized);
       Assert.Equal(list, ParseLaTeX(serialized));
     }
 
     [Fact]
     public void NotSerializesScriptsOnOuterRelation() {
-      var list = ParseLaTeX(@"\not\approx^2");
+      var list = ParseLaTeX(@"\not\propto^2");
 
       var relation = Assert.IsType<Relation>(Assert.Single(list));
-      Assert.Equal("≈\u0338", relation.Nucleus);
+      Assert.Equal("∝\u0338", relation.Nucleus);
       Assert.Equal("2", Assert.Single(relation.Superscript).Nucleus);
       var serialized = LaTeXParser.MathListToLaTeX(list).ToString();
-      Assert.Equal(@"\not \approx ^2", serialized);
+      Assert.Equal(@"\not \propto ^2", serialized);
       Assert.Equal(list, ParseLaTeX(serialized));
     }
 
 
@@ -26,10 +26,10 @@ public void CommandsAreDisplayable(Rune ch) =>
       Assert.Contains(typefaces, font => font.GetGlyphIndex(ch.Value) != 0);
 
     [Fact]
-    public void NotApproximatelyOverlaysApproximately() {
+    public void NotProportionalToOverlaysProportionalTo() {
       var fonts = new Fonts(Array.Empty<Typography.OpenFont.Typeface>(), 20);
-      var negatedLine = Assert.Single(ParseLine(@"\not\approx", fonts).Displays);
-      var baseLine = Assert.Single(ParseLine(@"\approx", fonts).Displays);
+      var negatedLine = Assert.Single(ParseLine(@"\not\propto", fonts).Displays);
+      var baseLine = Assert.Single(ParseLine(@"\propto", fonts).Displays);
       Assert.IsType<TextLineDisplay<Fonts, Glyph>>(negatedLine);
       Assert.IsType<TextLineDisplay<Fonts, Glyph>>(baseLine);
       var negatedTextLine = (TextLineDisplay<Fonts, Glyph>)negatedLine;
@@ -38,7 +38,7 @@ public void NotApproximatelyOverlaysApproximately() {
       Assert.Single(baseTextLine.Runs);
       Assert.Equal(2, negatedRun.Run.Length);
 
-      var expectedBase = GlyphFinder.Instance.Lookup(fonts, 0x2248);
+      var expectedBase = GlyphFinder.Instance.Lookup(fonts, 0x221D);
       var expectedOverlay = GlyphFinder.Instance.Lookup(fonts, 0x0338);
       Assert.Equal(expectedBase.Info.GlyphIndex, negatedRun.Run.GlyphInfos[0].Glyph.Info.GlyphIndex);
       Assert.Same(expectedBase.Typeface, negatedRun.Run.GlyphInfos[0].Glyph.Typeface);
 
@@ -76,6 +76,7 @@ public sealed class TestRenderingMathData : TestRenderingSharedData<TestRenderin
     public const string Nothing = @"";
     public const string NotEquals = @"\not=";
     public const string NotApproximately = @"\not\approx";
+    public const string NotProportionalTo = @"\not\propto";
     public const string Overline = @"\overline{Overline}";
     public const string Pi = @"\pi";
     public const string Phi = @"\phi";
@@ -137,4 +138,4 @@ public sealed class TestRenderingMathData : TestRenderingSharedData<TestRenderin
 
     public const string VectorProjection = @"Proj_\vec{v}\vec{u}=|\vec u|\cos\theta\times\frac\vec v{|\vec v|}=|\vec u|\frac{\vec u \cdot \vec v}{|\vec u||\vec v|}\times\frac\vec v{|\vec v|}\\\text{Suppose \mathit{u} and \mathit v are unit vectors, }Proj_\vec v\vec u = (\vec u\cdot\vec v)\vec v";
   }
-}
+}
@@ -681,9 +681,11 @@ static bool MathAtomToLaTeX(MathAtom atom, StringBuilder builder,
             break;
           case Relation { Nucleus: { } nucleus }
             when LaTeXSettings.CommandForAtom(atom) is null
-              && nucleus.Length > 0 && nucleus[nucleus.Length - 1] == '\u0338':
+              && nucleus.Normalize(NormalizationForm.FormD) is { } decomposed
+              && decomposed.Length > 0 && decomposed[decomposed.Length - 1] == '\u0338':
             builder.Append(@"\not ");
-            var baseRelation = new Relation(nucleus.Substring(0, nucleus.Length - 1));
+            var baseRelation = new Relation(
+              decomposed.Substring(0, decomposed.Length - 1).Normalize(NormalizationForm.FormC));
             if (LaTeXSettings.CommandForAtom(baseRelation) is string baseCommand) {
               builder.Append(baseCommand);
               if (baseCommand.AsSpan().StartsWithInvariant(@"\"))
 
@@ -9,6 +9,32 @@ namespace CSharpMath.Atom {
   using Atoms;
   //https://mirror.hmc.edu/ctan/macros/latex/contrib/unicode-math/unimath-symbols.pdf
   public static class LaTeXSettings {
+    // Unlike LaTeX, where \not is a relation glyph that overstrikes the next
+    // atom (see the kernel's \neq/\ne definitions and \not declaration:
+    // https://github.com/latex3/latex2e/blob/develop/base/fontdef.dtx#L1122-L1128,
+    // https://github.com/latex3/latex2e/blob/develop/base/fontdef.dtx#L1167-L1170),
+    // CSharpMath consumes one Relation and chooses the best Unicode negation.
+    // This follows UTR #25's preference for precomposed operators, using U+0338
+    // only when no precomposed form exists: https://www.unicode.org/reports/tr25/.
+    static readonly IReadOnlyDictionary<string, string> NegatedRelationCommands =
+      new Dictionary<string, string> {
+        ["="] = @"\neq", ["<"] = @"\nless", [">"] = @"\ngtr",
+        [@"\in"] = @"\notin", [@"\leq"] = @"\nleq", [@"\leqslant"] = @"\nleqslant",
+        [@"\leqq"] = @"\nleqq", [@"\prec"] = @"\nprec", [@"\preceq"] = @"\npreceq",
+        [@"\preccurlyeq"] = @"\npreccurlyeq",
+        [@"\sim"] = @"\nsim", [@"\mid"] = @"\nmid", [@"\shortmid"] = @"\nshortmid",
+        [@"\vdash"] = @"\nvdash", [@"\vDash"] = @"\nvDash", [@"\Vdash"] = @"\nVdash",
+        [@"\vartriangleleft"] = @"\ntriangleleft", [@"\trianglelefteq"] = @"\ntrianglelefteq",
+        [@"\subseteq"] = @"\nsubseteq", [@"\geq"] = @"\ngeq", [@"\geqslant"] = @"\ngeqslant",
+        [@"\geqq"] = @"\ngeqq", [@"\succ"] = @"\nsucc", [@"\succeq"] = @"\nsucceq",
+        [@"\succcurlyeq"] = @"\nsucccurlyeq",
+        [@"\parallel"] = @"\nparallel", [@"\shortparallel"] = @"\nshortparallel",
+        [@"\vartriangleright"] = @"\ntriangleright", [@"\trianglerighteq"] = @"\ntrianglerighteq",
+        [@"\supseteq"] = @"\nsupseteq", [@"\cong"] = @"\ncong",
+        [@"\leftarrow"] = @"\nleftarrow", [@"\Leftarrow"] = @"\nLeftarrow",
+        [@"\rightarrow"] = @"\nrightarrow", [@"\Rightarrow"] = @"\nRightarrow",
+        [@"\leftrightarrow"] = @"\nleftrightarrow", [@"\Leftrightarrow"] = @"\nLeftrightarrow",
+      };
     static readonly Dictionary<Boundary, string> boundaryDelimitersReverse = new Dictionary<Boundary, string>();
     public static IReadOnlyDictionary<Boundary, string> BoundaryDelimitersReverse => boundaryDelimitersReverse;
     public static LaTeXCommandDictionary<Boundary> BoundaryDelimiters { get; } =
@@ -199,24 +225,17 @@ public static class LaTeXSettings {
                 || relation.Subscript.IsNonEmpty() || relation.Superscript.IsNonEmpty())
               return Err(@"\not must be followed by a relation");
 
-            // Resolve the negation through the symbol table so the resulting atom
-            // remains a normal relation and serializes back to canonical LaTeX.
+            // Prefer an explicit, semantically exact named negation. In particular,
+            // do not infer names such as \lneq or \lnapprox: those are refinements,
+            // not simply \not applied to the positive relation.
             var command = CommandForAtom(relation);
-            var negatedCommand = command switch {
-              "=" => @"\neq",
-              "<" => @"\nless",
-              ">" => @"\ngtr",
-              @"\in" => @"\notin",
-              _ when command is { Length: > 1 } && command[0] == '\\' =>
-                @"\n" + command.Substring(1),
-              _ => null
-            };
-            if (negatedCommand != null && AtomForCommand(negatedCommand) is Relation negated)
+            if (command != null && NegatedRelationCommands.TryGetValue(command, out var negatedCommand)
+                && AtomForCommand(negatedCommand) is Relation negated)
               return Ok(negated);
 
-            // A combining long solidus is the generic representation for a
-            // relation without a dedicated Unicode/LaTeX negation.
-            return Ok(new Relation(relation.Nucleus + "\u0338"));
+            // UTR #25 recommends a precomposed operator where Unicode provides
+            // one, and the combining long solidus otherwise.
+            return Ok(new Relation((relation.Nucleus + "\u0338").Normalize(NormalizationForm.FormC)));
           }) },
         { @"\operatorname", (parser, accumulate, stopChar) => {
           if (!parser.ReadCharIfAvailable('{')) return "Expected {";