Defactoring - Revision history

Cmloegcmluin: update link

2021-12-20T19:26:06Z

update link

← Older revision		Revision as of 19:26, 20 December 2021
Line 1:		Line 1:
	#REDIRECT [[Saturation,_torsion,_and_contorsion#Defactoring]]		#REDIRECT [[Saturation,_torsion,_and_contorsion#Defactoring/enfactoring]]

Cmloegcmluin: fix double redirect

2021-11-17T16:54:52Z

fix double redirect

← Older revision		Revision as of 16:54, 17 November 2021
Line 1:		Line 1:
	#REDIRECT [[Saturation,_torsion,~~_contorsion,_and_defactoring~~#Defactoring]]		#REDIRECT [[Saturation,_torsion,_and_contorsion#Defactoring]]

Cmloegcmluin: explode page out to separate articles and merged saturation/torsion/contorsion/defactoring page for general audiences

2021-11-12T22:53:50Z

explode page out to separate articles and merged saturation/torsion/contorsion/defactoring page for general audiences

Show changes

Cmloegcmluin: unhyphenate "comma basis"

2021-11-12T20:27:13Z

unhyphenate "comma basis"

Show changes

Cmloegcmluin: fix broken links

2021-11-11T19:27:55Z

fix broken links

Cmloegcmluin: fix section capitalization

2021-11-11T19:26:03Z

fix section capitalization

Show changes

Cmloegcmluin: simplify inline math

2021-11-11T19:06:02Z

simplify inline math

Cmloegcmluin: add links

2021-11-08T22:50:19Z

add links

← Older revision		Revision as of 22:50, 8 November 2021
Line 1:		Line 1:
	'''Defactoring''' is a operation on the mapping for a regular temperament which ensures it represents the same information but without any enfactoring, or in other words, redundancies due to a common factor found in its rows. It is also defined for comma-bases, the duals of mappings, where it instead checks its columns for enfactoring.		'''Defactoring''' is a operation on the [[mapping]] for a [[regular temperament]] which ensures it represents the same information but without any enfactoring, or in other words, redundancies due to a common factor found in its rows. It is also defined for [[comma-basis\|comma-bases]], the duals of mappings, where it instead checks its columns for enfactoring.

	Being enfactored is a bad thing. Enfactored matrices — those in the RTT domain, at least — are sick, in a way<ref>According to [[saturation]], "...if [an RTT matrix] isn't saturated the supposed temperament it defines may be regarded as pathological..." </ref>; it's no accident that "enfactored" sounds sort of like "infected". We'll discuss this pathology in detail in [[defactoring#the_pathology_of_enfactoredness\|a later section of this article]]. Fortunately, the remedy is simple: all one has to do is "defactor" it — identify and divide out the common factor — to produce a healthy mapping.		Being enfactored is a bad thing. Enfactored matrices — those in the RTT domain, at least — are sick, in a way<ref>According to [[saturation]], "...if [an RTT matrix] isn't saturated the supposed temperament it defines may be regarded as pathological..." </ref>; it's no accident that "enfactored" sounds sort of like "infected". We'll discuss this pathology in detail in [[defactoring#the_pathology_of_enfactoredness\|a later section of this article]]. Fortunately, the remedy is simple: all one has to do is "defactor" it — identify and divide out the common factor — to produce a healthy mapping.

Cmloegcmluin: /* enfactored, to replace contorted */ hyphenate and link comma-basis

2021-11-08T22:46:58Z

enfactored, to replace contorted: hyphenate and link comma-basis

← Older revision		Revision as of 22:46, 8 November 2021
Line 58:		Line 58:
	\right]		\right]
	</math><br><br>		</math><br><br>
	when it is used as a list of 5-limit commas defining a periodicity block versus when it is used as a comma basis for a temperament, namely, that in the first case the fact that the first column has a common factor of 2 and the second column has a common factor of 3 is meaningful, i.e. the 2-enfactorment will affect one dimension of the block and the 3-enfactorment will affect a different dimension of the block, or in other words, we can say that the commas here are individually enfactored rather than the entire list being enfactored, while in the second case there is no such meaning to the individual columns' factors of 2 and 3, respectively, because it would be equivalent of any form where the product of all the column factors was 6, or in other words, all that matters is that the comma-basis as a whole is 6-enfactored here. So perhaps it would be best if, for periodicity blocks, the term "enfactored" was avoided altogether, and instead commas were described as "2-torted".</ref><ref>The explanation for "why 'torsion' in the first place?" is interesting. It comes from group theory (see: https://en.wikipedia.org/wiki/Group_(mathematics)#Uniqueness_of_identity_element). In group theory, to have torsion, a group must have an element that comes back to zero after being chained 2 or more times. The number of times before coming back to zero is called the "order" of the element, sometimes also called the "period length" or "period". When the order is greater than 1 (and less than infinity), the element is said to have torsion, or to be a torsion element, and so the group it is an identity element of is said to have torsion. See also: https://en.wikipedia.org/wiki/Order_(group_theory). Clearly we can't use period (length) because period has another firmly established meaning in xenharmonics. But we could refer to torsion as "finite order greater than one", but that's quite the mouthful while still nearly as obscure.</ref>), they feel it would be better to banish the term "contorsion" from the RTT community altogether.		when it is used as a list of 5-limit commas defining a periodicity block versus when it is used as a [[comma-basis]] for a temperament, namely, that in the first case the fact that the first column has a common factor of 2 and the second column has a common factor of 3 is meaningful, i.e. the 2-enfactorment will affect one dimension of the block and the 3-enfactorment will affect a different dimension of the block, or in other words, we can say that the commas here are individually enfactored rather than the entire list being enfactored, while in the second case there is no such meaning to the individual columns' factors of 2 and 3, respectively, because it would be equivalent of any form where the product of all the column factors was 6, or in other words, all that matters is that the comma-basis as a whole is 6-enfactored here. So perhaps it would be best if, for periodicity blocks, the term "enfactored" was avoided altogether, and instead commas were described as "2-torted".</ref><ref>The explanation for "why 'torsion' in the first place?" is interesting. It comes from group theory (see: https://en.wikipedia.org/wiki/Group_(mathematics)#Uniqueness_of_identity_element). In group theory, to have torsion, a group must have an element that comes back to zero after being chained 2 or more times. The number of times before coming back to zero is called the "order" of the element, sometimes also called the "period length" or "period". When the order is greater than 1 (and less than infinity), the element is said to have torsion, or to be a torsion element, and so the group it is an identity element of is said to have torsion. See also: https://en.wikipedia.org/wiki/Order_(group_theory). Clearly we can't use period (length) because period has another firmly established meaning in xenharmonics. But we could refer to torsion as "finite order greater than one", but that's quite the mouthful while still nearly as obscure.</ref>), they feel it would be better to banish the term "contorsion" from the RTT community altogether.
	# A word with the same spelling was also coined with a different mathematical meaning outside of RTT, in the field of differential geometry: https://en.wikipedia.org/wiki/Contorsion_tensor<ref>In this field, it does definitely represent twisting, like in a Möbius strip. Also, DG contorsion is related to DG torsion by subtraction, not duality.</ref>		# A word with the same spelling was also coined with a different mathematical meaning outside of RTT, in the field of differential geometry: https://en.wikipedia.org/wiki/Contorsion_tensor<ref>In this field, it does definitely represent twisting, like in a Möbius strip. Also, DG contorsion is related to DG torsion by subtraction, not duality.</ref>
	# It is prone to spelling confusion. People commonly refer to temperaments with contorsion as "contorted". But contorted is the adjective form of a different word, contortion, with a t, not an s. The proper adjective form of contorsion would be contorsioned. Would you use "torted" instead of torsioned? Or would people prefer "torsional" and "contorsional", even though that suggests only of or pertaining to in general rather than having the effect applied.<ref>If it was meant to most strongly evoke duality with torsion, it should have been spelled "cotorsion". Naming it "contorsion" is an annoying step toward "contortion" but stopping halfway there. But this isn't a strong point, because duality with torsion was the false assumption mentioned above.</ref>		# It is prone to spelling confusion. People commonly refer to temperaments with contorsion as "contorted". But contorted is the adjective form of a different word, contortion, with a t, not an s. The proper adjective form of contorsion would be contorsioned. Would you use "torted" instead of torsioned? Or would people prefer "torsional" and "contorsional", even though that suggests only of or pertaining to in general rather than having the effect applied.<ref>If it was meant to most strongly evoke duality with torsion, it should have been spelled "cotorsion". Naming it "contorsion" is an annoying step toward "contortion" but stopping halfway there. But this isn't a strong point, because duality with torsion was the false assumption mentioned above.</ref>

Cmloegcmluin: /* motivation */ use defactored Hermite form

2021-11-02T01:16:36Z

motivation: use defactored Hermite form

← Older revision		Revision as of 01:16, 2 November 2021
Line 15:		Line 15:
	= motivation =		= motivation =

	A major use case for defactoring is to enable a [[canonical form]] for temperament mappings, or in other words, to achieve for the linear-algebra-only school of RTT practitioners a unique ID for temperaments. Previously this was only available by using lists of minor determinants AKA wedge products of mapping rows, which by virtue of reducing the information down to a single list of numbers, could be checked for enfactoring by simply checking the single row's GCD. For more information on this historical situation, see: [[Varianced Exterior Algebra#lack of importance to RTT]]		A major use case for defactoring is to enable a [[canonical form]] for temperament mappings, or in other words, to achieve for the linear-algebra-only school of RTT practitioners a unique ID for temperaments. Previously this was only available by using lists of minor determinants AKA wedge products of mapping rows, which by virtue of reducing the information down to a single list of numbers, could be checked for enfactoring by simply checking the single row's GCD. For more information on this historical situation, see: [[Varianced Exterior Algebra#lack of importance to RTT]], and for more information on the canonical form developed, see [[defactored Hermite form]].

	= terminology change proposal =		= terminology change proposal =

← Older revision		Revision as of 19:27, 11 November 2021
Line 1:		Line 1:
	'''Defactoring''' is a operation on the [[mapping]] for a [[regular temperament]] which ensures it represents the same information but without any enfactoring, or in other words, redundancies due to a common factor found in its rows. It is also defined for [[comma-basis\|comma-bases]], the duals of mappings, where it instead checks its columns for enfactoring.		'''Defactoring''' is a operation on the [[mapping]] for a [[regular temperament]] which ensures it represents the same information but without any enfactoring, or in other words, redundancies due to a common factor found in its rows. It is also defined for [[comma-basis\|comma-bases]], the duals of mappings, where it instead checks its columns for enfactoring.

	Being enfactored is a bad thing. Enfactored matrices — those in the RTT domain, at least — are sick, in a way<ref>According to [[saturation]], "...if [an RTT matrix] isn't saturated the supposed temperament it defines may be regarded as pathological..." </ref>; it's no accident that "enfactored" sounds sort of like "infected". We'll discuss this pathology in detail in [[defactoring#~~the_pathology_of_enfactoredness~~\|a later section of this article]]. Fortunately, the remedy is simple: all one has to do is "defactor" it — identify and divide out the common factor — to produce a healthy mapping.		Being enfactored is a bad thing. Enfactored matrices — those in the RTT domain, at least — are sick, in a way<ref>According to [[saturation]], "...if [an RTT matrix] isn't saturated the supposed temperament it defines may be regarded as pathological..." </ref>; it's no accident that "enfactored" sounds sort of like "infected". We'll discuss this pathology in detail in [[defactoring#The_pathology_of_enfactoredness\|a later section of this article]]. Fortunately, the remedy is simple: all one has to do is "defactor" it — identify and divide out the common factor — to produce a healthy mapping.

	Due to complications associated with enfactored matrices which we'll get into later in this article, we discourage treating them as representations of true temperaments.<ref>As Graham Breed writes [http://x31eq.com/temper/method.html here], "Whether temperaments with contorsion should even be thought of as temperaments is a matter of debate."</ref> Instead we recommend that they be considered to represent mere "temperoids": temperament-like structures.		Due to complications associated with enfactored matrices which we'll get into later in this article, we discourage treating them as representations of true temperaments.<ref>As Graham Breed writes [http://x31eq.com/temper/method.html here], "Whether temperaments with contorsion should even be thought of as temperaments is a matter of debate."</ref> Instead we recommend that they be considered to represent mere "temperoids": temperament-like structures.
Line 15:		Line 15:
	= Motivation =		= Motivation =

	A major use case for defactoring is to enable a [[canonical form]] for temperament mappings, or in other words, to achieve for the linear-algebra-only school of RTT practitioners a unique ID for temperaments. Previously this was only available by using lists of minor determinants AKA wedge products of mapping rows, which by virtue of reducing the information down to a single list of numbers, could be checked for enfactoring by simply checking the single row's GCD. For more information on this historical situation, see: [[Varianced Exterior Algebra#~~lack~~ of importance to RTT]], and for more information on the canonical form developed, see [[defactored Hermite form]].		A major use case for defactoring is to enable a [[canonical form]] for temperament mappings, or in other words, to achieve for the linear-algebra-only school of RTT practitioners a unique ID for temperaments. Previously this was only available by using lists of minor determinants AKA wedge products of mapping rows, which by virtue of reducing the information down to a single list of numbers, could be checked for enfactoring by simply checking the single row's GCD. For more information on this historical situation, see: [[Varianced Exterior Algebra#Lack of importance to RTT]], and for more information on the canonical form developed, see [[defactored Hermite form]].

	= Terminology change proposal =		= Terminology change proposal =
Line 319:		Line 319:
	After we know how to do these two things individually, we'll learn how to tweak them and assemble them together in order to perform a complete column Hermite defactoring.		After we know how to do these two things individually, we'll learn how to tweak them and assemble them together in order to perform a complete column Hermite defactoring.

	Fortunately, both of these two processes can be done using a technique you may already be familiar with if you've learned how to calculate the null-space of a mapping by hand (as demonstrated [[Douglas_Blumeyer%27s_RTT_How-To#~~null~~-space\|here]]):		Fortunately, both of these two processes can be done using a technique you may already be familiar with if you've learned how to calculate the null-space of a mapping by hand (as demonstrated [[Douglas_Blumeyer%27s_RTT_How-To#Null-space\|here]]):
	# augmenting your matrix with an identity matrix		# augmenting your matrix with an identity matrix
	# performing elementary row or column operations until a desired state is achieved<ref>For convenience, here is a summary of the three different techniques and their targets:<br>		# performing elementary row or column operations until a desired state is achieved<ref>For convenience, here is a summary of the three different techniques and their targets:<br>
Line 863:		Line 863:
	= Canonical comma-bases =		= Canonical comma-bases =

	Canonical form is not only for mappings; comma-bases may also be put into canonical form. The only difference is that they must be put in an "antitranspose sandwich", or in other words, antitransposed<ref>See a discussion of the antitranspose here: [[Douglas_Blumeyer%27s_RTT_How-To#~~null~~-space]]</ref>once at the beginning, and then antitransposed again at the end.		Canonical form is not only for mappings; comma-bases may also be put into canonical form. The only difference is that they must be put in an "antitranspose sandwich", or in other words, antitransposed<ref>See a discussion of the antitranspose here: [[Douglas_Blumeyer%27s_RTT_How-To#Null-space]]</ref>once at the beginning, and then antitransposed again at the end.

	For example, suppose we have the comma-basis for septimal meantone:		For example, suppose we have the comma-basis for septimal meantone:

← Older revision		Revision as of 19:06, 11 November 2021
Line 241:		Line 241:
	Dave and Douglas did much of their work in [https://www.wolfram.com/language/ Wolfram Language] (formerly Mathematica), a popular programming language used for math problems. In this section we'll give examples using it.		Dave and Douglas did much of their work in [https://www.wolfram.com/language/ Wolfram Language] (formerly Mathematica), a popular programming language used for math problems. In this section we'll give examples using it.

	An input mapping ~~<span>~~<math>m</math~~></span~~>, such as the example Gene gives [[saturation\|on the xen wiki page for Saturation]], {{ket\|{{map\|12 19 28 34}} {{map\|26 41 60 72}}}}, in Wolfram Language you would have to write as a list:		An input mapping <math>m</math>, such as the example Gene gives [[saturation\|on the xen wiki page for Saturation]], {{ket\|{{map\|12 19 28 34}} {{map\|26 41 60 72}}}}, in Wolfram Language you would have to write as a list:

	<nowiki>m = {{12,19,28,34},{26,41,60,72}};</nowiki>		<nowiki>m = {{12,19,28,34},{26,41,60,72}};</nowiki>
Line 250:		Line 250:
	smithDefactor[m_] := Take[Inverse[rightReducingMatrix[m]], MatrixRank[m]]</nowiki>		smithDefactor[m_] := Take[Inverse[rightReducingMatrix[m]], MatrixRank[m]]</nowiki>

	So the first thing that happens to ~~<span>~~<math>m</math~~></span~~> when you pass it in to <code>smithDefactor[]</code> is that it calls <code>rightReducingMatrix[]</code> on it. This will find the Smith decomposition (using a function built in to Wolfram Language), which gives you three outputs: the Smith normal form, flanked by its left and right reducing matrices. Gene asks only for the right reducing matrix, so we grab that with <code>Last[]</code>. So that's what the function on the first line, <code>rightReducingMatrix[]</code>, does.		So the first thing that happens to <math>m</math> when you pass it in to <code>smithDefactor[]</code> is that it calls <code>rightReducingMatrix[]</code> on it. This will find the Smith decomposition (using a function built in to Wolfram Language), which gives you three outputs: the Smith normal form, flanked by its left and right reducing matrices. Gene asks only for the right reducing matrix, so we grab that with <code>Last[]</code>. So that's what the function on the first line, <code>rightReducingMatrix[]</code>, does.

	Then Gene asks us to invert this result and take its first ~~<span>~~<math>r</math~~></span~~> rows, where ~~<span>~~<math>r</math~~></span~~> is the rank of the temperament. <code>Invert[]</code> takes care of the inversion, of course. <code>MatrixRank[m]</code> gives the count of linearly independent rows to the mapping, AKA the rank, or count of generators in this temperament. In this case that's 2. And so <code>Take[list, 2]</code> simply returns the first 2 entries of the list.		Then Gene asks us to invert this result and take its first <math>r</math> rows, where <math>r</math> is the rank of the temperament. <code>Invert[]</code> takes care of the inversion, of course. <code>MatrixRank[m]</code> gives the count of linearly independent rows to the mapping, AKA the rank, or count of generators in this temperament. In this case that's 2. And so <code>Take[list, 2]</code> simply returns the first 2 entries of the list.

	Almost done! Except Gene not only defactors, he also calls for HNF, as we would, to achieve canonical (unique ID) form.		Almost done! Except Gene not only defactors, he also calls for HNF, as we would, to achieve canonical (unique ID) form.
Line 283:		Line 283:
	The next step is to invert that matrix, which is doable because it is unimodular; a key property of unimodular matrices is that they are always invertible, and because their determinant is ±1, if they contain all integer entries, their inverse will also contain all integer entries (which it does, and we need it to)<ref>Interesting tidbit regarding full-rank matrices and unimodular matrices: for square matrices, full-rank implies unimodularity, and vice-versa.</ref>.		The next step is to invert that matrix, which is doable because it is unimodular; a key property of unimodular matrices is that they are always invertible, and because their determinant is ±1, if they contain all integer entries, their inverse will also contain all integer entries (which it does, and we need it to)<ref>Interesting tidbit regarding full-rank matrices and unimodular matrices: for square matrices, full-rank implies unimodularity, and vice-versa.</ref>.

	Finally we take only the top ~~<span>~~<math>r</math~~></span~~> rows of this, where ~~<span>~~<math>r</math~~></span~~> is the rank of the original matrix. That's found with <code>MatrixRank[m]</code>.		Finally we take only the top <math>r</math> rows of this, where <math>r</math> is the rank of the original matrix. That's found with <code>MatrixRank[m]</code>.

	=== how/why it works ===		=== how/why it works ===
Line 291:		Line 291:
	So inverting is one of those "undo" type operations. To understand why, we have to understand the nature of this decomposition. What the Hermite decomposition does is return a unimodular matrix U and a Hermite normal form matrix H such that if you left-multiply your original matrix A by the unimodular matrix U you get the normal form matrix H, or in other words, UA = H. So, think of it this way. If A is what we input, and we want something sort of like A, but U is what we've taken, and U is multiplied with A in this equality to get H, where H is also kind of like A, then probably what we really want is something like U, but inverted.		So inverting is one of those "undo" type operations. To understand why, we have to understand the nature of this decomposition. What the Hermite decomposition does is return a unimodular matrix U and a Hermite normal form matrix H such that if you left-multiply your original matrix A by the unimodular matrix U you get the normal form matrix H, or in other words, UA = H. So, think of it this way. If A is what we input, and we want something sort of like A, but U is what we've taken, and U is multiplied with A in this equality to get H, where H is also kind of like A, then probably what we really want is something like U, but inverted.

	Finally, we take only the top ~~<span>~~<math>r</math~~></span~~> rows, which again is an "undo" type operation. Here what we're undoing is that we had to graduate from a rectangle to a square temporarily, storing our important information in the form of this invertible square unimodular matrix temporarily, so we could invert it while keeping it integer, but now we need to get it back into the same type of rectangular shape as we put in. So that's what this part is for.<ref>There is probably some special meaning or information in the rows you throw away here, but we're not sure what it might be.</ref>		Finally, we take only the top <math>r</math> rows, which again is an "undo" type operation. Here what we're undoing is that we had to graduate from a rectangle to a square temporarily, storing our important information in the form of this invertible square unimodular matrix temporarily, so we could invert it while keeping it integer, but now we need to get it back into the same type of rectangular shape as we put in. So that's what this part is for.<ref>There is probably some special meaning or information in the rows you throw away here, but we're not sure what it might be.</ref>

	=== various additional ways of thinking about how/why it works ===		=== various additional ways of thinking about how/why it works ===
Line 307:		Line 307:
	==== unimodular matrix size ====		==== unimodular matrix size ====

	One reason for doing a column Hermite decomposition on a mapping can be understood by comparing the sizes of the unimodular matrices. Matrices are often described as ~~<span>~~<math>m×n</math~~></span~~>, where ~~<span>~~<math>m</math~~></span~~> is the row count and ~~<span>~~<math>n</math~~></span~~> is the column count. In the case of mappings it may be superior to use variable names corresponding to the domain concepts of rank ~~<span>~~<math>r</math~~></span~~>, and dimension ~~<span>~~<math>d</math~~></span~~>, i.e. to speak of ~~<span>~~<math>r×d</math~~></span~~> mappings. The key bit of info here is that — for non-trivial mappings, anyway — ~~<span>~~<math>d</math~~></span~~> is always greater than ~~<span>~~<math>r</math~~></span~~>. So a standard row-based Hermite decomposition, i.e. to the right, is going to produce an ~~<span>~~<math>r×r</math~~></span~~> unimodular matrix, while a column-based Hermite decomposition, i.e. to the bottom, is going to produce a ~~<span>~~<math>d×d</math~~></span~~> unimodular matrix. For example, 5-limit meantone has ~~<span>~~<math>r=2</math~~></span~~> and ~~<span>~~<math>d=3</math~~></span~~>, so a standard row-based Hermite decomposition is going to produce a unimodular matrix that is only 2×2, while the column-based Hermite decomposition will produce one that is 3×3. With ~~<span>~~<math>d>r</math~~></span~~>, it's clear that the column-based decomposition in general will always produced the larger unimodular matrix. In fact, the row-based decomposition is too small to be capable of enclosing an amount of entries equal to the count of entries in the original mapping, and therefore it could never support preserving the entirety of the important information from the input (in terms of our example, a 3×3 matrix can hold a 2×3 matrix, but a 2×2 matrix cannot).		One reason for doing a column Hermite decomposition on a mapping can be understood by comparing the sizes of the unimodular matrices. Matrices are often described as <math>m×n</math>, where <math>m</math> is the row count and <math>n</math> is the column count. In the case of mappings it may be superior to use variable names corresponding to the domain concepts of rank <math>r</math>, and dimension <math>d</math>, i.e. to speak of <math>r×d</math> mappings. The key bit of info here is that — for non-trivial mappings, anyway — <math>d</math> is always greater than <math>r</math>. So a standard row-based Hermite decomposition, i.e. to the right, is going to produce an <math>r×r</math> unimodular matrix, while a column-based Hermite decomposition, i.e. to the bottom, is going to produce a <math>d×d</math> unimodular matrix. For example, 5-limit meantone has <math>r=2</math> and <math>d=3</math>, so a standard row-based Hermite decomposition is going to produce a unimodular matrix that is only 2×2, while the column-based Hermite decomposition will produce one that is 3×3. With <math>d>r</math>, it's clear that the column-based decomposition in general will always produced the larger unimodular matrix. In fact, the row-based decomposition is too small to be capable of enclosing an amount of entries equal to the count of entries in the original mapping, and therefore it could never support preserving the entirety of the important information from the input (in terms of our example, a 3×3 matrix can hold a 2×3 matrix, but a 2×2 matrix cannot).

	=== by hand ===		=== by hand ===
Line 832:		Line 832:
	\end{array} \right]</math>		\end{array} \right]</math>

	And we take from this thing the top ~~<span>~~<math>r</math~~></span~~> rows, where ~~<span>~~<math>r</math~~></span~~> is the rank of the input matrix, which in this case is 2:		And we take from this thing the top <math>r</math> rows, where <math>r</math> is the rank of the input matrix, which in this case is 2:

	<math>\left[ \begin{array} {rrr}		<math>\left[ \begin{array} {rrr}