{"id":8347,"date":"2022-02-22T08:28:06","date_gmt":"2022-02-22T13:28:06","guid":{"rendered":"https:\/\/blogs.mathworks.com\/cleve\/?p=8347"},"modified":"2023-01-04T07:14:27","modified_gmt":"2023-01-04T12:14:27","slug":"what-is-aa","status":"publish","type":"post","link":"https:\/\/blogs.mathworks.com\/cleve\/2022\/02\/22\/what-is-aa\/","title":{"rendered":"What is A\\A?"},"content":{"rendered":"<div class=\"content\"><!--introduction--><p>The answer: <tt>A\\A<\/tt> is always <tt>I<\/tt>, except when it isn't.<\/p><!--\/introduction--><h3>Contents<\/h3><div><ul><li><a href=\"#ae338b95-f89b-4634-bbe2-add19f0fa92f\">Why A\\A ?<\/a><\/li><li><a href=\"#44882ad7-ebee-4871-946c-baab21cc1e31\">Mono-elemental matrices<\/a><\/li><li><a href=\"#d6de032f-e1da-47b9-8f08-4bf7acd2eeaa\">Nonsingular matrices<\/a><\/li><li><a href=\"#0152d18e-8c8d-4aa0-802c-1fe3807f3033\">Mono-elemental again<\/a><\/li><li><a href=\"#38c52489-7db2-4ba0-ad0c-156111d7643f\">Rank  deficient matrices<\/a><\/li><li><a href=\"#2e31bb2c-7c65-45ae-8d75-a1fecebbf576\">Lots of NaNs<\/a><\/li><li><a href=\"#c49fe7ce-b9fb-45da-8af6-e6842166dd89\">Magic squares<\/a><\/li><li><a href=\"#09b5c1de-53f5-47ed-b21b-270fe66f6aea\">Odd<\/a><\/li><li><a href=\"#fee1eea4-2f6d-4eac-aad6-c4941db49733\">Singly even<\/a><\/li><li><a href=\"#91e4c282-d92b-4198-9b30-0120fb80694a\">Doubly even<\/a><\/li><li><a href=\"#ba1706d3-0349-427a-bdec-9a4c6b6a59f9\">Pseudoinverse<\/a><\/li><li><a href=\"#5d730b9c-864f-4f18-8aac-f7fb5c2cd06b\">My Bottom Line<\/a><\/li><\/ul><\/div><h4>Why A\\A ?<a name=\"ae338b95-f89b-4634-bbe2-add19f0fa92f\"><\/a><\/h4><p>I have been explaining our backslash operator for almost 50 years, but I have to admit that the title of today's blog post looks a bit strange.  You never see <tt>3\\3<\/tt> for numbers. So, what is <tt>A\\A<\/tt> ?<\/p><p><tt>A\\A<\/tt>  solves the equation<\/p><pre>   |A*X = A|<\/pre><p>If <tt>A<\/tt> is square and nonsingular, then <tt>X<\/tt> = <tt>I<\/tt>. But what if <tt>A<\/tt> is rectangular, or singular, or not known exactly? These are all nontrivial questions.<\/p><p>This post is my response to a recent internal discussion at MathWorks about backslash generating NaNs.<\/p><h4>Mono-elemental matrices<a name=\"44882ad7-ebee-4871-946c-baab21cc1e31\"><\/a><\/h4><p>Any general statement about matrices should be applicable to 1-by-1 matrices in particular. For 1-by-1 matrices, there is an easy answer to  our question.<\/p><div><ul><li>If <tt>a<\/tt> is any  nonzero number, then <tt>a\\a = 1<\/tt>.<\/li><\/ul><\/div><p>My colleague Pete Stewart likes to use \"mono-elemental\" for this important class of matrices.<\/p><h4>Nonsingular matrices<a name=\"d6de032f-e1da-47b9-8f08-4bf7acd2eeaa\"><\/a><\/h4><p>When the 1-by-1 case is generalized to n-by-n with larger n, it becomes:<\/p><div><ul><li>If <tt>A<\/tt> is any nonsingular matrix, then <tt>A\\A = I<\/tt>,<\/li><\/ul><\/div><p>This is not the end of the story, of course.  It's our job to investigate approximately nonsingular and approximately equals.<\/p><h4>Mono-elemental again<a name=\"0152d18e-8c8d-4aa0-802c-1fe3807f3033\"><\/a><\/h4><p>When my daughter was in the fifth grade, her math teacher told her that mathematicians hadn't figured out yet how to divide by zero.  But the authors of the IEEE 754 standard for floating point arithmetic have figured it out and have assured us that <tt>0\\0<\/tt> is not equal to <tt>1<\/tt>, but rather<\/p><div><ul><li>If <tt>a = 0<\/tt>, then <tt>0\\0<\/tt> is Not-A-Number.<\/li><\/ul><\/div><p>And, for a diagonal matrix of any order, this scalar case is applicable to each diagonal element.<\/p><h4>Rank  deficient matrices<a name=\"38c52489-7db2-4ba0-ad0c-156111d7643f\"><\/a><\/h4><p>If <tt>A<\/tt> is a <i>rank deficient<\/i>  matrix with rank <tt>r<\/tt> &lt; <tt>n<\/tt>, then <tt>A\\A<\/tt> cannot possibly be <tt>I<\/tt>.  The rank of the product of two matrices cannot be larger than rank of either matrix.  So <tt>A\\A<\/tt> cannot outrank <tt>A<\/tt> itself and<\/p><div><ul><li>If <tt>A<\/tt> is rank deficient, then <tt>A\\A<\/tt> is definitely not <tt>I<\/tt>.<\/li><\/ul><\/div><p>It just so happens that the most recent issue of <i>SIAM Review<\/i> includes the paper about matrix rank, \"LU and CR Elimination\", by my colleague Gil Strang and myself.  The paper is available from the <a href=\"https:\/\/epubs.siam.org\/doi\/epdf\/10.1137\/20M1358694\">SIAM web site<\/a>. Another pointer is this <a href=\"https:\/\/blogs.mathworks.com\/cleve\/2020\/10\/23\/\">Cleve's Corner<\/a>.<\/p><h4>Lots of NaNs<a name=\"2e31bb2c-7c65-45ae-8d75-a1fecebbf576\"><\/a><\/h4><p>Here are three examples where <tt>A\\A<\/tt> generates <tt>NaN<\/tt> .<\/p><pre class=\"codeinput\">     A = 0\r\n     B = [1 0; 0 0]\r\n     C = [1 2; 4 8]\r\n\r\n     X = A\\A\r\n     Y = B\\B\r\n     Z = C\\C\r\n<\/pre><pre class=\"codeoutput\">\r\nA =\r\n\r\n     0\r\n\r\n\r\nB =\r\n\r\n     1     0\r\n     0     0\r\n\r\n\r\nC =\r\n\r\n     1     2\r\n     4     8\r\n\r\n\r\nX =\r\n\r\n   NaN\r\n\r\n\r\nY =\r\n\r\n     1     0\r\n   NaN   NaN\r\n\r\n\r\nZ =\r\n\r\n   NaN   NaN\r\n   NaN   NaN\r\n\r\n<\/pre><h4>Magic squares<a name=\"c49fe7ce-b9fb-45da-8af6-e6842166dd89\"><\/a><\/h4><p>I always like to investigate any property of matrices by checking out magic squares.<\/p><pre class=\"codeinput\">    small_fig\r\n    warning <span class=\"string\">off<\/span>\r\n    nmax = 50;\r\n    r = zeros(nmax,1);\r\n    e = zeros(nmax,1);\r\n\r\n    <span class=\"keyword\">for<\/span> n  = 1:nmax\r\n        A = magic(n);\r\n        X = A\\A;\r\n        I = eye(n);\r\n        r(n) = rank(A);\r\n        e(n) = norm(X-I);\r\n    <span class=\"keyword\">end<\/span>\r\n<\/pre><h4>Odd<a name=\"09b5c1de-53f5-47ed-b21b-270fe66f6aea\"><\/a><\/h4><p>MATLAB uses three different algorithms for computing magic squares, odd, singly even and doubly even. If the order <tt>n<\/tt> is odd, then <tt>A  = magic(n)<\/tt> is nonsingular, the rank of <tt>A<\/tt> is <tt>n<\/tt> and the elements of the computed <tt>A\\A<\/tt> are within roundoff error of the elements of <tt>I<\/tt>. Notice that the scale factor for the error plot is 3.0e-15.<\/p><pre class=\"codeinput\">    n = 3:2:nmax;\r\n    plots(n,r,60,e,[],<span class=\"string\">\"Odd\"<\/span>)\r\n<\/pre><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"http:\/\/blogs.mathworks.com\/cleve\/files\/AslashA_blog_02.png\" alt=\"\"> <h4>Singly even<a name=\"fee1eea4-2f6d-4eac-aad6-c4941db49733\"><\/a><\/h4><p>If the order <tt>n<\/tt> is divisible by <tt>2<\/tt>, but not by <tt>4<\/tt>, then <tt>magic(n)<\/tt> is rank deficient.  Its rank is about half its order. The error plot reflects the fact that <tt>A\\A<\/tt> is not <tt>I<\/tt>.<\/p><pre class=\"codeinput\">    n = 2:4:nmax;\r\n    plots(n,r,60,e,200,<span class=\"string\">\"Singly even\"<\/span>)\r\n<\/pre><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"http:\/\/blogs.mathworks.com\/cleve\/files\/AslashA_blog_03.png\" alt=\"\"> <h4>Doubly even<a name=\"91e4c282-d92b-4198-9b30-0120fb80694a\"><\/a><\/h4><p>If the order <tt>n<\/tt> is divisible by <tt>4<\/tt>, then <tt>magic(n)<\/tt> is very rank deficient. The rank is always <tt>3<\/tt>. The error plots are all over the place.  Orders <tt>8<\/tt> and <tt>40<\/tt> have errors that are larger than my plot scale. Orders <tt>16<\/tt> and <tt>32<\/tt> are missing entirely because computing <tt>A\\A<\/tt> encounters <tt>0\\0<\/tt> resulting in <tt>NaN<\/tt>.<\/p><pre class=\"codeinput\">    n = 4:4:nmax;\r\n    plots(n,r,12,e,750,<span class=\"string\">\"Doubly even\"<\/span>)\r\n<\/pre><img decoding=\"async\" vspace=\"5\" hspace=\"5\" src=\"http:\/\/blogs.mathworks.com\/cleve\/files\/AslashA_blog_04.png\" alt=\"\"> <h4>Pseudoinverse<a name=\"ba1706d3-0349-427a-bdec-9a4c6b6a59f9\"><\/a><\/h4><p>Is <tt>pinv(A)*b<\/tt> more \"robust\" than <tt>A\\b<\/tt>?<\/p><p>You should not use <tt>pinv<\/tt> just to create solutions to problems that do not have solutions. The pseudoinverse is intended to characterize the solution to a specific technical question: if a system of linear equations has many solutions, which is the shortest one? If you replace <tt>A\\b<\/tt> by <tt>pinv(A)*b<\/tt>, be sure that is what you want.<\/p><p>Using pinv instead of backslash does not do away with rank deficiency. The difficulties are already present in mono-elemental matrices. The only rank deficient 1-by-1 matrix is <tt>0<\/tt>  and  <tt>pinv(0)<\/tt> = <tt>0<\/tt>. This is less in-your-face than <tt>NaN<\/tt>, but there is no way you can make <tt>pinv(0)*0<\/tt> equal to <tt>1<\/tt>.<\/p><p>When I redo the examples above, I get<\/p><pre class=\"codeinput\">     A = 0\r\n     B = [1 0; 0 0]\r\n     C = [1 2; 4 8]\r\n\r\n     X = pinv(A)*A\r\n     Y = pinv(B)*B\r\n     Z = pinv(C)*C\r\n<\/pre><pre class=\"codeoutput\">\r\nA =\r\n\r\n     0\r\n\r\n\r\nB =\r\n\r\n     1     0\r\n     0     0\r\n\r\n\r\nC =\r\n\r\n     1     2\r\n     4     8\r\n\r\n\r\nX =\r\n\r\n     0\r\n\r\n\r\nY =\r\n\r\n     1     0\r\n     0     0\r\n\r\n\r\nZ =\r\n\r\n    0.2000    0.4000\r\n    0.4000    0.8000\r\n\r\n<\/pre><p>The NaNs are gone, but is this really \"more robust\" than backslash? If you still think so, explain where <tt>Z<\/tt> comes from.<\/p><h4>My Bottom Line<a name=\"5d730b9c-864f-4f18-8aac-f7fb5c2cd06b\"><\/a><\/h4><p>This has been about square, dense, nonsymmetric matrices <tt>A<\/tt>. For such matrices:<\/p><div><ul><li><tt>A\\A<\/tt> may produce <tt>NaN<\/tt> for rank-deficient matrices.<\/li><\/ul><\/div><div><ul><li><tt>pinv(A)*A<\/tt> avoids <tt>NaN<\/tt> by attempting to hide rank-deficient matrices.<\/li><\/ul><\/div><script language=\"JavaScript\"> <!-- \r\n    function grabCode_926242405a7b4785ab042fe10e46e0ad() {\r\n        \/\/ Remember the title so we can use it in the new page\r\n        title = document.title;\r\n\r\n        \/\/ Break up these strings so that their presence\r\n        \/\/ in the Javascript doesn't mess up the search for\r\n        \/\/ the MATLAB code.\r\n        t1='926242405a7b4785ab042fe10e46e0ad ' + '##### ' + 'SOURCE BEGIN' + ' #####';\r\n        t2='##### ' + 'SOURCE END' + ' #####' + ' 926242405a7b4785ab042fe10e46e0ad';\r\n    \r\n        b=document.getElementsByTagName('body')[0];\r\n        i1=b.innerHTML.indexOf(t1)+t1.length;\r\n        i2=b.innerHTML.indexOf(t2);\r\n \r\n        code_string = b.innerHTML.substring(i1, i2);\r\n        code_string = code_string.replace(\/REPLACE_WITH_DASH_DASH\/g,'--');\r\n\r\n        \/\/ Use \/x3C\/g instead of the less-than character to avoid errors \r\n        \/\/ in the XML parser.\r\n        \/\/ Use '\\x26#60;' instead of '<' so that the XML parser\r\n        \/\/ doesn't go ahead and substitute the less-than character. \r\n        code_string = code_string.replace(\/\\x3C\/g, '\\x26#60;');\r\n\r\n        copyright = 'Copyright 2022 The MathWorks, Inc.';\r\n\r\n        w = window.open();\r\n        d = w.document;\r\n        d.write('<pre>\\n');\r\n        d.write(code_string);\r\n\r\n        \/\/ Add copyright line at the bottom if specified.\r\n        if (copyright.length > 0) {\r\n            d.writeln('');\r\n            d.writeln('%%');\r\n            if (copyright.length > 0) {\r\n                d.writeln('% _' + copyright + '_');\r\n            }\r\n        }\r\n\r\n        d.write('<\/pre>\\n');\r\n\r\n        d.title = title + ' (MATLAB code)';\r\n        d.close();\r\n    }   \r\n     --> <\/script><p style=\"text-align: right; font-size: xx-small; font-weight:lighter;   font-style: italic; color: gray\"><br><a href=\"javascript:grabCode_926242405a7b4785ab042fe10e46e0ad()\"><span style=\"font-size: x-small;        font-style: italic;\">Get \r\n      the MATLAB code <noscript>(requires JavaScript)<\/noscript><\/span><\/a><br><br>\r\n      Published with MATLAB&reg; R2022a<br><\/p><\/div><!--\r\n926242405a7b4785ab042fe10e46e0ad ##### SOURCE BEGIN #####\r\n%% What is A\\A ?\r\n% The answer: |A\\A| is always |I|,\r\n% except when it isn't.\r\n\r\n%% Why A\\A ?\r\n% I have been explaining our backslash operator for almost 50 years,\r\n% but I have to admit that the title of today's blog post looks a \r\n% bit strange.  You never see |3\\3| for numbers.\r\n% So, what is |A\\A| ?\r\n%\r\n% |A\\A|  solves the equation\r\n% \r\n%     |A*X = A|\r\n%  \r\n% If |A| is square and nonsingular, then |X| = |I|.\r\n% But what if |A| is rectangular, or singular, or not known exactly?\r\n% These are all nontrivial questions.\r\n%\r\n% This post is my response to a recent internal discussion at MathWorks \r\n% about backslash generating NaNs.\r\n%\r\n%% Mono-elemental matrices\r\n% Any general statement about matrices should be applicable to\r\n% 1-by-1 matrices in particular. For 1-by-1 matrices, \r\n% there is an easy answer to  our question. \r\n%\r\n% * If |a| is any  nonzero number, then |a\\a = 1|.\r\n%\r\n% My colleague Pete Stewart likes to use \"mono-elemental\"\r\n% for this important class of matrices.\r\n\r\n%% Nonsingular matrices\r\n% When the 1-by-1 case is generalized to n-by-n with larger n,\r\n% it becomes: \r\n%\r\n% * If |A| is any nonsingular matrix, then |A\\A = I|,\r\n%\r\n% This is not the end of the story, of course.  It's our job to \r\n% investigate approximately nonsingular and approximately equals.\r\n\r\n%% Mono-elemental again\r\n% When my daughter was in the fifth grade, her math teacher told her\r\n% that mathematicians\r\n% hadn't figured out yet how to divide by zero.  But the authors of the\r\n% IEEE 754 standard for floating point arithmetic have figured it out\r\n% and have assured us that |0\\0| is not equal to |1|, but rather\r\n%\r\n% * If |a = 0|, then |0\\0| is Not-A-Number.\r\n%\r\n% And, for a diagonal matrix of any order,\r\n% this scalar case is applicable to each diagonal element.\r\n\r\n%% Rank  deficient matrices\r\n% If |A| is a _rank deficient_  matrix with rank |r| < |n|,\r\n% then |A\\A| cannot possibly be |I|.  The rank of the product \r\n% of two matrices cannot be larger than rank of either\r\n% matrix.  So |A\\A| cannot outrank |A| itself and\r\n%\r\n% * If |A| is rank deficient, then |A\\A| is definitely not |I|.\r\n%\r\n% It just so happens that the most recent issue of _SIAM Review_\r\n% includes the paper about matrix rank, \"LU and CR Elimination\",\r\n% by my colleague Gil Strang and myself.  The paper is available from\r\n% the \r\n% <https:\/\/epubs.siam.org\/doi\/epdf\/10.1137\/20M1358694\r\n% SIAM web site.  Another pointer is this\r\n% <https:\/\/blogs.mathworks.com\/cleve\/2020\/10\/23\/ Cleve's Corner>.\r\n\r\n%% Lots of NaNs\r\n% Here are three examples where |A\\A| generates \r\n% |NaN| .\r\n%\r\n     A = 0\r\n     B = [1 0; 0 0]\r\n     C = [1 2; 4 8]\r\n     \r\n     X = A\\A\r\n     Y = B\\B\r\n     Z = C\\C\r\n         \r\n%% Magic squares\r\n% I always like to investigate any property of matrices by\r\n% checking out magic squares.\r\n\r\n    small_fig\r\n    warning off\r\n    nmax = 50;\r\n    r = zeros(nmax,1);\r\n    e = zeros(nmax,1);\r\n  \r\n    for n  = 1:nmax\r\n        A = magic(n); \r\n        X = A\\A;\r\n        I = eye(n);\r\n        r(n) = rank(A);\r\n        e(n) = norm(X-I);\r\n    end\r\n\r\n%% Odd\r\n% MATLAB uses three different algorithms for computing magic squares,\r\n% odd, singly even and doubly even.\r\n% If the order |n| is odd, then |A  = magic(n)| is nonsingular,\r\n% the rank of |A| is |n| and the elements of the computed |A\\A|\r\n% are within roundoff error of the elements of |I|.\r\n% Notice that the scale factor for the error plot is 3.0e-15.\r\n\r\n    n = 3:2:nmax;\r\n    plots(n,r,60,e,[],\"Odd\")\r\n    \r\n%% Singly even\r\n% If the order |n| is divisible by |2|, but not by |4|, then |magic(n)|\r\n% is rank deficient.  Its rank is about half its order.\r\n% The error plot reflects the fact that |A\\A| is not |I|.\r\n\r\n    n = 2:4:nmax;\r\n    plots(n,r,60,e,200,\"Singly even\")\r\n\r\n%% Doubly even\r\n% If the order |n| is divisible by |4|, then |magic(n)| is very\r\n% rank deficient. The rank is always |3|.\r\n% The error plots are all over the place.  Orders |8| and |40|\r\n% have errors that are larger than my plot scale.\r\n% Orders |16| and |32|\r\n% are missing entirely because computing |A\\A| encounters |0\\0|\r\n% resulting in |NaN|.\r\n\r\n    n = 4:4:nmax;\r\n    plots(n,r,12,e,750,\"Doubly even\")\r\n    \r\n%% Pseudoinverse\r\n% Is |pinv(A)*b| more \"robust\" than |A\\b|?\r\n%\r\n% You should not use |pinv| just to create solutions to\r\n% problems that do not have solutions.\r\n% The pseudoinverse is intended to characterize the solution to a specific\r\n% technical question: if a system of linear equations has many\r\n% solutions, which is the shortest one?\r\n% If you replace |A\\b| by |pinv(A)*b|, be sure that is what you want.\r\n%\r\n% Using pinv instead of backslash does not do away with rank deficiency.\r\n% The difficulties are already present in mono-elemental matrices.\r\n% The only rank deficient 1-by-1 matrix is |0|  and  |pinv(0)| = |0|.\r\n% This is less in-your-face than |NaN|, but there is no way\r\n% you can make |pinv(0)*0| equal to |1|.\r\n%\r\n% When I redo the examples above, I get \r\n\r\n     A = 0\r\n     B = [1 0; 0 0]\r\n     C = [1 2; 4 8]\r\n     \r\n     X = pinv(A)*A\r\n     Y = pinv(B)*B\r\n     Z = pinv(C)*C\r\n\r\n%%\r\n% The NaNs are gone, but is this really \"more robust\" than backslash?\r\n% If you still think so, explain where |Z| comes from.\r\n\r\n%% My Bottom Line\r\n% This has been about square, dense, nonsymmetric matrices |A|.\r\n% For such matrices:\r\n%\r\n% * |A\\A| may produce |NaN| for rank-deficient matrices.\r\n% \r\n% * |pinv(A)*A| avoids |NaN| by attempting to hide rank-deficient matrices.\r\n##### SOURCE END ##### 926242405a7b4785ab042fe10e46e0ad\r\n-->","protected":false},"excerpt":{"rendered":"<div class=\"overview-image\"><img src=\"https:\/\/blogs.mathworks.com\/cleve\/files\/AslashA_blog_04.png\" class=\"img-responsive attachment-post-thumbnail size-post-thumbnail wp-post-image\" alt=\"\" decoding=\"async\" loading=\"lazy\" \/><\/div><!--introduction--><p>The answer: <tt>A\\A<\/tt> is always <tt>I<\/tt>, except when it isn't.... <a class=\"read-more\" href=\"https:\/\/blogs.mathworks.com\/cleve\/2022\/02\/22\/what-is-aa\/\">read more >><\/a><\/p>","protected":false},"author":78,"featured_media":8365,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[9,6,16],"tags":[],"_links":{"self":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts\/8347"}],"collection":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/users\/78"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/comments?post=8347"}],"version-history":[{"count":4,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts\/8347\/revisions"}],"predecessor-version":[{"id":9590,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/posts\/8347\/revisions\/9590"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/media\/8365"}],"wp:attachment":[{"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/media?parent=8347"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/categories?post=8347"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.mathworks.com\/cleve\/wp-json\/wp\/v2\/tags?post=8347"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}