Documentation

Signals.Geometry

Finite geometric representatives #

Ordered minors, orientation laws and finite two-step products are checked algebra. Positive conditions require their stated input hypotheses; full-rank promotion requires an available nonzero minor. No quotient, planar embedding or optical interpretation is constructed here.

A two-component complex Weyl spinor as algebraic data.

  • first : ℂ
  • second : ℂ
Instances For

    The antisymmetric spinor contraction.

    Instances For
      theorem Signals.Geometry.angleBracket_swap (left right : WeylSpinor) :
      angleBracket left right = -angleBracket right left

      Swapping the spinors reverses the angle bracket.

      theorem Signals.Geometry.angleBracket_self (spinor : WeylSpinor) :
      angleBracket spinor spinor = 0

      A spinor has zero angle bracket with itself.

      Twistor data represented by a pair of Weyl spinors.

      Instances For

        Finite Grassmannian coordinates #

        The unrestricted matrix record deliberately permits negative Pluecker coordinates. Positivity is an additional chart condition, not part of the underlying linear-algebra data.

        structure Signals.Geometry.OrderedColumns (k n : ℕ) :

        A strictly ordered selection of k columns from n columns.

        • index : Fin k → Fin n
        • strictlyIncreasing : StrictMono self.index
        Instances For
          def Signals.Geometry.OrderedColumns.single {n : ℕ} (column : Fin n) :

          A single column is an ordered selection without a vacuous rank assertion.

          Instances For
            def Signals.Geometry.OrderedColumns.pair {n : ℕ} (first second : Fin n) (ordered : first < second) :

            Select two distinct columns in the supplied increasing order.

            Instances For
              def Signals.Geometry.OrderedColumns.triple {n : ℕ} (first second third : Fin n) (ordered01 : first < second) (ordered12 : second < third) :

              Select three distinct columns in the supplied strictly increasing order.

              Instances For

                A finite matrix representing a point before any positivity restriction.

                • mat : Matrix (Fin k) (Fin n) ℝ
                Instances For
                  def Signals.Geometry.selectedMinor {k n : ℕ} (matrix : Matrix (Fin k) (Fin n) ℝ) (columns : OrderedColumns k n) :
                  ℝ

                  The maximal minor selected by an ordered list of columns.

                  Instances For
                    def Signals.Geometry.GrassmannianMatrix.pluckerCoordinate {k n : ℕ} (grassmannian : GrassmannianMatrix k n) (columns : OrderedColumns k n) :
                    ℝ

                    The Pluecker coordinate of an ordered column selection.

                    Instances For
                      theorem Signals.Geometry.selectedMinor_basisChange {k n : ℕ} (basis : Matrix (Fin k) (Fin k) ℝ) (matrix : Matrix (Fin k) (Fin n) ℝ) (columns : OrderedColumns k n) :
                      selectedMinor (basis * matrix) columns = basis.det * selectedMinor matrix columns

                      Left multiplication by a row basis matrix scales every maximal minor by its determinant.

                      def Signals.Geometry.GrassmannianMatrix.changeBasis {k n : ℕ} (grassmannian : GrassmannianMatrix k n) (basis : Matrix (Fin k) (Fin k) ℝ) :

                      Change the row representative without quotienting by the basis action.

                      Instances For
                        theorem Signals.Geometry.GrassmannianMatrix.pluckerCoordinate_basisChange {k n : ℕ} (grassmannian : GrassmannianMatrix k n) (basis : Matrix (Fin k) (Fin k) ℝ) (columns : OrderedColumns k n) :
                        (grassmannian.changeBasis basis).pluckerCoordinate columns = basis.det * grassmannian.pluckerCoordinate columns

                        Every Pluecker coordinate transforms by the same determinant factor.

                        theorem Signals.Geometry.GrassmannianMatrix.pluckerRatio_basisChange {k n : ℕ} (grassmannian : GrassmannianMatrix k n) (basis : Matrix (Fin k) (Fin k) ℝ) (nonsingular : basis.det ≠ 0) (first second : OrderedColumns k n) :
                        (grassmannian.changeBasis basis).pluckerCoordinate first / (grassmannian.changeBasis basis).pluckerCoordinate second = grassmannian.pluckerCoordinate first / grassmannian.pluckerCoordinate second

                        Pluecker ratios are invariant under any nonsingular row basis change, including orientation reversal.

                        Every ordered maximal minor is strictly positive.

                        Instances For

                          The positive Grassmannian condition, isolated from unrestricted matrices.

                          Instances For
                            theorem Signals.Geometry.PositiveGrassmannian.pluckerCoordinate_pos {k n : ℕ} (grassmannian : PositiveGrassmannian k n) (columns : OrderedColumns k n) :
                            0 < grassmannian.pluckerCoordinate columns

                            The positive-condition record supplies positivity of each available ordered maximal minor.

                            def Signals.Geometry.OrderedColumns.projection {k n : ℕ} (columns : OrderedColumns k n) :
                            (Fin n → ℝ) →ₗ[ℝ] Fin k → ℝ

                            The linear projection selecting the ordered columns of a row vector.

                            Instances For
                              def Signals.Geometry.pluckerAlternating {k n : ℕ} (columns : OrderedColumns k n) :
                              (Fin n → ℝ) [⋀^Fin k]→ₗ[ℝ] ℝ

                              The selected determinant as an alternating map on the matrix rows.

                              Instances For
                                theorem Signals.Geometry.pluckerAlternating_eq_selectedMinor {k n : ℕ} (columns : OrderedColumns k n) (matrix : Matrix (Fin k) (Fin n) ℝ) :
                                (pluckerAlternating columns) matrix = selectedMinor matrix columns

                                The alternating-map construction agrees with the existing maximal minor.

                                theorem Signals.Geometry.selectedMinor_swap_rows {k n : ℕ} (matrix : Matrix (Fin k) (Fin n) ℝ) (columns : OrderedColumns k n) {left right : Fin k} (distinct : left ≠ right) :
                                selectedMinor (matrix ∘ ⇑(Equiv.swap left right)) columns = -selectedMinor matrix columns

                                Exchanging distinct rows negates the selected Pluecker coordinate.

                                theorem Signals.Geometry.selectedMinor_eq_zero_of_rows_eq {k n : ℕ} (matrix : Matrix (Fin k) (Fin n) ℝ) (columns : OrderedColumns k n) {left right : Fin k} (equal : matrix left = matrix right) (distinct : left ≠ right) :
                                selectedMinor matrix columns = 0

                                Equal distinct rows force every maximal minor to vanish.

                                All ordered maximal minors are nonnegative, including boundary zeros.

                                Instances For

                                  A full-rank nonnegative representative, not a quotient by change of basis.

                                  Instances For
                                    theorem Signals.Geometry.NonnegativeGrassmannian.pluckerCoordinate_nonnegative {k n : ℕ} (grassmannian : NonnegativeGrassmannian k n) (columns : OrderedColumns k n) :
                                    0 ≤ grassmannian.pluckerCoordinate columns

                                    Nonnegative representatives allow a minor to vanish on a boundary.

                                    An available ordered minor makes a positive representative nonnegative and full-rank.

                                    Instances For
                                      def Signals.Geometry.PositiveGrassmannian.changeBasis {k n : ℕ} (grassmannian : PositiveGrassmannian k n) (basis : Matrix (Fin k) (Fin k) ℝ) (orientation : 0 < basis.det) :

                                      Orientation-preserving basis changes preserve positive representatives.

                                      Instances For
                                        def Signals.Geometry.NonnegativeGrassmannian.changeBasis {k n : ℕ} (grassmannian : NonnegativeGrassmannian k n) (basis : Matrix (Fin k) (Fin k) ℝ) (orientation : 0 < basis.det) :

                                        Orientation-preserving changes also preserve boundary zeros and a full-rank witness.

                                        Instances For
                                          theorem Signals.Geometry.PositiveGrassmannian.not_positive_of_det_neg {k n : ℕ} (grassmannian : PositiveGrassmannian k n) (basis : Matrix (Fin k) (Fin k) ℝ) (orientation : basis.det < 0) (columns : OrderedColumns k n) :
                                          ¬(grassmannian.changeBasis basis).hasPositiveOrderedMinors

                                          A negative determinant reverses every positive minor, so positivity is not invariant under GL(k).

                                          def Signals.Geometry.PositiveGrassmannian.intervalCell (coordinate : ℝ) (lower : 0 < coordinate) (upper : coordinate < 1) :

                                          A normalized one-dimensional positive cell with representative [t, 1-t].

                                          Instances For
                                            noncomputable def Signals.Geometry.forkRepresentative (firstWeight secondWeight : NNReal) :

                                            The actual fork boundary row, converted from nonnegative weights to a real representative.

                                            Instances For
                                              theorem Signals.Geometry.forkRepresentative_mat (firstWeight secondWeight : NNReal) :
                                              (forkRepresentative firstWeight secondWeight).mat = !![↑firstWeight, ↑secondWeight]

                                              Both fork columns are derived from finite boundary measurements rather than supplied minors.

                                              noncomputable def Signals.Geometry.forkPositive (firstWeight secondWeight : NNReal) (firstPositive : 0 < firstWeight) (secondPositive : 0 < secondWeight) :

                                              Two positive fork weights yield a positive one-row representative.

                                              Instances For
                                                noncomputable def Signals.Geometry.forkNonnegative (firstWeight secondWeight : NNReal) (active : firstWeight ≠ 0 ∨ secondWeight ≠ 0) :

                                                A nonzero branch supplies the nonzero-minor witness for a nonnegative fork representative.

                                                Instances For
                                                  noncomputable def Signals.Geometry.twoChannelRepresentative (firstFirst firstSecond secondFirst secondSecond : NNReal) :

                                                  The actual two-channel boundary matrix with nonnegative entries converted to real scalars.

                                                  Instances For
                                                    theorem Signals.Geometry.twoChannelRepresentative_mat (firstFirst firstSecond secondFirst secondSecond : NNReal) :
                                                    (twoChannelRepresentative firstFirst firstSecond secondFirst secondSecond).mat = !![↑firstFirst, ↑firstSecond; ↑secondFirst, ↑secondSecond]

                                                    The real representative retains all four entries of the measured two-channel boundary matrix.

                                                    theorem Signals.Geometry.twoChannelRepresentative_det (firstFirst firstSecond secondFirst secondSecond : NNReal) :
                                                    (twoChannelRepresentative firstFirst firstSecond secondFirst secondSecond).mat.det = ↑firstFirst * ↑secondSecond - ↑firstSecond * ↑secondFirst

                                                    The two-channel determinant is the signed difference of the two source/sink pair products.

                                                    theorem Signals.Geometry.twoChannelRepresentative_det_pos_iff (firstFirst firstSecond secondFirst secondSecond : NNReal) :
                                                    0 < (twoChannelRepresentative firstFirst firstSecond secondFirst secondSecond).mat.det ↔ ↑firstSecond * ↑secondFirst < ↑firstFirst * ↑secondSecond

                                                    Positive measured determinant requires ordered-product dominance, not just positive entries.

                                                    noncomputable def Signals.Geometry.singleHubRepresentative (firstIn secondIn firstOut secondOut : NNReal) :

                                                    The actual shared-hub boundary matrix converted from nonnegative weights to real entries.

                                                    Instances For
                                                      theorem Signals.Geometry.singleHubRepresentative_mat (firstIn secondIn firstOut secondOut : NNReal) :
                                                      (singleHubRepresentative firstIn secondIn firstOut secondOut).mat = !![↑firstIn * ↑firstOut, ↑firstIn * ↑secondOut; ↑secondIn * ↑firstOut, ↑secondIn * ↑secondOut]

                                                      The shared hub produces an incoming/outgoing product matrix from its finite path sums.

                                                      theorem Signals.Geometry.singleHubRepresentative_det (firstIn secondIn firstOut secondOut : NNReal) :
                                                      (singleHubRepresentative firstIn secondIn firstOut secondOut).mat.det = 0

                                                      The two signed path-pair products through the shared hub cancel for every choice of edge weights.

                                                      theorem Signals.Geometry.twoStep_det_pathPairs {middleCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin 2) ℝ) :
                                                      (incoming * outgoing).det = ∑ first : Fin middleCount, ∑ second : Fin middleCount, incoming 0 first * incoming 1 second * (outgoing first 0 * outgoing second 1 - outgoing first 1 * outgoing second 0)

                                                      A two-step two-channel determinant expands as signed pairs of intermediate-vertex terms.

                                                      theorem Signals.Geometry.twoStep_sameMiddle_term {middleCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin 2) ℝ) (middle : Fin middleCount) :
                                                      incoming 0 middle * incoming 1 middle * (outgoing middle 0 * outgoing middle 1 - outgoing middle 1 * outgoing middle 0) = 0

                                                      A repeated intermediate vertex contributes zero to the signed path-pair expansion.

                                                      def Signals.Geometry.twoStepMinorPair {middleCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin 2) ℝ) (first second : Fin middleCount) :
                                                      ℝ

                                                      The signed product of incoming and outgoing two-by-two minors for one intermediate pair.

                                                      Instances For
                                                        theorem Signals.Geometry.twoStep_minorPairs_sum {middleCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin 2) ℝ) :
                                                        ∑ first : Fin middleCount, ∑ second : Fin middleCount, twoStepMinorPair incoming outgoing first second = 2 * (incoming * outgoing).det

                                                        Pairing both intermediate orders gives products of two-by-two minors, counted twice.

                                                        theorem Signals.Geometry.twoStep_det_nonnegative {middleCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin 2) ℝ) (compatible : ∀ (first second : Fin middleCount), 0 ≤ twoStepMinorPair incoming outgoing first second) :
                                                        0 ≤ (incoming * outgoing).det

                                                        Compatible nonnegative minor-pair contributions derive a nonnegative two-step determinant.

                                                        theorem Signals.Geometry.twoStep_det_positive {middleCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin 2) ℝ) (compatible : ∀ (first second : Fin middleCount), 0 ≤ twoStepMinorPair incoming outgoing first second) (first second : Fin middleCount) (active : 0 < twoStepMinorPair incoming outgoing first second) :
                                                        0 < (incoming * outgoing).det

                                                        One positive minor-pair witness among compatible contributions derives strict determinant positivity.

                                                        theorem Signals.Geometry.twoStep_selectedMinor {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) (columns : OrderedColumns 2 sinkCount) :
                                                        selectedMinor (incoming * outgoing) columns = (incoming * outgoing.submatrix id columns.index).det

                                                        Selecting output columns commutes with finite two-step matrix multiplication.

                                                        theorem Signals.Geometry.twoStep_selectedMinor_pairs {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) (columns : OrderedColumns 2 sinkCount) :
                                                        ∑ first : Fin middleCount, ∑ second : Fin middleCount, twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second = 2 * selectedMinor (incoming * outgoing) columns

                                                        Every ordered output maximal minor has the derived finite input minor-pair expansion.

                                                        def Signals.Geometry.twoStepRepresentative {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) :
                                                        GrassmannianMatrix 2 sinkCount

                                                        The unrestricted two-row representative computed by the finite two-step product.

                                                        Instances For
                                                          theorem Signals.Geometry.twoStep_selectedMinor_nonnegative {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) (columns : OrderedColumns 2 sinkCount) (compatible : ∀ (first second : Fin middleCount), 0 ≤ twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) :
                                                          0 ≤ selectedMinor (incoming * outgoing) columns

                                                          Compatible selected input minor pairs derive nonnegativity of one ordered output minor.

                                                          theorem Signals.Geometry.twoStep_selectedMinor_positive {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) (columns : OrderedColumns 2 sinkCount) (compatible : ∀ (first second : Fin middleCount), 0 ≤ twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) (first second : Fin middleCount) (active : 0 < twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) :
                                                          0 < selectedMinor (incoming * outgoing) columns

                                                          A positive selected input pair among compatible pairs derives positivity of one output minor.

                                                          def Signals.Geometry.twoStepPositive {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) (compatible : ∀ (columns : OrderedColumns 2 sinkCount) (first second : Fin middleCount), 0 ≤ twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) (active : ∀ (columns : OrderedColumns 2 sinkCount), ∃ (first : Fin middleCount) (second : Fin middleCount), 0 < twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) :

                                                          Compatible input pairs and a positive witness for each ordered selection derive the positive condition.

                                                          Instances For
                                                            def Signals.Geometry.twoStepNonnegative {middleCount sinkCount : ℕ} (incoming : Matrix (Fin 2) (Fin middleCount) ℝ) (outgoing : Matrix (Fin middleCount) (Fin sinkCount) ℝ) (compatible : ∀ (columns : OrderedColumns 2 sinkCount) (first second : Fin middleCount), 0 ≤ twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) (active : ∃ (columns : OrderedColumns 2 sinkCount) (first : Fin middleCount) (second : Fin middleCount), 0 < twoStepMinorPair incoming (outgoing.submatrix id columns.index) first second) :

                                                            One active selected input pair supplies a nonzero output minor for a nonnegative full-rank record.

                                                            Instances For

                                                              Massive spinor-helicity bookkeeping #

                                                              The records below expose the massive replacement for the massless factorization used in the source chat. They state on-shell and factorization conditions as supplied data; they do not assert that an experimental field is described by this representation.

                                                              A real four-momentum in the mostly-minus metric convention.

                                                              • energy : ℝ
                                                              • px : ℝ
                                                              • py : ℝ
                                                              • pz : ℝ
                                                              • mass : ℝ
                                                              • mass_nonnegative : 0 ≤ self.mass
                                                              • mass_shell : self.energy ^ 2 - self.px ^ 2 - self.py ^ 2 - self.pz ^ 2 = self.mass ^ 2
                                                              Instances For
                                                                def Signals.Geometry.FourMomentum.bispinor (momentum : FourMomentum) :
                                                                Matrix (Fin 2) (Fin 2) ℂ

                                                                The momentum bispinor in a fixed Pauli-matrix convention.

                                                                Instances For
                                                                  def Signals.Geometry.WeylSpinor.component (spinor : WeylSpinor) (index : Fin 2) :
                                                                  ℂ

                                                                  The two-component coordinate function used in a spinor outer product.

                                                                  Instances For
                                                                    def Signals.Geometry.WeylSpinor.ofComponents (components : Fin 2 → ℂ) :

                                                                    Construct a Weyl spinor from its two complex components.

                                                                    Instances For
                                                                      theorem Signals.Geometry.WeylSpinor.component_ofComponents (components : Fin 2 → ℂ) :
                                                                      (ofComponents components).component = components

                                                                      Converting components to a spinor and back preserves the vector.

                                                                      Equality of the two components determines a spinor.

                                                                      theorem Signals.Geometry.Twistor.ext_components {left right : Twistor} (lambda_equal : left.lambda = right.lambda) (mu_equal : left.mu.component = right.mu.component) :
                                                                      left = right

                                                                      Equality of lambda and of the mu components determines a twistor.

                                                                      @[reducible, inline]

                                                                      A complex coordinate matrix; no Hermiticity or spacetime metric is assumed.

                                                                      Instances For

                                                                        Incidence in the convention mu = -i x lambda.

                                                                        Instances For

                                                                          The algebraic shear induced by translating the coordinate matrix.

                                                                          Instances For
                                                                            theorem Signals.Geometry.Twistor.translate_lambda (twistor : Twistor) (offset : SpacetimeMatrix) :
                                                                            (twistor.translate offset).lambda = twistor.lambda

                                                                            Translation leaves the first spinor unchanged.

                                                                            theorem Signals.Geometry.Twistor.translate_mu (twistor : Twistor) (offset : SpacetimeMatrix) :
                                                                            (twistor.translate offset).mu.component = twistor.mu.component - Complex.I • Matrix.mulVec offset twistor.lambda.component

                                                                            The second spinor changes by the prescribed matrix shear.

                                                                            theorem Signals.Geometry.Twistor.translate_incident (twistor : Twistor) (position offset : SpacetimeMatrix) (incidence : twistor.incident position) :
                                                                            (twistor.translate offset).incident (position + offset)

                                                                            The shear preserves incidence at the translated coordinate matrix.

                                                                            theorem Signals.Geometry.Twistor.translate_zero (twistor : Twistor) :
                                                                            twistor.translate 0 = twistor

                                                                            A zero coordinate translation is the identity shear.

                                                                            theorem Signals.Geometry.Twistor.translate_add (twistor : Twistor) (first second : SpacetimeMatrix) :
                                                                            (twistor.translate first).translate second = twistor.translate (first + second)

                                                                            Successive coordinate translations add their offsets.

                                                                            theorem Signals.Geometry.Twistor.translate_neg (twistor : Twistor) (offset : SpacetimeMatrix) :
                                                                            (twistor.translate offset).translate (-offset) = twistor

                                                                            The negative offset undoes a translation.

                                                                            theorem Signals.Geometry.Twistor.translate_incident_iff (twistor : Twistor) (position offset : SpacetimeMatrix) :
                                                                            (twistor.translate offset).incident (position + offset) ↔ twistor.incident position

                                                                            Incidence is equivalent before and after applying the same coordinate translation.

                                                                            def Signals.Geometry.massiveSpinorProduct (left right : Fin 2 → WeylSpinor) :
                                                                            Matrix (Fin 2) (Fin 2) ℂ

                                                                            A finite sum of two rank-one spinor products.

                                                                            Instances For

                                                                              A massive momentum together with its supplied spinor-helicity factorization.

                                                                              Instances For
                                                                                theorem Signals.Geometry.FourMomentum.mass_shell_holds (momentum : FourMomentum) :
                                                                                momentum.energy ^ 2 - momentum.px ^ 2 - momentum.py ^ 2 - momentum.pz ^ 2 = momentum.mass ^ 2

                                                                                Expose the supplied mostly-minus mass-shell equation; this does not derive its physical premise.

                                                                                @[reducible, inline]

                                                                                Real matrices with two rows and four columns.

                                                                                Instances For
                                                                                  def Signals.Geometry.minor (matrix : Matrix2x4) (left right : Fin 4) :
                                                                                  ℝ

                                                                                  The determinant of the two columns selected by left and right.

                                                                                  Instances For
                                                                                    theorem Signals.Geometry.minor_swap (matrix : Matrix2x4) (left right : Fin 4) :
                                                                                    minor matrix left right = -minor matrix right left

                                                                                    Swapping columns negates a two-column minor.

                                                                                    theorem Signals.Geometry.minor_self (matrix : Matrix2x4) (column : Fin 4) :
                                                                                    minor matrix column column = 0

                                                                                    Repeating a column gives a zero two-column minor.

                                                                                    theorem Signals.Geometry.pluecker_relation (matrix : Matrix2x4) :
                                                                                    minor matrix 0 1 * minor matrix 2 3 - minor matrix 0 2 * minor matrix 1 3 + minor matrix 0 3 * minor matrix 1 2 = 0

                                                                                    The quadratic Pluecker relation for every two-row, four-column matrix.

                                                                                    This is a finite determinant identity; it does not assert an Amplituhedron volume or any physical interpretation of the matrix.

                                                                                    def Signals.Geometry.twoRowMinor {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (left right : Fin columnCount) :
                                                                                    ℝ

                                                                                    The two-column determinant of a 2 × n matrix for arbitrary column indices.

                                                                                    Instances For
                                                                                      theorem Signals.Geometry.twoRowMinor_swap {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (left right : Fin columnCount) :
                                                                                      twoRowMinor matrix left right = -twoRowMinor matrix right left

                                                                                      Swapping the two column indices negates twoRowMinor.

                                                                                      theorem Signals.Geometry.twoRowMinor_self {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (column : Fin columnCount) :
                                                                                      twoRowMinor matrix column column = 0

                                                                                      Repeating a column index gives a zero twoRowMinor.

                                                                                      theorem Signals.Geometry.twoRowMinor_eq_selectedMinor {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (left right : Fin columnCount) (ordered : left < right) :
                                                                                      twoRowMinor matrix left right = selectedMinor matrix (OrderedColumns.pair left right ordered)

                                                                                      For strictly ordered column indices, twoRowMinor agrees with selectedMinor.

                                                                                      theorem Signals.Geometry.twoRowMinor_pluecker {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (first second third fourth : Fin columnCount) :
                                                                                      twoRowMinor matrix first second * twoRowMinor matrix third fourth - twoRowMinor matrix first third * twoRowMinor matrix second fourth + twoRowMinor matrix first fourth * twoRowMinor matrix second third = 0

                                                                                      The three-term quadratic Pluecker relation holds for any four column indices of any 2 × n matrix.

                                                                                      theorem Signals.Geometry.selectedMinor_pluecker_four {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (columns : OrderedColumns 4 columnCount) :
                                                                                      selectedMinor matrix (OrderedColumns.pair (columns.index 0) (columns.index 1) ⋯) * selectedMinor matrix (OrderedColumns.pair (columns.index 2) (columns.index 3) ⋯) - selectedMinor matrix (OrderedColumns.pair (columns.index 0) (columns.index 2) ⋯) * selectedMinor matrix (OrderedColumns.pair (columns.index 1) (columns.index 3) ⋯) + selectedMinor matrix (OrderedColumns.pair (columns.index 0) (columns.index 3) ⋯) * selectedMinor matrix (OrderedColumns.pair (columns.index 1) (columns.index 2) ⋯) = 0

                                                                                      For any ordered four-column selection in Fin n, the six induced ordered-pair selectedMinor coordinates satisfy the quadratic Pluecker relation.

                                                                                      theorem Signals.Geometry.selectedMinor_crossing_product_eq_sum {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (columns : OrderedColumns 4 columnCount) :
                                                                                      selectedMinor matrix (OrderedColumns.pair (columns.index 0) (columns.index 2) ⋯) * selectedMinor matrix (OrderedColumns.pair (columns.index 1) (columns.index 3) ⋯) = selectedMinor matrix (OrderedColumns.pair (columns.index 0) (columns.index 1) ⋯) * selectedMinor matrix (OrderedColumns.pair (columns.index 2) (columns.index 3) ⋯) + selectedMinor matrix (OrderedColumns.pair (columns.index 0) (columns.index 3) ⋯) * selectedMinor matrix (OrderedColumns.pair (columns.index 1) (columns.index 2) ⋯)

                                                                                      The product of the two crossing minors equals the sum of the two uncrossed boundary minor products.

                                                                                      noncomputable def Signals.Geometry.gr24BarycentricShift (matrix : Matrix (Fin 2) (Fin 4) ℝ) :
                                                                                      ℝ

                                                                                      Barycentric Pluecker channel-imbalance offset $d_{\mathrm{bary}}(M) = \frac{\Delta_{01}(M)\Delta_{23}(M) - \Delta_{03}(M)\Delta_{12}(M)}{2}$ between the two uncrossed double-slit channels of a $2 \times 4$ matrix $M$.

                                                                                      Instances For
                                                                                        theorem Signals.Geometry.gr24_plucker_pythagorean_identity (matrix : Matrix (Fin 2) (Fin 4) ℝ) :
                                                                                        gr24BarycentricShift matrix ^ 2 + twoRowMinor matrix 0 1 * twoRowMinor matrix 2 3 * (twoRowMinor matrix 0 3 * twoRowMinor matrix 1 2) = (twoRowMinor matrix 0 2 * twoRowMinor matrix 1 3 / 2) ^ 2

                                                                                        Pythagorean Pluecker--Steiner Identity on $Gr(2, 4)$: For every real $2 \times 4$ matrix $M$, the squared Pluecker barycentric shift $d_{\mathrm{bary}}(M)^2$ plus the product of the two uncrossed channel weights $(\Delta_{01}\Delta_{23})(\Delta_{03}\Delta_{12})$ equals the squared half-crossing product $(\Delta_{02}\Delta_{13} / 2)^2$.

                                                                                        def Signals.Geometry.complexTwoRowMinor {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℂ) (left right : Fin columnCount) :
                                                                                        ℂ

                                                                                        Complex two-column determinant $\Delta_{ab}^{\mathbb{C}}(M) = M_{0a} M_{1b} - M_{0b} M_{1a}$ for a $2 \times n$ complex Grassmannian representative $M \in \mathbb{C}^{2 \times n}$ (induced by projecting $\mathbb{C}^4$ twistors carrying complex incidence phases).

                                                                                        Instances For
                                                                                          theorem Signals.Geometry.complexTwoRowMinor_pluecker {columnCount : ℕ} (matrix : Matrix (Fin 2) (Fin columnCount) ℂ) (first second third fourth : Fin columnCount) :
                                                                                          complexTwoRowMinor matrix first second * complexTwoRowMinor matrix third fourth - complexTwoRowMinor matrix first third * complexTwoRowMinor matrix second fourth + complexTwoRowMinor matrix first fourth * complexTwoRowMinor matrix second third = 0

                                                                                          The 3-term quadratic Pluecker identity holds over $\mathbb{C}$ for any four column indices of any complex $2 \times n$ matrix $M \in \mathbb{C}^{2 \times n}$.

                                                                                          theorem Signals.Geometry.complexGr24_crossing_eq_channel_sum (matrix : Matrix (Fin 2) (Fin 4) ℂ) :
                                                                                          complexTwoRowMinor matrix 0 2 * complexTwoRowMinor matrix 1 3 = complexTwoRowMinor matrix 0 1 * complexTwoRowMinor matrix 2 3 + complexTwoRowMinor matrix 0 3 * complexTwoRowMinor matrix 1 2

                                                                                          In any complex $2 \times 4$ Grassmannian matrix $M \in \mathbb{C}^{2 \times 4}$, the crossing Pluecker product $\Delta_{02}^{\mathbb{C}}(M)\Delta_{13}^{\mathbb{C}}(M)$ equals the coherent complex sum of the two uncrossed channel products $\Delta_{01}^{\mathbb{C}}(M)\Delta_{23}^{\mathbb{C}}(M) + \Delta_{03}^{\mathbb{C}}(M)\Delta_{12}^{\mathbb{C}}(M)$.

                                                                                          theorem Signals.Geometry.twoRowMinor_basisChange {columnCount : ℕ} (basis : Matrix (Fin 2) (Fin 2) ℝ) (matrix : Matrix (Fin 2) (Fin columnCount) ℝ) (left right : Fin columnCount) :
                                                                                          twoRowMinor (basis * matrix) left right = basis.det * twoRowMinor matrix left right

                                                                                          Left-multiplying any real $2 \times n$ matrix $M$ by a $2 \times 2$ basis-change matrix $B \in \mathbb{R}^{2 \times 2}$ scales every two-row minor $\Delta_{ab}(B M)$ by $\det B$.

                                                                                          theorem Signals.Geometry.complexTwoRowMinor_basisChange {columnCount : ℕ} (basis : Matrix (Fin 2) (Fin 2) ℂ) (matrix : Matrix (Fin 2) (Fin columnCount) ℂ) (left right : Fin columnCount) :
                                                                                          complexTwoRowMinor (basis * matrix) left right = basis.det * complexTwoRowMinor matrix left right

                                                                                          Left-multiplying any complex $2 \times n$ matrix $M_{\mathbb{C}}$ by a complex $2 \times 2$ basis-change matrix $B_{\mathbb{C}} \in \mathbb{C}^{2 \times 2}$ scales every complex two-row minor $\Delta_{ab}^{\mathbb{C}}(B_{\mathbb{C}} M_{\mathbb{C}})$ by $\det B_{\mathbb{C}}$.

                                                                                          noncomputable def Signals.Geometry.gr24ProjectiveBarycentricShift (matrix : Matrix (Fin 2) (Fin 4) ℝ) :
                                                                                          ℝ

                                                                                          Projectively Normalized Pluecker Barycentric Shift on $Gr(2, 4)$: Dividing the channel-imbalance difference by the crossing Pluecker product yields the scale-invariant projective barycentric shift $\widehat{d}_{\mathrm{bary}}(M) = \frac{\Delta_{01}(M)\Delta_{23}(M) - \Delta_{03}(M)\Delta_{12}(M)}{\Delta_{02}(M)\Delta_{13}(M)}$.

                                                                                          Instances For
                                                                                            noncomputable def Signals.Geometry.gr24ProjectiveVisibilitySq (matrix : Matrix (Fin 2) (Fin 4) ℝ) :
                                                                                            ℝ

                                                                                            Projectively Normalized Pluecker Visibility Squared on $Gr(2, 4)$: $\widehat{\mathcal{V}}_{Gr(2,4)}(M)^2 = \frac{4\,\Delta_{01}(M)\Delta_{23}(M)\,\Delta_{03}(M)\Delta_{12}(M)}{(\Delta_{02}(M)\Delta_{13}(M))^2}$.

                                                                                            Instances For
                                                                                              theorem Signals.Geometry.gr24_projective_pythagorean_complementarity (matrix : Matrix (Fin 2) (Fin 4) ℝ) (h_cross : twoRowMinor matrix 0 2 * twoRowMinor matrix 1 3 ≠ 0) :

                                                                                              Universal Projective Pythagorean Pluecker--Steiner Complementarity: For any real $2 \times 4$ matrix $M$ with nonvanishing crossing product $\Delta_{02}(M)\Delta_{13}(M) \neq 0$ (without requiring $\Delta_{02}\Delta_{13} = 2$), the projectively normalized barycentric shift and visibility satisfy $\widehat{d}_{\mathrm{bary}}(M)^2 + \widehat{\mathcal{V}}_{Gr(2,4)}(M)^2 = 1$.

                                                                                              theorem Signals.Geometry.gr24Projective_basisChange_invariant (basis : Matrix (Fin 2) (Fin 2) ℝ) (matrix : Matrix (Fin 2) (Fin 4) ℝ) (h_det : basis.det ≠ 0) :

                                                                                              Exact $GL(2, \mathbb{R})$ Basis-Change Invariance of Projective Pluecker Shift & Visibility: Under any nonsingular $2 \times 2$ transformation $B \in GL(2, \mathbb{R})$ ($\det B \neq 0$), both $\widehat{d}_{\mathrm{bary}}(B M) = \widehat{d}_{\mathrm{bary}}(M)$ and $\widehat{\mathcal{V}}_{Gr(2,4)}(B M)^2 = \widehat{\mathcal{V}}_{Gr(2,4)}(M)^2$ are strictly invariant because the $(\det B)^2$ scaling factors cancel identically.

                                                                                              $N$-ary ($N \ge 1$) Complex Grassmannian $Gr_{\mathbb{C}}(2, N+2)$ Channel Matrices & Sorkin Triple-Slit Invariance #

                                                                                              Generalizes the $N = 2$ double-slit Grassmannian channel matrix in $Gr_{\mathbb{C}}(2, 4)$ to an arbitrary $N$-slit ($N$-ary, including triple-slit $N = 3$, quadruple-slit $N = 4$, and general $N \ge 1$) complex Grassmannian representative in $Gr_{\mathbb{C}}(2, N + 2)$:

                                                                                              def Signals.Geometry.narySourceCol (numSlits : ℕ) :
                                                                                              Fin (numSlits + 2)

                                                                                              Source reference column index $0 \in \operatorname{Fin}(N + 2)$ in $Gr_{\mathbb{C}}(2, N + 2)$.

                                                                                              Instances For
                                                                                                def Signals.Geometry.naryCollectorCol (numSlits : ℕ) :
                                                                                                Fin (numSlits + 2)

                                                                                                Collector terminal column index $1 \in \operatorname{Fin}(N + 2)$ in $Gr_{\mathbb{C}}(2, N + 2)$.

                                                                                                Instances For
                                                                                                  def Signals.Geometry.narySlitCol {numSlits : ℕ} (j : Fin numSlits) :
                                                                                                  Fin (numSlits + 2)

                                                                                                  Slit-$j$ column index $j + 2 \in \operatorname{Fin}(N + 2)$ for $j \in \operatorname{Fin}(N)$ in $Gr_{\mathbb{C}}(2, N + 2)$.

                                                                                                  Instances For
                                                                                                    def Signals.Geometry.complexGr2NChannelMatrix (numSlits : ℕ) (z : Fin numSlits → ℂ) :
                                                                                                    Matrix (Fin 2) (Fin (numSlits + 2)) ℂ

                                                                                                    Canonical $2 \times (N + 2)$ complex Grassmannian channel matrix $M_{\mathbb{C}}^{(N)}(z) \in \mathbb{C}^{2 \times (N + 2)}$ encoding $N$ complex slit channel amplitudes $z : \operatorname{Fin} N \to \mathbb{C}$ alongside the source reference column $0$ and collector column $1$.

                                                                                                    Instances For
                                                                                                      theorem Signals.Geometry.complexGr2NChannelMatrix_minors (numSlits : ℕ) (z : Fin numSlits → ℂ) :
                                                                                                      (∀ (j : Fin numSlits), complexTwoRowMinor (complexGr2NChannelMatrix numSlits z) (narySourceCol numSlits) (narySlitCol j) = z j) ∧ (∀ (j k : Fin numSlits), complexTwoRowMinor (complexGr2NChannelMatrix numSlits z) (narySlitCol j) (narySlitCol k) = z k - z j) ∧ complexTwoRowMinor (complexGr2NChannelMatrix numSlits z) (narySourceCol numSlits) (naryCollectorCol numSlits) = ∑ j : Fin numSlits, z j ∧ complexTwoRowMinor (complexGr2NChannelMatrix numSlits z) (narySourceCol numSlits) (naryCollectorCol numSlits) = ∑ j : Fin numSlits, complexTwoRowMinor (complexGr2NChannelMatrix numSlits z) (narySourceCol numSlits) (narySlitCol j)

                                                                                                      ** Exact Pluecker Minor Laws of the $N$-ary Complex Grassmannian Matrix $M_{\mathbb{C}}^{(N)}(z)$**: For any number of slits $N \in \mathbb{N}$ and complex channel amplitudes $z : \operatorname{Fin} N \to \mathbb{C}$:

                                                                                                      1. Each individual slit Pluecker minor equals its channel amplitude: $\Delta_{0, j+2}^{\mathbb{C}}\bigl(M_{\mathbb{C}}^{(N)}(z)\bigr) = z_j$,
                                                                                                      2. Each pairwise slit-to-slit Pluecker minor equals the amplitude difference: $\Delta_{j+2, k+2}^{\mathbb{C}}\bigl(M_{\mathbb{C}}^{(N)}(z)\bigr) = z_k - z_j$, and
                                                                                                      3. The collector Pluecker minor $\Delta_{0, 1}^{\mathbb{C}}\bigl(M_{\mathbb{C}}^{(N)}(z)\bigr)$ equals the coherent sum of all $N$ individual slit Pluecker minors: $\Delta_{0, 1}^{\mathbb{C}}\bigl(M_{\mathbb{C}}^{(N)}(z)\bigr) = \sum_{j=0}^{N-1} z_j = \sum_{j=0}^{N-1} \Delta_{0, j+2}^{\mathbb{C}}\bigl(M_{\mathbb{C}}^{(N)}(z)\bigr)$.
                                                                                                      noncomputable def Signals.Geometry.sorkinTripleSlitParameter (z0 z1 z2 : ℂ) :
                                                                                                      ℝ

                                                                                                      Sorkin third-order quantum interference functional $\kappa_3(z_0, z_1, z_2) = |z_0 + z_1 + z_2|^2 - (|z_0 + z_1|^2 + |z_0 + z_2|^2 + |z_1 + z_2|^2) + (|z_0|^2 + |z_1|^2 + |z_2|^2)$ for a triple-slit ($N = 3$) amplitude configuration $(z_0, z_1, z_2) \in \mathbb{C}^3$.

                                                                                                      Instances For

                                                                                                        Vanishing of the Sorkin Third-Order Interference Parameter on $Gr_{\mathbb{C}}(2, 5)$: For any three complex slit amplitudes $z_0, z_1, z_2 \in \mathbb{C}$ in a triple-slit system, the Sorkin third-order interference parameter $\kappa_3(z_0, z_1, z_2) = 0$ vanishes identically because pairwise interference terms cancel between the three-slit and two-slit sub-experiments.

                                                                                                        Orbital angular-momentum translations #

                                                                                                        These are real coordinate identities for a four-index bivector, not an identification of the bivector with a two-by-two commutator or a Casimir.

                                                                                                        @[reducible, inline]

                                                                                                        Four real coordinates in a fixed common index convention.

                                                                                                        Instances For
                                                                                                          def Signals.Geometry.orbitalBivector (position momentum : FourVector) :
                                                                                                          Matrix (Fin 4) (Fin 4) ℝ

                                                                                                          The orbital bivector position wedge momentum.

                                                                                                          Instances For
                                                                                                            theorem Signals.Geometry.orbitalBivector_antisymmetric (position momentum : FourVector) (row column : Fin 4) :
                                                                                                            orbitalBivector position momentum row column = -orbitalBivector position momentum column row

                                                                                                            The orbital tensor is antisymmetric.

                                                                                                            theorem Signals.Geometry.orbitalBivector_translate (position offset momentum : FourVector) :
                                                                                                            orbitalBivector (position + offset) momentum = orbitalBivector position momentum + orbitalBivector offset momentum

                                                                                                            Translating the position adds the offset's orbital bivector.

                                                                                                            Momentum and an antisymmetric angular-momentum tensor as algebraic data.

                                                                                                            Instances For

                                                                                                              Coordinate translation adds offset wedge momentum while preserving momentum.

                                                                                                              Instances For

                                                                                                                Coordinate translation does not change the supplied momentum.

                                                                                                                The angular-momentum shift exposes the full four-index wedge tensor.

                                                                                                                Higher-Rank $Gr(3, n)$ and $Gr_{\mathbb{C}}(3, n)$ Three-Row Minors, Four-Term Plücker Relations, and Three-Channel Cauchy–Binet / LGV Identities #

                                                                                                                def Signals.Geometry.threeRowMinor {columnCount : ℕ} (matrix : Matrix (Fin 3) (Fin columnCount) ℝ) (first second third : Fin columnCount) :
                                                                                                                ℝ

                                                                                                                Three-column determinant $\Delta_{abc}(M)$ of a real $3 \times n$ matrix $M \in \mathbb{R}^{3 \times n}$ for arbitrary column indices $a, b, c \in \operatorname{Fin}(n)$.

                                                                                                                Instances For
                                                                                                                  def Signals.Geometry.complexThreeRowMinor {columnCount : ℕ} (matrix : Matrix (Fin 3) (Fin columnCount) ℂ) (first second third : Fin columnCount) :
                                                                                                                  ℂ

                                                                                                                  Complex three-column determinant $\Delta_{abc}^{\mathbb{C}}(M_{\mathbb{C}})$ of a complex $3 \times n$ matrix $M_{\mathbb{C}} \in \mathbb{C}^{3 \times n}$ for arbitrary column indices $a, b, c \in \operatorname{Fin}(n)$.

                                                                                                                  Instances For
                                                                                                                    theorem Signals.Geometry.threeRowMinor_eq_selectedMinor {columnCount : ℕ} (matrix : Matrix (Fin 3) (Fin columnCount) ℝ) (first second third : Fin columnCount) (ordered01 : first < second) (ordered12 : second < third) :
                                                                                                                    threeRowMinor matrix first second third = selectedMinor matrix (OrderedColumns.triple first second third ordered01 ordered12)

                                                                                                                    For strictly ordered column indices $a < b < c$, threeRowMinor agrees with selectedMinor.

                                                                                                                    theorem Signals.Geometry.threeRowMinor_basisChange {columnCount : ℕ} (basis : Matrix (Fin 3) (Fin 3) ℝ) (matrix : Matrix (Fin 3) (Fin columnCount) ℝ) (first second third : Fin columnCount) :
                                                                                                                    threeRowMinor (basis * matrix) first second third = basis.det * threeRowMinor matrix first second third

                                                                                                                    Left-multiplying any real $3 \times n$ matrix $M$ by a $3 \times 3$ row basis matrix $B \in \mathbb{R}^{3 \times 3}$ scales every three-row minor $\Delta_{abc}(B M)$ by $\det B$.

                                                                                                                    theorem Signals.Geometry.threeRowMinor_pluecker {columnCount : ℕ} (matrix : Matrix (Fin 3) (Fin columnCount) ℝ) (i1 i2 j0 j1 j2 j3 : Fin columnCount) :
                                                                                                                    threeRowMinor matrix i1 i2 j0 * threeRowMinor matrix j1 j2 j3 - threeRowMinor matrix i1 i2 j1 * threeRowMinor matrix j0 j2 j3 + threeRowMinor matrix i1 i2 j2 * threeRowMinor matrix j0 j1 j3 - threeRowMinor matrix i1 i2 j3 * threeRowMinor matrix j0 j1 j2 = 0

                                                                                                                    Higher-Rank $Gr(3, n)$ Four-Term Quadratic Plücker Relation (Real): For any real $3 \times n$ matrix $M \in \mathbb{R}^{3 \times n}$, any two shared pivot columns $i_1, i_2 \in \operatorname{Fin}(n)$, and any four columns $j_0, j_1, j_2, j_3 \in \operatorname{Fin}(n)$, the four $3 \times 3$ Plücker minors satisfy the universal 4-term quadratic Plücker syzygy: $$\Delta_{i_1 i_2 j_0}(M),\Delta_{j_1 j_2 j_3}(M)

                                                                                                                    • \Delta_{i_1 i_2 j_1}(M),\Delta_{j_0 j_2 j_3}(M)
                                                                                                                    • \Delta_{i_1 i_2 j_2}(M),\Delta_{j_0 j_1 j_3}(M)
                                                                                                                    • \Delta_{i_1 i_2 j_3}(M),\Delta_{j_0 j_1 j_2}(M) = 0.$$
                                                                                                                    theorem Signals.Geometry.complexThreeRowMinor_pluecker {columnCount : ℕ} (matrix : Matrix (Fin 3) (Fin columnCount) ℂ) (i1 i2 j0 j1 j2 j3 : Fin columnCount) :
                                                                                                                    complexThreeRowMinor matrix i1 i2 j0 * complexThreeRowMinor matrix j1 j2 j3 - complexThreeRowMinor matrix i1 i2 j1 * complexThreeRowMinor matrix j0 j2 j3 + complexThreeRowMinor matrix i1 i2 j2 * complexThreeRowMinor matrix j0 j1 j3 - complexThreeRowMinor matrix i1 i2 j3 * complexThreeRowMinor matrix j0 j1 j2 = 0

                                                                                                                    Higher-Rank $Gr_{\mathbb{C}}(3, n)$ Four-Term Quadratic Plücker Relation (Complex): For any complex $3 \times n$ matrix $M_{\mathbb{C}} \in \mathbb{C}^{3 \times n}$ and column indices $i_1, i_2, j_0, j_1, j_2, j_3 \in \operatorname{Fin}(n)$, $$\Delta_{i_1 i_2 j_0}^{\mathbb{C}},\Delta_{j_1 j_2 j_3}^{\mathbb{C}}

                                                                                                                    • \Delta_{i_1 i_2 j_1}^{\mathbb{C}},\Delta_{j_0 j_2 j_3}^{\mathbb{C}}
                                                                                                                    • \Delta_{i_1 i_2 j_2}^{\mathbb{C}},\Delta_{j_0 j_1 j_3}^{\mathbb{C}}
                                                                                                                    • \Delta_{i_1 i_2 j_3}^{\mathbb{C}},\Delta_{j_0 j_1 j_2}^{\mathbb{C}} = 0.$$
                                                                                                                    theorem Signals.Geometry.selectedMinor_pluecker_rank3_five {columnCount : ℕ} (matrix : Matrix (Fin 3) (Fin columnCount) ℝ) (columns : OrderedColumns 5 columnCount) :
                                                                                                                    selectedMinor matrix (OrderedColumns.triple (columns.index 0) (columns.index 1) (columns.index 2) ⋯ ⋯) * selectedMinor matrix (OrderedColumns.triple (columns.index 1) (columns.index 3) (columns.index 4) ⋯ ⋯) - selectedMinor matrix (OrderedColumns.triple (columns.index 0) (columns.index 1) (columns.index 3) ⋯ ⋯) * selectedMinor matrix (OrderedColumns.triple (columns.index 1) (columns.index 2) (columns.index 4) ⋯ ⋯) + selectedMinor matrix (OrderedColumns.triple (columns.index 0) (columns.index 1) (columns.index 4) ⋯ ⋯) * selectedMinor matrix (OrderedColumns.triple (columns.index 1) (columns.index 2) (columns.index 3) ⋯ ⋯) = 0

                                                                                                                    Ordered Five-Column $Gr(3, n)$ Plücker Identity (selectedMinor Form): For any ordered five-column selection $c_0 < c_1 < c_2 < c_3 < c_4$ in $\operatorname{Fin}(n)$, choosing the shared pivot pair $(c_0, c_1)$ and the four-tuple $(c_1, c_2, c_3, c_4)$ causes the degenerate term $\Delta_{c_0 c_1 c_1}$ to vanish and yields the ordered three-term $Gr(3, 5)$ Plücker relation in selectedMinor: $$\Delta_{c_0 c_1 c_2}\Delta_{c_1 c_3 c_4}

                                                                                                                    • \Delta_{c_0 c_1 c_3}\Delta_{c_1 c_2 c_4}
                                                                                                                    • \Delta_{c_0 c_1 c_4}\Delta_{c_1 c_2 c_3} = 0.$$