Quatroids – Julia Results Jupyter Notebook

We begin by following the instructions from the MathRepo page:

]activate .

  Activating project at `~/Dropbox/Articoli/2023-QuatroidsRationalPlaneCubics/mathrepoSource/Quatroids`

]instantiate

Precompiling project...
  ✓ Quatroids
        Info Given Quatroids was explicitly requested, output will be shown live
  1 dependency successfully precompiled in 15 seconds. 250 already precompiled.
  1 dependency precompiled but a different version is currently loaded. Restart julia to access the new version

using Quatroids

The function QuatroidAnalysis performs the following computation: - It uses the input file src/InitialFiles/SimpleMatroids38.txt to import the database of matroids of rank 3 on 8 points - It uses Algorithm 1 of the paper to produce the list of candidate quatroids - It computes several features of the quatroids: which are Bezoutian, the oribt side for the action of S_8 and other data useful in the rest of the computation - It computes quatroid reductions and modifications as described in Section 4 of the paper - It computes the upper bounds on d_Q, as described in Section 5 of the paper - It uses src/InitialFiles/RationalRepresentatives.txt to import the list of one rational point in each realization space of the 125 quatroids that are representable over the rationals

The results of the computation are stored in several txt files. These files are used to produce Macaulay2 files required by the Macaulay2 code in QuatroidsM2Code.zip

QuatroidAnalysis()

~~~~~~~~~~~~~~~~~~~~~ Quatroid Analysis is starting ~~~~~~~~~~~~~~~~~~~~~
 This computation addresses all the claims made in the paper.
 It requires two input files, located in src/InitialFiles/
 SimpleMatroids38.txt: the database of matroids of rank 3 on 8 points
 RationalRepresentatives.txt: the list of one rational point in each realization space of the 125 representable quatroids
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Parsing Matroids From DB ~~~~~~~~~~~~~~~~~~~~~
Checking if matroids have been previously parsed
Pulling parsed matroids
~~~~~~~~~~~~~~~~~~~~~ Computing All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Determining Which Candidate Quatroids Are Bezoutian~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Computing Orbit Sizes Of All Candidate Quatroid ~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Computing Short Descriptions Of All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Computing Signatures Of All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Computing All Modifications of All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Computing Reductions For All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
Reducing quatroid 1
Quatroid 1 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 2
Quatroid 2 reduces to quatroid 1 for reason [2, 1]
Reducing quatroid 3
Quatroid 3 reduces to quatroid 2 for reason [2, 5]
Reducing quatroid 4
Quatroid 4 reduces to quatroid 4 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 5
Quatroid 5 reduces to quatroid 5 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 6
Quatroid 6 reduces to quatroid 1 for reason [2, 1]
Reducing quatroid 7
Quatroid 7 reduces to quatroid 1 for reason [2, 1]
Reducing quatroid 8
Quatroid 8 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 9
Quatroid 9 reduces to quatroid 2 for reason [1, 3]
Reducing quatroid 10
Quatroid 10 reduces to quatroid 2 for reason [1, 2]
Reducing quatroid 11
Quatroid 11 reduces to quatroid 9 for reason [2, 7]
Reducing quatroid 12
Quatroid 12 reduces to quatroid 9 for reason [2, 8]
Reducing quatroid 13
Quatroid 13 reduces to quatroid 13 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 14
Quatroid 14 reduces to quatroid 6 for reason [1, 3]
Reducing quatroid 15
Quatroid 15 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 16
Quatroid 16 reduces to quatroid 9 for reason [1, 3]
Reducing quatroid 17
Quatroid 17 reduces to quatroid 2 for reason [1, 1]
Reducing quatroid 18
Quatroid 18 reduces to quatroid 2 for reason [1, 1]
Reducing quatroid 19
Quatroid 19 reduces to quatroid 19 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 20
Quatroid 20 reduces to quatroid 17 for reason [2, 8]
Reducing quatroid 21
Quatroid 21 reduces to quatroid 21 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 22
Quatroid 22 reduces to quatroid 22 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 23
Quatroid 23 reduces to quatroid 6 for reason [1, 1]
Reducing quatroid 24
Quatroid 24 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 25
Quatroid 25 reduces to quatroid 25 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 26
Quatroid 26 reduces to quatroid 17 for reason [1, 7]
Reducing quatroid 27
Quatroid 27 reduces to quatroid 24 for reason [2, 8]
Reducing quatroid 28
Quatroid 28 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 29
Quatroid 29 reduces to quatroid 17 for reason [1, 6]
Reducing quatroid 30
Quatroid 30 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 31
Quatroid 31 reduces to quatroid 30 for reason [2, 8]
Reducing quatroid 32
Quatroid 32 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 33
Quatroid 33 reduces to quatroid 30 for reason [1, 6]
Reducing quatroid 34
Quatroid 34 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 35
Quatroid 35 reduces to quatroid 30 for reason [1, 3]
Reducing quatroid 36
Quatroid 36 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 37
Quatroid 37 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 38
Quatroid 38 reduces to quatroid 38 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 39
Quatroid 39 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 40
Quatroid 40 reduces to quatroid 43 for reason [1, 4]
Reducing quatroid 41
Quatroid 41 reduces to quatroid 41 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 42
Quatroid 42 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 43
Quatroid 43 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 44
Quatroid 44 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 45
Quatroid 45 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 46
Quatroid 46 reduces to quatroid 25 for reason [1, 8]
Reducing quatroid 47
Quatroid 47 reduces to quatroid 17 for reason [1, 4]
Reducing quatroid 48
Quatroid 48 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 49
Quatroid 49 reduces to quatroid 25 for reason [1, 8]
Reducing quatroid 50
Quatroid 50 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 51
Quatroid 51 reduces to quatroid 25 for reason [1, 8]
Reducing quatroid 52
Quatroid 52 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 53
Quatroid 53 reduces to quatroid 53 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 54
Quatroid 54 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 55
Quatroid 55 reduces to quatroid 17 for reason [1, 3]
Reducing quatroid 56
Quatroid 56 reduces to quatroid 9 for reason [1, 2]
Reducing quatroid 57
Quatroid 57 reduces to quatroid 57 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 58
Quatroid 58 reduces to quatroid 58 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 59
Quatroid 59 reduces to quatroid 59 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 60
Quatroid 60 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 61
Quatroid 61 reduces to quatroid 17 for reason [1, 3]
Reducing quatroid 62
Quatroid 62 reduces to quatroid 62 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 63
Quatroid 63 reduces to quatroid 63 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 64
Quatroid 64 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 65
Quatroid 65 reduces to quatroid 17 for reason [1, 3]
Reducing quatroid 66
Quatroid 66 reduces to quatroid 66 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 67
Quatroid 67 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 68
Quatroid 68 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 69
Quatroid 69 reduces to quatroid 17 for reason [1, 3]
Reducing quatroid 70
Quatroid 70 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 71
Quatroid 71 reduces to quatroid 9 for reason [1, 2]
Reducing quatroid 72
Quatroid 72 reduces to quatroid 9 for reason [1, 1]
Reducing quatroid 73
Quatroid 73 reduces to quatroid 73 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 74
Quatroid 74 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 75
Quatroid 75 reduces to quatroid 17 for reason [1, 2]
Reducing quatroid 76
Quatroid 76 reduces to quatroid 76 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 77
Quatroid 77 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 78
Quatroid 78 reduces to quatroid 9 for reason [1, 1]
Reducing quatroid 79
Quatroid 79 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 80
Quatroid 80 reduces to quatroid 9 for reason [1, 3]
Reducing quatroid 81
Quatroid 81 reduces to quatroid 81 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 82
Quatroid 82 reduces to quatroid 82 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 83
Quatroid 83 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 84
Quatroid 84 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 85
Quatroid 85 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 86
Quatroid 86 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 87
Quatroid 87 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 88
Quatroid 88 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 89
Quatroid 89 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 90
Quatroid 90 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 91
Quatroid 91 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 92
Quatroid 92 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 93
Quatroid 93 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 94
Quatroid 94 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 95
Quatroid 95 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 96
Quatroid 96 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 97
Quatroid 97 reduces to quatroid 17 for reason [1, 4]
Reducing quatroid 98
Quatroid 98 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 99
Quatroid 99 reduces to quatroid 17 for reason [1, 2]
Reducing quatroid 100
Quatroid 100 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 101
Quatroid 101 reduces to quatroid 101 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 102
Quatroid 102 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 103
Quatroid 103 reduces to quatroid 30 for reason [1, 3]
Reducing quatroid 104
Quatroid 104 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 105
Quatroid 105 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 106
Quatroid 106 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 107
Quatroid 107 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 108
Quatroid 108 reduces to quatroid 2 for reason [1, 1]
Reducing quatroid 109
Quatroid 109 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 110
Quatroid 110 reduces to quatroid 9 for reason [1, 1]
Reducing quatroid 111
Quatroid 111 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 112
Quatroid 112 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 113
Quatroid 113 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 114
Quatroid 114 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 115
Quatroid 115 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 116
Quatroid 116 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 117
Quatroid 117 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 118
Quatroid 118 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 119
Quatroid 119 reduces to quatroid 9 for reason [1, 1]
Reducing quatroid 120
Quatroid 120 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 121
Quatroid 121 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 122
Quatroid 122 reduces to quatroid 2 for reason [1, 3]
Reducing quatroid 123
Quatroid 123 reduces to quatroid 123 for reason Union{Nothing, Int64}[4, nothing]
Reducing quatroid 124
Quatroid 124 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 125
Quatroid 125 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
Reducing quatroid 126
Quatroid 126 reduces to quatroid 1 for reason Union{Nothing, Int64}[3, nothing]
The first three types of reductions show all are irreducible except
[4, 5, 13, 19, 21, 22, 25, 38, 41, 46, 49, 51, 53, 57, 58, 59, 62, 63, 66, 73, 76, 81, 82, 101, 123]
Checking modifications for quatroid 4
Checking modifications for quatroid 5
Checking modifications for quatroid 13
Checking modifications for quatroid 19
Checking modifications for quatroid 21
Checking modifications for quatroid 22
Checking modifications for quatroid 25
Checking modifications for quatroid 38
Checking modifications for quatroid 41
Checking modifications for quatroid 53
Checking modifications for quatroid 57
Checking modifications for quatroid 58
Checking modifications for quatroid 59
Checking modifications for quatroid 62
Checking modifications for quatroid 66
Checking modifications for quatroid 73
Checking modifications for quatroid 76
Checking modifications for quatroid 81
Checking modifications for quatroid 82
Checking modifications for quatroid 101
Checking modifications for quatroid 123
Reductions are written in Reductions.txt
Reduction proofs are written in ReductionProofs.txt
~~~~~~~~~~~~~~~~~~~~~ Computing Weak Upper Bounds For d_Q For All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
Weak upper bounds for dQ are stored in WeakUpperBounds.txt
~~~~~~~~~~~~~~~~~~~~~ Computing Strong Upper Bounds For d_Q For All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
Strong upper bounds for dQ are stored in StrongUpperBounds.txt
~~~~~~~~~~~~~~~~~~~~~ Reading Rational Representatives For All Candidate Quatroids ~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~ Converting Data to M2 Format ~~~~~~~~~~~~~~~~~~~~~

The following reads the matroid database file, deletes the two non-representable matroids, and appends the one relevant rank 2 matroid. The result is an array of sets of triples of {1…8}, each describing a matroid representable by 8 points in the plane up to the S_8 action of relabeling the points. This list is exhaustive and is stored subsequently in src/Results/Matroids.txt. Subsequent calls of this function will read from that file.

AllMatroids = GenerateAllMatroids(;verbose=true)

Checking if matroids have been previously parsed
Pulling parsed matroids

67-element Vector{Any}:
 Any[]
 [[1, 2, 3]]
 [[1, 2, 3], [1, 4, 5]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 7]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 7], [3, 4, 7]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 7], [3, 4, 7], [3, 5, 8]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 7], [3, 4, 8]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 7], [3, 4, 8], [5, 6, 8]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 7], [4, 7, 8]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 8]]
 [[1, 2, 3], [1, 4, 5], [1, 6, 7], [2, 4, 6], [2, 5, 8], [3, 5, 7]]
 ⋮
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 5, 8], [4, 6, 7]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 5, 8], [6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 6, 7]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 6, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 6, 8], [4, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [5, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [5, 6, 7]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [5, 6, 7], [5, 6, 8], [5, 7, 8], [6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 2, 6], [1, 2, 7], [1, 2, 8], [1, 3, 4], [1, 3, 5], [1, 3, 6], [1, 3, 7]  …  [4, 5, 6], [4, 5, 7], [4, 5, 8], [4, 6, 7], [4, 6, 8], [4, 7, 8], [5, 6, 7], [5, 6, 8], [5, 7, 8], [6, 7, 8]]

The following calls Algorithm 1 on each of the S_8 representatives contained in AllMatroids. The result is, up to the S_8 action, an exhaustive list of ‘candidate quatroids’: subsets of triples and sextuples satisfying Bezout’s weak criteria and have underlying representable matroids. Calling this function produces a file called CandidateQuatroids.txt containing the output (126 sets of triples and sextuples of {1…8}). Subsequent calls of this function will read from that file.

AllQuatroids = GenerateAllCandidateQuatroids(;verbose=true)

126-element Vector{Any}:
 Any[]
 [[1, 2, 3, 4, 5, 6]]
 [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 7, 8]]
 [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 7, 8], [1, 2, 5, 6, 7, 8]]
 [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 7, 8], [1, 2, 5, 6, 7, 8], [3, 4, 5, 6, 7, 8]]
 [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 7], [1, 2, 3, 4, 6, 7], [1, 2, 3, 5, 6, 7], [1, 2, 4, 5, 6, 7], [1, 3, 4, 5, 6, 7], [2, 3, 4, 5, 6, 7]]
 [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 7], [1, 2, 3, 4, 5, 8], [1, 2, 3, 4, 6, 7], [1, 2, 3, 4, 6, 8], [1, 2, 3, 4, 7, 8], [1, 2, 3, 5, 6, 7], [1, 2, 3, 5, 6, 8], [1, 2, 3, 5, 7, 8], [1, 2, 3, 6, 7, 8]  …  [1, 3, 4, 6, 7, 8], [1, 3, 5, 6, 7, 8], [1, 4, 5, 6, 7, 8], [2, 3, 4, 5, 6, 7], [2, 3, 4, 5, 6, 8], [2, 3, 4, 5, 7, 8], [2, 3, 4, 6, 7, 8], [2, 3, 5, 6, 7, 8], [2, 4, 5, 6, 7, 8], [3, 4, 5, 6, 7, 8]]
 [[1, 2, 3]]
 [[1, 2, 3], [1, 2, 4, 5, 6, 7]]
 [[1, 2, 3], [1, 4, 5, 6, 7, 8]]
 [[1, 2, 3], [1, 2, 4, 5, 6, 7], [1, 3, 4, 5, 6, 8]]
 [[1, 2, 3], [1, 2, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]]
 [[1, 2, 3], [1, 2, 4, 5, 6, 7], [1, 3, 4, 5, 6, 8], [2, 3, 4, 5, 7, 8]]
 ⋮
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 6, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [3, 6, 8], [4, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 5, 7], [6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [2, 7, 8], [3, 4, 5, 6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [1, 5, 6], [2, 3, 4], [5, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [1, 2, 5, 6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [1, 2, 5, 6, 7, 8], [3, 4, 5, 6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [5, 6, 7]]
 [[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [5, 6, 7], [5, 6, 8], [5, 7, 8], [6, 7, 8]]
 [[1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 2, 6], [1, 2, 7], [1, 2, 8], [1, 3, 4], [1, 3, 5], [1, 3, 6], [1, 3, 7]  …  [4, 5, 6], [4, 5, 7], [4, 5, 8], [4, 6, 7], [4, 6, 8], [4, 7, 8], [5, 6, 7], [5, 6, 8], [5, 7, 8], [6, 7, 8]]

The Commands

There are several commands which analyze certain aspects of these 126 candidate quatroid orbits. Each produces a corresponding file in src/Results. Subsequent calls will then read from that file.

Bezoutian

This produces 126 lines of boolean values indicating whether the corresponding quatroid is Bezoutian.

AllBezoutian = Bezoutian()

126-element Vector{Any}:
  true
  true
  true
  true
  true
 false
 false
  true
  true
  true
  true
  true
  true
     ⋮
 false
 false
 false
 false
 false
 false
 false
 false
 false
 false
 false
 false

This indicates, for instance, that quatroid number 1 is Bezoutian, while quatroid number 6 is not.

Orbit Sizes

This produces a list of 126 integers; each is the size of the S_8-orbit of the corresponding quatroid.

AllOrbitSizes = OrbitSizes()

126-element Vector{Any}:
     1
    28
   210
   420
   105
     8
     1
    56
   840
   168
  3360
   840
  3360
     ⋮
 20160
  5040
 10080
  2520
  2520
  3360
    70
   420
   210
   280
    35
     1

This indicates, for instance, that the S_8 orbits of quatroids 1 and 2 have size 1 and 28, respectively:

AllOrbitSizes[1], AllOrbitSizes[2]

(1, 28)

Short Descriptions

This produces a list with the short description of each candidate quatroid. The short description removes redundant data, e.g. if Q = ([123,124,134,234],[]) then the short desc of Q is [[1234],[]]. The result is a pair of sets subsets of {1..8}. The first set indicates those points on lines. The second indicates those points on conics.

AllShortDescriptions = ShortDescriptions()

126-element Vector{Any}:
 Vector{Any}[[], []]
 Vector{Any}[[], [[1, 2, 3, 4, 5, 6]]]
 Vector{Any}[[], [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 7, 8]]]
 Vector{Any}[[], [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 7, 8], [1, 2, 5, 6, 7, 8]]]
 Vector{Any}[[], [[1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 7, 8], [1, 2, 5, 6, 7, 8], [3, 4, 5, 6, 7, 8]]]
 Vector{Any}[[], [[1, 2, 3, 4, 5, 6, 7]]]
 Vector{Any}[[], [[1, 2, 3, 4, 5, 6, 7, 8]]]
 Vector{Any}[[[1, 2, 3]], []]
 [[[1, 2, 3]], [[1, 2, 4, 5, 6, 7]]]
 [[[1, 2, 3]], [[1, 4, 5, 6, 7, 8]]]
 [[[1, 2, 3]], [[1, 2, 4, 5, 6, 7], [1, 3, 4, 5, 6, 8]]]
 [[[1, 2, 3]], [[1, 2, 4, 5, 6, 7], [3, 4, 5, 6, 7, 8]]]
 [[[1, 2, 3]], [[1, 2, 4, 5, 6, 7], [1, 3, 4, 5, 6, 8], [2, 3, 4, 5, 7, 8]]]
 ⋮
 Vector{Any}[[[1, 2, 3, 4], [1, 5, 6], [2, 5, 7], [3, 6, 8]], []]
 Vector{Any}[[[1, 2, 3, 4], [1, 5, 6], [2, 5, 7], [3, 6, 8], [4, 7, 8]], []]
 Vector{Any}[[[1, 2, 3, 4], [1, 5, 6], [2, 5, 7], [6, 7, 8]], []]
 Vector{Any}[[[1, 2, 3, 4], [1, 5, 6], [2, 7, 8]], []]
 [[[1, 2, 3, 4], [1, 5, 6], [2, 7, 8]], [[3, 4, 5, 6, 7, 8]]]
 Vector{Any}[[[1, 2, 3, 4], [1, 5, 6], [5, 7, 8]], []]
 Vector{Any}[[[1, 2, 3, 4]], []]
 [[[1, 2, 3, 4]], [[1, 2, 5, 6, 7, 8]]]
 [[[1, 2, 3, 4]], [[1, 2, 5, 6, 7, 8], [3, 4, 5, 6, 7, 8]]]
 Vector{Any}[[[1, 2, 3, 4], [5, 6, 7]], []]
 Vector{Any}[[[1, 2, 3, 4], [5, 6, 7, 8]], []]
 Vector{Any}[[[1, 2, 3, 4, 5, 6, 7, 8]], []]

Quatroid Signatures

This produces a list with the signature of each candidate quatroid. The signature of a quatroid is a quadruple (a,b,c,d) where

• a is the the index of the underlying matroid in the list Simplematroids38.txt

• b is the number of triples (not just lines!) involved in the quatroid

• c is the number of sextuples (not just conics!) involved

• d is the 8 pairs of integers (x,y), ordered, so that (x,y) appears if there is a number i in {1…8} which is involved in x triples and y sextuples

AllQuatroidSignatures = QuatroidSignatures()

126-element Vector{Any}:
 Any[1, 0, 0, [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]]]
 Any[1, 0, 1, [[0, 0], [0, 0], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]]
 Any[1, 0, 2, [[0, 1], [0, 1], [0, 1], [0, 1], [0, 2], [0, 2], [0, 2], [0, 2]]]
 Any[1, 0, 3, [[0, 2], [0, 2], [0, 2], [0, 2], [0, 2], [0, 2], [0, 3], [0, 3]]]
 Any[1, 0, 4, [[0, 3], [0, 3], [0, 3], [0, 3], [0, 3], [0, 3], [0, 3], [0, 3]]]
 Any[1, 0, 7, [[0, 0], [0, 6], [0, 6], [0, 6], [0, 6], [0, 6], [0, 6], [0, 6]]]
 Any[1, 0, 28, [[0, 21], [0, 21], [0, 21], [0, 21], [0, 21], [0, 21], [0, 21], [0, 21]]]
 Any[2, 1, 0, [[0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [1, 0], [1, 0], [1, 0]]]
 Any[2, 1, 1, [[0, 0], [0, 1], [0, 1], [0, 1], [0, 1], [1, 0], [1, 1], [1, 1]]]
 Any[2, 1, 1, [[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [1, 0], [1, 0], [1, 1]]]
 Any[2, 1, 2, [[0, 1], [0, 1], [0, 2], [0, 2], [0, 2], [1, 1], [1, 1], [1, 2]]]
 Any[2, 1, 2, [[0, 1], [0, 2], [0, 2], [0, 2], [0, 2], [1, 1], [1, 1], [1, 1]]]
 Any[2, 1, 3, [[0, 2], [0, 2], [0, 2], [0, 3], [0, 3], [1, 2], [1, 2], [1, 2]]]
 ⋮
 Any[59, 7, 0, [[1, 0], [1, 0], [2, 0], [2, 0], [3, 0], [4, 0], [4, 0], [4, 0]]]
 Any[60, 8, 0, [[2, 0], [2, 0], [2, 0], [2, 0], [4, 0], [4, 0], [4, 0], [4, 0]]]
 Any[61, 7, 0, [[1, 0], [2, 0], [2, 0], [2, 0], [3, 0], [3, 0], [4, 0], [4, 0]]]
 Any[62, 6, 0, [[1, 0], [1, 0], [1, 0], [1, 0], [3, 0], [3, 0], [4, 0], [4, 0]]]
 Any[62, 6, 1, [[1, 1], [1, 1], [1, 1], [1, 1], [3, 1], [3, 1], [4, 0], [4, 0]]]
 Any[63, 6, 0, [[1, 0], [1, 0], [1, 0], [2, 0], [3, 0], [3, 0], [3, 0], [4, 0]]]
 Any[64, 4, 0, [[0, 0], [0, 0], [0, 0], [0, 0], [3, 0], [3, 0], [3, 0], [3, 0]]]
 Any[64, 4, 1, [[0, 1], [0, 1], [0, 1], [0, 1], [3, 0], [3, 0], [3, 1], [3, 1]]]
 Any[64, 4, 2, [[0, 2], [0, 2], [0, 2], [0, 2], [3, 1], [3, 1], [3, 1], [3, 1]]]
 Any[65, 5, 0, [[0, 0], [1, 0], [1, 0], [1, 0], [3, 0], [3, 0], [3, 0], [3, 0]]]
 Any[66, 8, 0, [[3, 0], [3, 0], [3, 0], [3, 0], [3, 0], [3, 0], [3, 0], [3, 0]]]
 Any[67, 56, 0, [[21, 0], [21, 0], [21, 0], [21, 0], [21, 0], [21, 0], [21, 0], [21, 0]]]

Notice that, for instance, quatroid 121 (four points on a line) has 4 triples even though all four of these triples define the same line:

AllQuatroidSignatures[121]

4-element Vector{Any}:
 64
  4
  0
   [[0, 0], [0, 0], [0, 0], [0, 0], [3, 0], [3, 0], [3, 0], [3, 0]]

However, this only happens because quatroid 121 is not Bezoutian.

AllBezoutian[121]

false

If instead we consider quatroid 65, which is Bezoutian and which has 4 lines, the number of triples is exactly 4:

AllBezoutian[65]

true

AllQuatroids[65]

5-element Vector{Vector{Int64}}:
 [1, 2, 3]
 [1, 4, 5]
 [2, 4, 6]
 [3, 5, 7]
 [1, 2, 5, 6, 7, 8]

AllQuatroidSignatures[65]

4-element Vector{Any}:
 25
  4
  1
   [[0, 1], [1, 1], [1, 1], [2, 0], [2, 0], [2, 1], [2, 1], [2, 1]]

Quatroid Modifications

This takes a quatroid Q and first checks if it satisfies the necessary conditions to have a reduced base locus (i.e. every representation gives a reduced base locus). If this is the case, it lists those quatroids which may be obtianed by passing to the base locus and subsequently deleting a point. If Q does not satisfy these necessary conditions, [Q] is returned.

QuatroidModifications()

126-element Vector{Any}:
 [1]
 [2]
 [3, 9, 15]
 [4, 17, 24]
 [5, 25]
 [6]
 [7]
 [8]
 [9]
 [10]
 [11, 16, 54]
 [12]
 [13, 20, 28, 55]
 ⋮
 [115]
 [116]
 [117]
 [118]
 [119]
 [120]
 [121]
 [122]
 [123]
 [124]
 [125]
 [126]

For instance, quatroid 3 may be modified as above to get quatroids 9 and 15. On the other hand, quatroid 1 is just 8 generic points, so even though it satisfies the necessary conditions to have a reduced base locus, its modifications all just return quatroid 1 again.

Quatroid Reductions

This is the function which reduces the problem of determining irreducibility of a quatroid stratum S_Q to the problem of determining the irreducibility of a new quatroid stratum S_{Q’} as described in Section 4 of the paper. These reductions are based on the following:

• 1. There is a point involved in one or two lines but no conics which may be deleted.

• 2. There is a point involved in no lines and one conic which may be deleted.

• 3. There are no conics, and there are six or fewer lines.

• 4. Q has reduced base locus and may be modified to Q’.

The output is a pair: [Reductions,ReductionProofs]. * Reductions: for each i in 1:126, return the quatroid index whose irreducibility proves irreducibility for Q_i (iteratively). * ReductionProofs: for each i in 1:126, a string indicating the applications of i,ii,iii, and iv, used to obtain the corresponding reduction.

AllReductions = QuatroidReductions()

Reductions are written in Reductions.txt
Reduction proofs are written in ReductionProofs.txt

2-element Vector{Vector{Any}}:
 [1, 1, 1, 1, 25, 1, 1, 1, 1, 1  …  1, 1, 1, 1, 1, 1, 123, 1, 1, 1]
 ["1--(iii <= 6 lines)-->1", "2--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "3--(ii: delete 5)-->2--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "4--(iv,17)-->17--(i: delete 1)-->2--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "5--(iv,0)-->[5, 25]", "6--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "7--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "8--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "9--(i: delete 3)-->2--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "10--(i: delete 2)-->2--(ii: delete 1)-->1--(iii <= 6 lines)-->1"  …  "117--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "118--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "119--(i: delete 1)-->9--(i: delete 3)-->2--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "120--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "121--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "122--(i: delete 3)-->2--(ii: delete 1)-->1--(iii <= 6 lines)-->1", "123", "124--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "125--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1", "126--(iii <= 6 lines)-->1--(iii <= 6 lines)-->1"]

For instance, quatroid 2 reduces to quatroid 1 by applying ii with point 1. (Note that quatroid 1 always reduces to itself in the output; although it’s trivially correct, having it here is really just an artifact.)

AllReductions[1][2], AllReductions[2][2]

(1, "2--(ii: delete 1)-->1--(iii <= 6 lines)-->1")

Weak Upper Bounds

QuatroidWeakUpperBounds gives a list of 12-m_Q for each quatroid candidate orbit which is Bezoutian and representable (for the others the number is zero), see Section 6.1.

QuatroidWeakUpperBounds()

Weak upper bounds for dQ are stored in WeakUpperBounds.txt

126-element Vector{Any}:
 12
 10
  8
  6
  4
  0
  0
 10
  8
 10
  6
  8
  4
  ⋮
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0

Strong Upper Bounds

This gives a list of 12-m_Q-i_Q for each quatroid candidate orbit, where m_Q is as defined in Section 6 and i_Q indicates whether or not the quatroid is contained in Q_10 or Q_77.

QuatroidStrongUpperBounds()

Strong upper bounds for dQ are stored in StrongUpperBounds.txt

126-element Vector{Any}:
 12
 10
  8
  6
  4
  0
  0
 10
  8
  9
  6
  7
  4
  ⋮
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0
  0