File size: 362,248 Bytes
803451e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | {"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nRemoveOnes := x -> Filtered(x, i->i<>1);\n\n#F MDDFT(<dims>, [<exp>]) - multi-dimensional DFT non-terminal\n#F dims = [ <n_1>,.., <n_t> ] list of (positive) dimensions\n#F exp = root of unity exponent scaling (see DFT for exact definition)\n#F\n#F Definition : multidimensional matrix of size NxN, where N=n_1*..*n_t\n#F can also be represented as Tensor(DFT(n_1), ..., DFT(n_t))\n#F\n#F Example (direct) : MDDFT([2,4,4])\n#F Example (inverse) : MDDFT([2,4,4], -1)\n#F\nClass(MDDFT, TaggedNonTerminal, rec(\n abbrevs := [\n P -> Checked(IsList(P), ForAll(P,IsPosInt), Product(P) > 1,\n [ RemoveOnes(P), 1, false ]),\n (P,k) -> Checked(IsList(P), ForAll(P,IsPosInt), IsInt(k), Product(P) > 1,\n Gcd(Product(P), k)=1,\n [ RemoveOnes(P), k mod Product(P), false ]),\n (P,k,rc) -> Checked(IsList(P), ForAll(P,IsPosInt), IsInt(k), Product(P) > 1,\n Gcd(Product(P), k)=1,\n [ RemoveOnes(P), k mod Product(P), rc ])\n ],\n dims := self >> let(n := Product(self.params[1]), When(self.isReal(), 2*[n,n], [n, n])),\n\n terminate := self >> let(t:=Tensor(List(self.params[1],\n i -> DFT(i, self.params[2]).terminate())),\n When(self.isReal(), MatAMat(RC(t).toAMat()), t)\n ),\n\n transpose := self >> Copy(self),\n\n isReal := self >> self.params[3],\n\n setAB := meth(self, ab)\n self.a := ab[1];\n self.b := ab[2];\n return self;\n end,\n\n normalizedArithCost := (self) >> let(n := Product(self.params[1]),\n IntDouble(5 * n * d_log(n) / d_log(2)) )\n\n#D setpv := meth(self, pv)\n#D local s;\n#D s:= Copy(self);\n#D s.params[3] := pv;\n#D return s;\n#D end,\n\n#D tagpos := 3\n\n));\n\n# check for 1 dimensional MDDFTs and convert them to DFTs\ncatch1d_mddft := ch ->\n List(ch, x -> List(x, t -> When(Length(t.params[1]) > 1, t,\n DFT(Rows(t), t.params[2], t.params[3], t.params[4]))));\n\nNewRulesFor(MDDFT, rec(\n #F RuleMDDFT_Base: MDDFT -> DFT\n #F\n MDDFT_Base := rec(\n info := \"MDDFT -> DFT\",\n applicable := nt -> Length(nt.params[1])=1,\n children := nt -> let(P := nt.params, tags := nt.getTags(), [[ DFT(P[1][1], P[2]).withTags(tags) ]]),\n apply := (nt, C, Nonterms) -> C[1]\n )\n));\n\nNewRulesFor(MDDFT, rec(\n\n #F RuleMDDFT_Tensor: MDDFT(n_1,n_2,...,n_t) = Tensor(DFT_n1, DFT_n2, ..., DFT_nt)\n #F\n MDDFT_Tensor := rec(\n switch := false,\n info :=\"MDDFT_n -> Tensor(DFT_n1,DFT_n2,...DFT_nt)\",\n applicable := nt -> Length(nt.params[1])>1 and not nt.hasTags(),\n children := nt -> [ List(nt.params[1],i->DFT(i, nt.params[2])) ],\n rule := (nt, C, cnt) -> Tensor(C)\n#D isApplicable := P -> Length(P[1])>1 and Length(P[3]) = 0,\n#D allChildren := P -> [ List(P[1],i->DFT(i, P[2])) ],\n#D rule := (P,C) -> Tensor(C)\n ),\n\n #F RuleMDDFT_Dimless\n #F\n #F If N = RxS = n_1xn_2x...n_t and\n #F d1 = n_1* ..*n_(l-1), d2 = n_(l+1)*..*n_t, n_(l) = a*b then,\n #F MDDFT([n_1,..,n_t]) = Tensor(MDDFT([n_1,..,n_(l-1),a]), I(b), I(d2))*\n #F Tensor(I(d1), T(n_(l),b), I(d2))*\n #F Tensor(I(d1), I(a), MDDFT([b,n_(l+1),..,n_t])) *\n #F Tensor(I(d1), L(n_(l),a), I(d2))\n #F\n MDDFT_RowCol := rec (\n info := \"MDDFT_n -> MDDFT_n/d, MDDFT_d\",\n applicable := nt -> Length(nt.params[1]) > 1 and not nt.hasTags(),\n\n children := nt -> let(\n dims := nt.params[1],\n len := Length(dims),\n List([1..len-1],\n i -> [ MDDFT(dims{[1..i]}, nt.params[2]), MDDFT(dims{[i+1..len]}, nt.params[2]) ])),\n\n apply := (nt, C, Nonterms) -> let(\n a := Last(Nonterms[1].params[1]),\n n1 := Rows(Nonterms[1])/a,\n n2 := Rows(Nonterms[2]),\n Tensor(C[1], I(n2)) *\n Tensor(I(n1), Tensor(I(a), C[2]))\n )\n#D isApplicable := P -> Length(P[1]) > 1 and Length(P[3]) = 0,\n#D\n#D allChildren := P -> let(\n#D dims := P[1],\n#D len := Length(dims),\n#D List([1..len-1],\n#D i -> [ MDDFT(dims{[1..i]}, P[2]), MDDFT(dims{[i+1..len]}, P[2]) ])),\n#D\n#D rule := (P,C,Nonterms) -> let(\n#D a := Last(Nonterms[1].params[1]),\n#D n1 := Rows(Nonterms[1])/a,\n#D n2 := Rows(Nonterms[2]),\n#D Tensor(C[1], I(n2)) *\n#D Tensor(I(n1), Tensor(I(a), C[2])))\n ),\n\n MDDFT_Dimless := rec (\n info := \"MDDFT_n -> MDDFT_n/d, MDDFT_d\",\n applicable := nt -> Length(nt.params[1]) > 1 and ForAny(nt.params[1], x->not IsPrime(x)) and not nt.hasTags(),\n\n children := function(nt)\n local ch, dims, len, simple_splits, div_splits;\n dims := nt.params[1];\n len := Length(dims);\n return Concatenation(List([1..len], i -> let(\n left := dims{[1..i-1]},\n right := dims{[i+1..len]},\n List(DivisorPairs(dims[i]), split ->\n [ MDDFT(Concatenation(left, [split[1]]), nt.params[2]),\n MDDFT(Concatenation([split[2]], right), nt.params[2]) ]))));\n end,\n\n apply := (nt, C, Nonterms) -> let(\n a := Last(Nonterms[1].params[1]),\n b := Nonterms[2].params[1][1],\n n1 := Rows(Nonterms[1])/a,\n n2 := Rows(Nonterms[2])/b,\n\n Tensor(Tensor(C[1], I(b)), I(n2)) *\n Diag(diagTensor(fConst(n1,1), Tw1(a*b,b,nt.params[2]), fConst(n2,1))) *\n Tensor(I(n1), Tensor(I(a), C[2])) *\n Tensor(I(n1), L(a*b,a), I(n2))\n )\n#D isApplicable := P -> Length(P[1]) > 1 and ForAny(P[1], x->not IsPrime(x)) and Length(P[3]) = 0,\n#D\n#D allChildren := meth(self,P)\n#D local ch, dims, len, simple_splits, div_splits;\n#D dims := P[1];\n#D len := Length(dims);\n#D return Concatenation(List([1..len], i -> let(\n#D left := dims{[1..i-1]},\n#D right := dims{[i+1..len]},\n#D List(DivisorPairs(dims[i]), split ->\n#D [ MDDFT(Concatenation(left, [split[1]]), P[2]),\n#D MDDFT(Concatenation([split[2]], right), P[2]) ]))));\n#D\n#D end,\n#D\n#D rule := (P,C,Nonterms) -> let(\n#D a := Last(Nonterms[1].params[1]),\n#D b := Nonterms[2].params[1][1],\n#D n1 := Rows(Nonterms[1])/a,\n#D n2 := Rows(Nonterms[2])/b,\n#D\n#D Tensor(Tensor(C[1], I(b)), I(n2)) *\n#D Diag(diagTensor(fConst(n1,1), T(a*b,b), fConst(n2,1))) *\n#D Tensor(I(n1), Tensor(I(a), C[2])) *\n#D Tensor(I(n1), L(a*b,a), I(n2)))\n ),\n\n # 2D Vector Radix\n # NOTE: Put citation\n MDDFT_vrdx2D := rec(\n info := \"MDDFT([mn, rs],k) -> MDDFT([m, r], k%mr), MDDFT([n, s], k%ns)\",\n\n\tswitch := false,\n maxSize := false,\n\n applicable := nt -> Length(nt.params[1]) = 2 and ForAll(nt.params[1], x->not IsPrime(x))\n and not nt.hasTags(),\n\n children := nt -> let(l:=List(nt.params[1], i->DivisorPairs(i)),\n idx:=Cartesian(List([1..Length(l)], i->[1..Length(l[i])])),\n rdx := List(idx, i->List([1..2], j->List([1..2], k->l[k][i[1]][j]))),\n Map2(rdx, (m,n) -> [ MDDFT(m, nt.params[2] mod Product(m)), MDDFT(n, nt.params[2] mod Product(n)) ])\n ),\n\n apply := (nt, C, cnt) -> let(mn := Product(nt.params[1]), m := Rows(C[1]), n := Rows(C[2]),\n Tensor(C[1], I(n)) *\n Diag(Tw1(mn, n, nt.params[2])) *\n Tensor(I(m), C[2]) *\n L(mn, m)\n )\n )\n#D isApplicable := (self,P) >> Length(P[1]) = 2 and ForAll(P[1], x->not IsPrime(x))\n#D and Length(P[3]) = 0,\n#D\n#D allChildren := P -> let(l:=List(P[1], i->DivisorPairs(i)),\n#D idx:=Cartesian(List([1..Length(l)], i->[1..Length(l[i])])),\n#D rdx := List(idx, i->List([1..2], j->List([1..2], k->l[k][i[1]][j]))),\n#D Map2(rdx, (m,n) -> [ MDDFT(m, P[2] mod Product(m)), MDDFT(n, P[2] mod Product(n)) ])\n#D ),\n#D\n#D rule := (P,C) -> let(mn := P[1], m := Rows(C[1]), n := Rows(C[2]),\n#D Tensor(C[1], I(n)) *\n#D T(mn, n, P[2]) *\n#D Tensor(I(m), C[2]) *\n#D L(mn, m))\n#D )\n\n));\n", "meta": {"hexsha": "5a64b1b0ba76e24d7b438c66c342b8ebb81d9f61", "size": 8438, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/dft/multidim.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/dft/multidim.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/dft/multidim.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 37.0087719298, "max_line_length": 118, "alphanum_fraction": 0.472979379, "num_tokens": 2895, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382094310355, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.5995946946209596}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nIsCyclicPerm := x -> IsSPL(x) and IsBound(x.isCyclic) and x.isCyclic;\n\nCyclicPerms := function(e)\n local beg, mid, endd, len, list, i;\n beg := I(Rows(e)); mid := I(Rows(e)); endd := I(Cols(e));\n list := e.children();\n len := Length(list);\n i := 1;\n while i <= Length(list) and IsCyclicPerm(list[i]) do\n beg:=beg*list[i]; i:=i+1; \n od;\n while i <= Length(list) and not IsCyclicPerm(list[i]) do mid:=mid*list[i]; i:=i+1; od;\n while i <= Length(list) and IsCyclicPerm(list[i]) do endd:=endd*list[i]; i:=i+1; od;\n return [beg, mid, endd];\nend;\n \nPullOutCyclicPerms := tensor ->\n SubstTopDownNR(tensor, [Tensor, @(1,Compose), @(2,Compose)],\n\te -> let(p1 := CyclicPerms(@(1).val), \n\t p2 := CyclicPerms(@(2).val),\n\t\t Tensor(p1[1], p2[1]) * Tensor(p1[2], p2[2]) * Tensor(p1[3], p2[3])));\n\n", "meta": {"hexsha": "e1c90ee91c4e46af74f663b9dd2c1edf1d8caf05", "size": 923, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/dft/modperms.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/dft/modperms.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/dft/modperms.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 32.9642857143, "max_line_length": 92, "alphanum_fraction": 0.5817984832, "num_tokens": 324, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.793105951184112, "lm_q2_score": 0.7549149978955811, "lm_q1q2_score": 0.5987275774691267}}
{"text": "# The graph obtained from an adjacency function on the vertex set.\nBindGlobal(\"AdjFunGraph\", function(E, F)\n return Graph(Group(()), E, function(x, y) return x; end, F, true);\nend);\n\n# A generic product graph.\nBindGlobal(\"ProductGraph\", function(Gs, F)\n local G, GG, dp;\n dp := DirectProduct(List(Gs, H -> H.group));\n G := Graph(dp, Cartesian(List(Gs, H -> [1..H.order])),\n OnProduct(Length(Gs), dp), F, true);\n for GG in Gs do\n if not \"names\" in RecNames(GG) then\n GG.names := [1..GG.order];\n fi;\n od;\n AssignVertexNames(G, List(G.names,\n f -> List([1..Length(f)], i -> Gs[i].names[f[i]])));\n return G;\nend);\n\n# The box product of two or more graphs.\nBindGlobal(\"BoxProductGraph\", function(arg)\n local Gs;\n if Length(arg) = 1 then\n Gs := arg[1];\n else\n Gs := arg;\n fi;\n return ProductGraph(Gs, function(x, y)\n local l;\n l := List([1..Length(Gs)], i -> Distance(Gs[i], x[i], y[i]));\n return WeightVecFFE(l) = 1 and Sum(l) = 1;\n end);\nend);\n\n# The cross product of two or more graphs.\nBindGlobal(\"CrossProductGraph\", function(arg)\n local Gs;\n if Length(arg) = 1 then\n Gs := arg[1];\n else\n Gs := arg;\n fi;\n return ProductGraph(Gs, function(x, y)\n local l;\n l := List([1..Length(Gs)], i -> Distance(Gs[i], x[i], y[i]));\n return Minimum(l) = 1 and Maximum(l) = 1;\n end);\nend);\n\n# The strong product of two or more graphs.\nBindGlobal(\"StrongProductGraph\", function(arg)\n local Gs;\n if Length(arg) = 1 then\n Gs := arg[1];\n else\n Gs := arg;\n fi;\n return ProductGraph(Gs, function(x, y)\n return Maximum(List([1..Length(Gs)],\n i -> Distance(Gs[i], x[i], y[i]))) = 1;\n end);\nend);\n\n# The bipartite double of a graph.\nBindGlobal(\"BipartiteDoubleGraph\", function(G)\n local H;\n H := BipartiteDouble(G);\n CheckDualityFunctions(G);\n H.halfDuality := BipartiteDoubleDualityFunction(G.duality);\n H.halfPrimality := BipartiteDoubleDualityFunction(G.primality);\n return H;\nend);\n\n# The extended bipartite double of a graph.\nBindGlobal(\"ExtendedBipartiteDoubleGraph\", function(G)\n local dp, signs, H;\n signs := [\"+\", \"-\"];\n dp := DirectProduct(G.group, SymmetricGroup(2));\n H := Graph(dp, Cartesian(G.representatives, signs),\n OnSignedPoints(dp, signs), function(x, y)\n return x[2] <> y[2] and Distance(G, x[1], y[1]) <= 1;\n end);\n if \"names\" in RecNames(G) then\n AssignVertexNames(H, List(H.names, x -> [G.names[x[1]], x[2]]));\n fi;\n CheckDualityFunctions(G);\n H.halfDuality := BipartiteDoubleDualityFunction(G.duality);\n H.halfPrimality := BipartiteDoubleDualityFunction(G.primality);\n return H;\nend);\n\n# The halved graph of a bipartite graph. The optional second argument\n# allows choosing between the first and second halves.\nBindGlobal(\"HalvedGraph\", function(arg)\n local n, G, G2, H, vs;\n if Length(arg) < 1 then\n Error(\"at least one argument expected\");\n return fail;\n fi;\n G := arg[1];\n if Length(arg) > 1 then\n n := arg[2];\n else\n n := 1;\n fi;\n if not IsConnectedGraph(G) then\n Error(\"not a connected graph\");\n return fail;\n fi;\n if not IsBipartite(G) then\n Error(\"not a bipartite graph\");\n return fail;\n fi;\n G2 := DistanceGraph(G, 2);\n vs := ConnectedComponent(G2, 1);\n if n = 2 then\n vs := Difference([1..G.order], vs);\n fi;\n H := Graph(Stabilizer(G.group, vs, OnSets), vs, OnPoints,\n function(x, y) return Distance(G2, x, y) = 1; end, true);\n if \"names\" in RecNames(G) then\n AssignVertexNames(H, G.names{vs});\n fi;\n if \"halfDuality\" in RecNames(G) then\n if n = 2 then\n H.primality := G.halfDuality;\n else\n H.duality := G.halfDuality;\n fi;\n fi;\n if \"halfPrimality\" in RecNames(G) then\n if n = 2 then\n H.duality := G.halfPrimality;\n else\n H.primality := G.halfPrimality;\n fi;\n fi;\n return H;\nend);\n\n# The antipodal quotient of an antipodal cover.\nBindGlobal(\"AntipodalQuotientGraph\", function(G)\n local d, H;\n if not IsAntipodalCover(G) then\n Error(\"not an antipodal cover\");\n return fail;\n fi;\n d := Diameter(G);\n H := Graph(G.group,\n Set(List(G.representatives, x -> DistanceSet(G, [0, d], x))),\n OnSets, function(x, y)\n return IsSubset(DistanceSet(G, 1, x), y);\n end);\n if \"names\" in RecNames(G) then\n AssignVertexNames(H, List(H.names, f -> G.names{f}));\n fi;\n return H;\nend);\n\n# A graph with the set of d-dimensional subspaces of V filtered by S\n# as the vertex set, acted upon by the matrix group G,\n# with two subspaces being adjacent iff their intersection has dimension d-1.\nBindGlobal(\"SubspaceGraph\", function(arg)\n local G, H, S, V, d, invt, vcs;\n if Length(arg) < 4 then\n Error(\"at least four arguments expected\");\n return fail;\n fi;\n G := arg[1];\n S := arg[2];\n V := arg[3];\n d := arg[4];\n if Length(arg) > 4 then\n invt := arg[5];\n else\n invt := true;\n fi;\n if IsList(S) then\n vcs := S;\n else\n vcs := S(Subspaces(V, d));\n fi;\n H := Graph(G, vcs, OnSubspaces(V), function(x,y)\n return Dimension(Intersection(x,y)) = d-1;\n end, invt);\n H.duality := Intersection;\n H.primality := Sum;\n return H;\nend);\n\n# The clique (dual geometry) graph of a collinearity graph. The optional second\n# argument allows choosing a connected component of the resulting graph.\nBindGlobal(\"CliqueGraph\", function(arg)\n local C, G, H, n;\n if Length(arg) < 1 then\n Error(\"at least one argument expected\");\n return fail;\n fi;\n G := arg[1];\n C := Cliques(G);\n if Length(arg) > 1 then\n n := arg[2];\n if not IsList(n) then\n n := [n];\n fi;\n else\n n := [1..Length(C)];\n fi;\n H := Graph(G.group, C{n}, OnSets,\n function(x, y)\n return Size(Intersection(x,y)) = 1;\n end);\n if \"names\" in RecNames(G) then\n CheckDualityFunctions(G);\n H.duality := G.primality;\n H.primality := G.duality;\n AssignVertexNames(H, List(H.names, f -> G.duality(G.names{f})));\n if \"halfDuality\" in RecNames(G) then\n H.halfDuality := G.halfDuality;\n fi;\n if \"halfPrimality\" in RecNames(G) then\n H.halfPrimality := G.halfPrimality;\n fi;\n fi;\n return H;\nend);\n\n# The incidence graph of a collinearity graph.\nBindGlobal(\"IncidenceGraph\", function(arg)\n local C, G, H, n;\n if Length(arg) < 1 then\n Error(\"at least one argument expected\");\n return fail;\n fi;\n G := arg[1];\n C := Cliques(G);\n if Length(arg) > 1 then\n n := arg[2];\n if not IsList(n) then\n n := [n];\n fi;\n else\n n := [1..Length(C)];\n fi;\n H := Graph(G.group, Union(G.representatives, C{n}),\n OnPointsOrLines(OnPoints, IsList),\n function(x, y)\n return (IsList(y) and x in y) or (IsList(x) and y in x);\n end);\n if \"names\" in RecNames(G) and G.order > 0 then\n CheckDualityFunctions(G);\n if IsList(H.names[1]) then\n H.halfDuality := G.primality;\n H.halfPrimality := G.duality;\n else\n H.halfDuality := G.duality;\n H.halfPrimality := G.primality;\n fi;\n AssignVertexNames(H, List(H.names, function(f)\n if IsList(f) then\n return G.duality(G.names{f});\n else\n return G.names[f];\n fi;\n end));\n fi;\n return H;\nend);\n", "meta": {"hexsha": "23eaf54711f66bfa8d198971c3f3d8ecec31343d", "size": 8019, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "lib/GeneralConstructions.gap", "max_stars_repo_name": "jaanos/gap-graphs", "max_stars_repo_head_hexsha": "18dd56c9b90a12a717a0cc893fdd72c6343ee79b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2015-10-27T15:54:29.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-07T14:09:44.000Z", "max_issues_repo_path": "lib/GeneralConstructions.gap", "max_issues_repo_name": "jaanos/gap-graphs", "max_issues_repo_head_hexsha": "18dd56c9b90a12a717a0cc893fdd72c6343ee79b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-04-20T23:13:11.000Z", "max_issues_repo_issues_event_max_datetime": "2015-04-20T23:13:11.000Z", "max_forks_repo_path": "lib/GeneralConstructions.gap", "max_forks_repo_name": "jaanos/gap-graphs", "max_forks_repo_head_hexsha": "18dd56c9b90a12a717a0cc893fdd72c6343ee79b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.5904059041, "max_line_length": 79, "alphanum_fraction": 0.5480733259, "num_tokens": 2252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511469672594, "lm_q2_score": 0.6992544147913994, "lm_q1q2_score": 0.5984576929211389}}
{"text": "#############################################################################\n##\n#W betti.gi Karel Dekimpe\n#W Bettina Eick\n##\n\n#############################################################################\n##\n## The following functions can be used to determine Betti-numbers of a\n## torsion-free polycyclic group given by a pcp presentation. All \n## Betti-numbers can be obtained if G has Hirsch length at most 5.\n##\n## The Betti-numbers B(G,m) are defined as the ranks of H_m(G,Z) for the\n## trivial G-module Z. If M is the orientation G-module, then we can also\n## characterise B(G,m) for n >= m >= n-2 as the ranks of H^n-m(G,M). \n## Further, the alternating sum of all Betti-numbers is 0 using the\n## Euler characteristic. \n##\n\n#############################################################################\n##\n#F OrientationModule( G )\n##\nInstallMethod( OrientationModule, \"for pcp groups\", true, [IsPcpGroup], 0, \nfunction( G )\n local pcps, gens, mats, acts, dets, i, pcp;\n pcps := PcpsOfEfaSeries( G );\n pcps := Filtered( pcps, x -> RelativeOrdersOfPcp(x)[1] = 0 );\n gens := Igs(G);\n mats := List( gens, x -> IdentityMat( 1 ) );\n for pcp in pcps do\n acts := LinearActionOnPcp( gens, pcp );\n dets := List( acts, x -> Determinant( x ) );\n for i in [1..Length(mats)] do\n mats[i] := dets[i] * mats[i];\n od;\n od;\n return mats;\nend );\n\n#############################################################################\n##\n#F IsOrientedMatGroup( G )\n##\nIsOrientedMatGroup := function( G )\n return ForAll( GeneratorsOfGroup(G), x -> Determinant(x) = 1 );\nend;\n\n#############################################################################\n##\n#F BettiNumber( G, m )\n##\nBettiNumberPcpGroup := function(G,m)\n local n, pcp, mats, CR, one, two;\n\n if not IsTorsionFree( G ) then\n Print(\"the input group must be torsion-free \\n\");\n return fail;\n fi;\n\n # catch the trivial case\n if IsFinite(G) then \n if m = 0 then \n return 1;\n else\n return 0;\n fi;\n fi;\n\n # the hirsch length \n n := HirschLength( G );\n\n if m < 0 or m > n then return 0; fi;\n\n if m = 0 then return 1; fi;\n\n if m = 1 then \n pcp := Pcp( G, DerivedSubgroup(G) );\n return Length( Filtered( RelativeOrdersOfPcp( pcp ),x -> x=0 ));\n fi;\n\n if m = n then\n mats := OrientationModule( G );\n if ForAny( mats, x -> x[1][1] = -1 ) then \n return 0;\n else\n return 1;\n fi;\n fi;\n\n if m = 2 then\n mats := List( Pcp(G), x -> IdentityMat(1) );\n CR := CRRecordByMats( G, mats );\n two := TwoCohomologyCR( CR ).factor.rels;\n return Length( Filtered( two, x -> x = 0 ) );\n fi;\n\n if m = n-1 then\n mats := OrientationModule( G );\n CR := CRRecordByMats( G, mats );\n one := OneCohomologyCR( CR ).factor.rels;\n return Length( Filtered( one, x -> x = 0 ) );\n fi;\n\n if m = n-2 then\n mats := OrientationModule( G );\n CR := CRRecordByMats( G, mats );\n two := TwoCohomologyCR( CR ).factor.rels;\n return Length( Filtered( two, x -> x = 0 ) );\n fi;\n\n Print(\"Betti-number is out of range for our methods \\n\");\n return fail;\nend;\n\nInstallMethod( BettiNumber, \"for torsion-free pcp groups\", true,\n [IsPcpGroup, IsInt], 0,\nfunction(G, m)\n if not IsTorsionFree(G) then TryNextMethod(); fi;\n if m in [3..HirschLength(G)-3] then TryNextMethod(); fi;\n return BettiNumberPcpGroup(G,m);\nend); \n \n#############################################################################\n##\n#F BettiNumbers( G )\n##\nInstallMethod( BettiNumbers, \"for torsion-free pcp groups\", true,\n [IsPcpGroup], 0,\nfunction( G )\n local n, betti;\n\n n := HirschLength( G );\n if not IsTorsionFree( G ) or n > 6 then TryNextMethod(); fi;\n\n # set up the Betti-numbers \n betti := [1];\n if n = 0 then return betti; fi;\n betti[2] := BettiNumber( G, 1 );\n if n = 1 then return betti; fi;\n betti[3] := BettiNumber( G, 2 );\n if n = 2 then return betti; fi;\n betti[4] := betti[1] - betti[2] + betti[3];\n if n = 3 then return betti; fi;\n if n > 3 then \n betti[5] := BettiNumber( G, 4 );\n betti[4] := betti[4] + betti[5];\n fi;\n if n > 4 then \n betti[6] := BettiNumber( G, 5 );\n betti[4] := betti[4] - betti[6];\n fi;\n if n > 5 then \n betti[7] := BettiNumber( G, 6 );\n betti[4] := betti[4] + betti[7];\n fi;\n return betti;\nend );\n\n", "meta": {"hexsha": "3a5b3df14caf896d5775e527e598b17f71bd6089", "size": 4654, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "gap/betti.gi", "max_stars_repo_name": "alex-konovalov/aclib", "max_stars_repo_head_hexsha": "d1afb020805bfd60a8bbb0a9a4adac77fe9b44f1", "max_stars_repo_licenses": ["Artistic-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gap/betti.gi", "max_issues_repo_name": "alex-konovalov/aclib", "max_issues_repo_head_hexsha": "d1afb020805bfd60a8bbb0a9a4adac77fe9b44f1", "max_issues_repo_licenses": ["Artistic-2.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2018-03-07T16:35:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T23:51:07.000Z", "max_forks_repo_path": "gap/betti.gi", "max_forks_repo_name": "alex-konovalov/aclib", "max_forks_repo_head_hexsha": "d1afb020805bfd60a8bbb0a9a4adac77fe9b44f1", "max_forks_repo_licenses": ["Artistic-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-03-10T19:58:42.000Z", "max_forks_repo_forks_event_max_datetime": "2018-03-10T19:58:42.000Z", "avg_line_length": 29.0875, "max_line_length": 77, "alphanum_fraction": 0.4922647185, "num_tokens": 1351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430394931456, "lm_q2_score": 0.7185943925708561, "lm_q1q2_score": 0.597254727604072}}
{"text": "\n## Copyright (c) 2018-2021, Carnegie Mellon University\n## See LICENSE for details\n\nNewRulesFor(DFT, rec(\n\n DFT_PD_loop := rec(\n forTransposition := false,\n minSize := 7,\n maxSize := 13,\n \n TabPerm := r -> let(i:=Ind(r.domain()), f := FData(r.tolist()).at(i), Lambda(i, f).setRange(r.range())),\n \n applicable := (self, nt) >> nt.params[1] > 2 and nt.params[1] in [self.minSize..self.maxSize] and IsPrime(nt.params[1]) and not nt.hasTags(),\n \n apply := (self, nt, C, cnt) >> let(\n N := nt.params[1], \n k := nt.params[2], \n root := PrimitiveRootMod(N),\n M:=(N-1)/2,\n i := Ind(M),\n j := Ind(M),\n k1 := Ind(M+1),\n m := MatSPL(DFT_PD.core(N, k, root, false) * DFT_PD.A(N)),\n m1 := Map(m{[2..(N+1)/2]}, r -> r{[2..(N+1)/2]}),\n m2 := Map(m{[(N+3)/2..N]}, r -> r{[(N+3)/2..N]}),\n d := Flat(m1)::Map(Flat(m2), c->im(ComplexAny(c)).v),\n fd := FData(d),\n \n s := Scat(self.TabPerm(RR(N, 1, root))),\n g := Gath(self.TabPerm(RR(N, 1, 1/root mod N))),\n\n gg := Gath(fCompose(fAdd(N, N-1, 1), fTensor(fId(2), fBase(M, k1-1)))),\n f2 := F(2),\n u := Ind(2),\n uf := Lambda(u, fd.at(u*M*M + M*i+(k1-1))),\n bb := DirectSum(Blk1(uf.at(0)), Scale(ImaginaryUnit(), Blk1(uf.at(1)))),\n \n krn0 := Mat([[1],[0]]) * Gath(fAdd(N, 1, 0)),\n krnn := bb * f2 * gg,\n krn := ScatAcc(fId(2)) * f2 * COND(eq(k1,0), krn0, krnn),\n \n q1 := L(2*M, 2) * IterVStack(i, ISumAcc(k1, krn)),\n #q2 := RowVec(fConst(13,V(1.0))),\n _i := Ind(N),\n q2 := ISumAcc(_i, ScatAcc(fAdd(1,1,0)) * Blk([[1]]) * COND(eq(_i, 0), Gath(fAdd(13,1,0)), Gath(fAdd(13,1,_i)))), \n q3 := VStack(q2, q1 * g),\n qq := s * q3, \n qq\n )\n )\n));\n\nRulesFor(PRDFT, rec(\n PRDFT_PD_loop := rec(\n\tforTransposition := false,\n minSize := 7,\n\tmaxSize := 13,\n\tisApplicable := (self, P) >> P[1] > 2 and P[1] in [self.minSize..self.maxSize] and IsPrime(P[1]),\n\t\n\trule := (self,P,C) >> let(N:=P[1], n:=N-1, k:=P[2], root:=PrimitiveRootMod(N),\n M:=n/2,\n i := Ind(M),\n j := Ind(M),\n k1 := Ind(M+1),\n m := MatSPL(DFT_PD.core(N, k, root, false) * DFT_PD.A(N)),\n m1 := Map(m{[2..(N+1)/2]}, r -> r{[2..(N+1)/2]}),\n m2 := Map(m{[(N+3)/2..N]}, r -> r{[(N+3)/2..N]}),\n d := Flat(m1)::Map(Flat(m2), c->im(ComplexAny(c)).v),\n fd := FData(d),\n #lfd1 := Lambda(j, fd.at(M*i+j)),\n #lfd1 := Lambda(k1, cond(eq(k1, V(0)), V(1.0), fd.at(M*i+(k1-V(1))))),\n #lfd2 := Lambda(j, fd.at(M*M+M*i+j)),\n \n gf := DFT_PD_loop.TabPerm(RR(N, 1, root)),\n g := Gath(gf),\n \n #kk1 := DirectSum(RowVec(lfd1), RowVec(lfd2)) * DirectSum(I(1), Tensor(F(2), I(M)) * OS(n, -1)),\n #q1 := IterVStack(i, BB(kk1)),\n \n #lbd := OS(12, -1).lambda(),\n _j := Ind(n),\n lbd := Lambda(_j, imod(V(n)-_j, V(n))),\n gg := Gath(fCompose(fAdd(N, N-1, 1), fCompose(lbd, fTensor(fId(2), fBase(M, k1-1))))),\n\n f2 := F(2),\n u := Ind(2),\n uf := Lambda(u, fd.at(u*M*M + M*i+(k1-1))),\n bb := DirectSum(Blk1(uf.at(0)), Blk1(uf.at(1))),\n\n krn0 := Mat([[1],[0]]) * Gath(fAdd(N, 1, 0)),\n krnn := bb * f2 * gg,\n krn := Grp(ScatAcc(fId(2))) * COND(eq(k1,0), krn0, krnn),\n\n q1 := IterVStack(i, ISumAcc(k1, krn)),\n q2a := RowVec(fConst(13,V(1.0))),\n# _i := Ind(N),\n# q2a := ISumAcc(_i, ScatAcc(fAdd(1,1,0)) * Blk([[1]]) * COND(eq(_i, 0), Gath(fAdd(13,1,0)), Gath(fAdd(13,1,_i)))), \n q2b := RowVec(fConst(13,V(0.0))),\n q3 := VStack(BB(VStack(q2a, q2b)), q1),\n sf := DFT_PD_loop.TabPerm(Refl((N+1)/2, N, (N+1)/2, RR(N,1,root))),\n s := Scat(fTensor(sf, fId(2))),\n \n u1 := Ind(N+1),\n df := Lambda(u1, cond(logic_and(eq(V(1), bin_and(u1, 1)), geq(gf.at(idiv(u1, 2)), (N+1)/2)), V(-1), V(1))),\n dfl := df.tolist(),\n m1s := Filtered([0..N], _i->dfl[_i+1] = V(-1)),\n m1eq := List(m1s, _i->eq(u1, V(_i))),\n cnd := ApplyFunc(logic_or, m1eq),\n lbdcnd := Lambda(u1, cond(cnd, V(-1), V(1))),\n diag := Diag(lbdcnd),\n sct := s * diag,\n qq := sct * q3 * g,\n qq\n )\n)));\n\n\nRulesFor(IPRDFT, rec(\n IPRDFT_PD_loop := rec(\n\tforTransposition := false,\n minSize := 7,\n\tmaxSize := 13,\n\tisApplicable := (self, P) >> P[1] > 2 and P[1] in [self.minSize..self.maxSize] and IsPrime(P[1]),\n\t\n\trule := (self,P,C) >> let(N:=P[1], n:=N-1, k:=P[2], root:=PrimitiveRootMod(N), M:=n/2,\n # loop variables\n ii := Ind(M),\n k1 := Ind(M+1),\n u := Ind(2),\n # scatter\n fstr := fDirsum(fId(1), L(n, n/2)),\n fos := fDirsum(fId(2), J(N-2)),\n frr := RR(N, 1, root),\n fsct := fCompose(frr, fos, fstr),\n fl := fsct.tolist(){[2..N]},\n flst := FList(N-1, fl),\n fst := DFT_PD_loop.TabPerm(flst),\n i := Ind(N),\n flbd := Lambda(i, cond(eq(i, V(0)), V(0), fst.at(i-V(1)))).setRange(N),\n sct := Scat(flbd),\n # diagonal sign flip and block matrix\n rr := RealRR_Out(N, root).transpose(),\n dd := rr.child(1),\n mc := TransposedSPL(DFT_PD.core(N, k, root, false) * DFT_PD.A(N)) * DirectSum(Mat([[1,0]]), 2*I(n)),\n dd2 := DirectSum(I(2), L(n, 2)) * dd * DirectSum(I(2), L(n, n/2)),\n m := MatSPL(mc * dd2),\n m1 := Map(m{[2..(N+1)/2]}, r -> r{[3..(N+1)/2+1]}),\n m2 := Map(m{[(N+3)/2..N]}, r -> Map(r{[(N+3)/2+1..N+1]}, c->-im(ComplexAny(c)).v)),\n d := Flat(m1)::Flat(m2),\n fd := FData(d),\n # gather\n gth := rr.child(2),\n gf := gth.func,\n gfl := gf.tolist(){2*[1..(N-1)/2]+1},\n gst := FList((N-1)/2, gfl),\n gftb := DFT_PD_loop.TabPerm(gst).setRange(N+1),\n glbd := Lambda(u, gftb.at(k1-1) + u).setRange(N+1),\n gath := Gath(glbd),\n # kernel\n uf := Lambda(u, fd.at(u*M*M + M*ii+(k1-1))),\n bb := DirectSum(Blk1(uf.at(0)), Blk1(uf.at(1))),\n f2 := F(2),\n krn0 := f2 * Mat([[1],[0]]) * Gath(fAdd(N+1, 1, 0)),\n krnn := f2 * bb * gath,\n krn := Grp(ScatAcc(fId(2))) * COND(eq(k1,0), krn0, krnn),\n # stack\n q1 := IterVStack(ii, ISumAcc(k1, krn)),\n r1 := RowVec(diagDirsum(fConst(1,V(1.0)), fConst(n/2,V(2.0)))) * Gath(fTensor(fId((N+1)/2), fBase(2, 0))),\n qq := VStack(r1, q1),\n qq1 := sct * qq,\n qq1\n ))\n));\n\n\n", "meta": {"hexsha": "568d869679c0cf962a42cdb590b96e88420e7435", "size": 6716, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "breakdown/dft_pd_loop.gi", "max_stars_repo_name": "franzfranchetti/spiral-package-fftx", "max_stars_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-15T12:40:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-15T12:40:19.000Z", "max_issues_repo_path": "breakdown/dft_pd_loop.gi", "max_issues_repo_name": "franzfranchetti/spiral-package-fftx", "max_issues_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2021-01-05T20:58:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-18T20:10:45.000Z", "max_forks_repo_path": "breakdown/dft_pd_loop.gi", "max_forks_repo_name": "franzfranchetti/spiral-package-fftx", "max_forks_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-12-14T18:24:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T12:40:20.000Z", "avg_line_length": 37.9435028249, "max_line_length": 153, "alphanum_fraction": 0.4444609887, "num_tokens": 2531, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314677809303, "lm_q2_score": 0.6723316860482763, "lm_q1q2_score": 0.5954380979505626}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n##################################\n# I currently have a streaming algorithm (from Nikara et al.) for two variations of DCT-2.\n#\n# First, we have Spiral's standard DCT-2. This is called TDCT2, defined: \n# [ cos(k*(l+1/2)*pi/n) | k,l = 0...n-1 ] \n#\n# Then, I have added a scaled version, defined:\n# [ Diag(1/sqrt(2), 1, 1, ... ] * [ cos(k*(l+1/2)*pi/n) | k,l = 0...n-1 ]\n# which matches the definition in the Nikara paper.\n\n# We use essentially the same algorithm for both; the only change is in one diagonal.\n\n# Using opts := InitStreamUnrollHw(); will enable these rules.\n\n# Other DCT-2 definitions also have a sqrt(2/n) scaling factor in front of the whole matrix.\n\n###########################\n\nDeclare(Sc_DCT2_func);\n\n\n\n#F Sc_DCT2(<n>) - Scaled Discrete Cosine Transform, Type II, non-terminal\n#F Definition: (n x n)-matrix [ Diag(1/sqrt(2), 1, 1, ... ] * [ cos(k*(l+1/2)*pi/n) | k,l = 0...n-1 ]\n#F Example: DCT2(8)\nClass(Sc_DCT2, TaggedNonTerminal, rec(\n\n abbrevs := [\n (n) -> Checked(IsPosIntSym(n),\n [_unwrap(n)]),\n ],\n\n hashAs := self >> ObjId(self)(self.params[1], 1).withTags(self.getTags()),\n\n dims := self >> [ self.params[1], self.params[1] ],\n\n isReal := self >> true,\n\n terminate := self >> Mat(Sc_DCT2_func(self.params[1])),\n transpose := self >> Mat(TransposedMat(Sc_DCT2_func(self.params[1]))),\n));\n\n\n\n\n# hadamard_func(n,i): n-point Hadamard permutation, position i. \n# Defined as in:\n# Z. Wang, Pruning the fast discrete Cosine transform, IEEE \n# Tr. Communications 39(5), May 1991, 640-643.\nhadamard_func := function(n,i)\n if ((n=1) and (i=0)) then return 0; fi;\n if (imod(n,2) <> 0) then return -1; fi; # ERROR\n if (imod(i,2) = 0) then return hadamard_func(n/2, i/2); fi;\n\n return n-1-hadamard_func(n/2, (i-1)/2);\n\nend;\n\n# An Exp wrapper for hadamard_func. Used so Spiral does not try to evaluate the expression \n# until Process_fPrecompute is called.\n\nClass(hadamard_func_exp, Exp, rec(\n ev := self >> hadamard_func(self.args[1].ev(), self.args[2].ev())\n));\n\n# Had(n): Hadamard permutation on n points.\n# See:\n# Z. Wang, Pruning the fast discrete Cosine transform, IEEE \n# Tr. Communications 39(5), May 1991, 640-643.\nClass(Had, PermClass, rec(\n# exportSymbol := self>>self.name,\n# exportParams := self>>self.params,\n# export := Sym.export,\n\n def := (n) -> Checked(\n IsPosIntSym(n),\n rec(size := n)),\n\n lambda := self >> let(\n n := self.params[1], i := Ind(n),\n lt := List([0..n-1], it->hadamard_func(n,it)),\n FList(TInt, lt).lambda()\n ),\n\n transpose := self >> Error(\"Transpoed Hadamard permutation not currently supported.\"),\n\n # Only symmetric for size 2.\n isSymmetric := self >> (self.params[1] = 2)\n));\n\n\n# Don't think I need this anymore.\n# tSPL Hadamard permutation on n points\n# See:\n# Z. Wang, Pruning the fast discrete Cosine transform, IEEE \n# Tr. Communications 39(5), May 1991, 640-643.\nClass(THad, Tagged_tSPL_Container, rec(\n abbrevs := [ size -> [size] ],\n\n dims := self >> Replicate(2, self.params[1]),\n\n terminate := self >> Had(self.params[1]),\n transpose := self >> Error(\"Transposed Hadamard permutation not currently supported.\"),\n isReal := self >> true,\n isSymmetric := self >> self.params[1] = 2,\n\n # We can verify this with:\n # PermMatrixToBits(MatSPL(Had(n)))\n permBits := self >> let(n:=self.params[1], logn:=Log2Int(n),\n (MatSPL(DirectSum(J(logn-1), O(1,1))) + MatSPL(J(logn))) * \n GF(2).one\n )\n\n));\n\n\n########################################\n## The following are helper functions used in the streaming DCT2\n## diagonal given in\n## Nikara et al., Discrete cosine and sine transforms--regular \n## algorithms and pipeline architectures, Signal Processing 86, \n## 2006.\n\nmu := (s,i) -> Cond(imod(i,2^s)=0, 0, 1);\ntau := (i,s) -> Cond(s=i, 0, 1);\n\nClass(mu_exp, Exp, rec(\n ev := self >> mu(self.args[1].ev(), self.args[2].ev())\n));\n\nClass(tau_exp, Exp, rec(\n ev := self >> tau(self.args[1].ev(), self.args[2].ev())\n));\n\ndct_diag_f := (k,i,s) -> (imod(i,2) + (1-tau_exp(0,i)) * (1-tau_exp(k-1,s)));\n\n\n#dct_diag_d := i -> let(K := 2^(Log2Int(i)), t := i-K,\n# h := hadamard_func(K, t),\n# cospi((h+1/2)/(2*K)));\n\ndct_diag_d := i -> let(K := 2^(floor(fdiv(log(i), log(2)))), t := i-K,\n h := hadamard_func_exp(K, t),\n cospi(fdiv((h+1/2), (2*K))));\n\ndct_sc_diag_g := (k,i,s) -> ((2^(mu_exp(s, floor(fdiv(i,2))))) * \n (dct_diag_d(2^(k-s-1) + floor(fdiv(i, (2^(s+1)))))))^dct_diag_f(k,i,s);\n\ndct_unsc_diag_g := (k,i,s) -> ((2^(mu_exp(s, floor(fdiv(i,2))))) * \n (dct_diag_d(2^(k-s-1) + floor(fdiv(i, (2^(s+1)))))))^imod(i,2);\n\n## This represents the diagonal matrix used in the streaming\n## DCT2 algorithm. The problem is of size 2^k, and s represents \n## the iteration\n#Str_DCT2_Diag := (k, s) -> Diag(List([0..((2^k)-1)], \n# i-> dct_diag_g(k, i, s)));\n\nClass(Str_Sc_DCT2_Diag, DiagFunc, rec(\n abbrevs := [(k, s) -> [k, s]],\n def := (k, s) -> rec(size := 2^k),\n lambda := self >> let(k := self.params[1], s := self.params[2], i := Ind(2^k), Lambda(i, dct_sc_diag_g(k, i, s))),\n range := self >> TReal,\n));\n\nClass(Str_DCT2_Diag, DiagFunc, rec(\n abbrevs := [(k, s) -> [k, s]],\n def := (k, s) -> rec(size := 2^k),\n lambda := self >> let(k := self.params[1], s := self.params[2], i := Ind(2^k), Lambda(i, dct_unsc_diag_g(k, i, s))),\n range := self >> TReal,\n));\n\nClass(Str_DCT2_Perm, PermClass, rec(\n def := (k) -> Checked(\n IsPosIntSym(k),\n rec(size := 2^k)),\n\n # Sigh, this is broken it seems.\n lambda := self >> let(\n k := self.params[1],\n\tfCompose(Reversed(List([0..(k-2)], i-> let(rsize := 2^k - 2^(k-i),\n\n fCompose(\n\t\tfTensor(fId(2^i), L(2^(k-i), 2^(k-i-1))),\n\t\tfDirsum(fId(2^(k-i)), fTensor(fId(rsize/4), fDirsum(fId(2), J(2))))\t\t\n\t )\n\n\t)))).lambda()),\n\n transpose := self >> self,\n isSymmetric := self >> true,\n\n));\n\n\nClass(Str_DCT2_Perm_tspl, TaggedNonTerminal, rec(\n\n abbrevs := [(k) -> [k]],\n\n dims := self >> [ 2^self.params[1], 2^self.params[1] ],\n\n terminate := self >> let(k := self.params[1],\n\t Compose(List([0..(k-2)], i-> let(rsize := 2^k - 2^(k-i),\n DirectSum(I(2^(k-i)), \n Tensor(I(rsize/4), DirectSum(I(2), J(2)))\n ) * \n Tensor(I(2^i), L(2^(k-i), 2^(k-i-1)))\n\t )\n )) \n ),\n\n isReal := self >> true,\n\n print := meth(self, indent, indentStep)\n local lparams, mparams;\n if not IsBound(self.params) then Print(self.name); return; fi;\n Print(self.name, \"(\");\n if IsList(self.params) then\n lparams := Filtered(self.params, i->not (IsList(i) and i=[]));\n mparams := Filtered(lparams, i->not (IsBool(i) and not i));\n DoForAllButLast(mparams, x -> Print(x, \", \"));\n Print(Last(mparams));\n else\n Print(self.params);\n fi;\n Print(\")\", When(self.transposed, \".transpose()\", \"\"));\n end,\n\n));\n\nStr_DCT2_M := (n,s) -> let(l := Ind(n/2), TTensorInd(COND(eq(imod(l, 2^s), 0), I(2), Mat([[1,0],[-1,1]])), l, APar, APar));\n\nStr_DCT2_H := (n,s) -> let(k := Log2Int(n), l := Ind(n/4), Cond(s=0, I(n), TTensorInd(COND(eq(imod(l, 2^(s-1)),0), I(4), Mat([[1,0,0,0],[0,0,0,1],[0,0,1,0],[0,1,0,0]])), l, APar, APar)));\n\n#Sc_DCT2_func := (N) -> List([0..N-1], m-> List([0..N-1], n-> ((Sqrt(2/N) * Cond(m=0, 1/Sqrt(2), 1) * CosPi(m*(n+1/2)/N)))));\nSc_DCT2_func := (N) -> List([0..N-1], m-> List([0..N-1], n-> (Cond(m=0, 1/Sqrt(2), 1) * CosPi(m*(n+1/2)/N))));\n\nNewRulesFor(Sc_DCT2, rec(\n Sc_DCT2_Stream := rec(\n forTransposition := false,\n applicable := (self, nt) >> nt.params[1] > 4 and nt.isTag(1, AStream) and nt.firstTag().bs >= 4,\n children := (self, t) >> let(\n n := t.params[1],\n k := Log2Int(n),\n [[ TCompose(Concatenation(\n [TPrm(Str_DCT2_Perm(k))],\n Reversed(List([1..k-1], s-> TCompose([Str_DCT2_M(n, s), TDiag(fPrecompute(Str_Sc_DCT2_Diag(k, s))), Str_DCT2_H(n, s), TTensorI(F(2), n/2, APar, APar), TTensorI(TPrm(L(2^(s+1), 2^s)), 2^(k-s-1), APar, APar),\n#TL(2^(s+1), 2^s, 2^(k-s-1), 1)\n]))),\n [TDiag(fPrecompute(Str_Sc_DCT2_Diag(k, 0))), TTensorI(F(2), n/2, APar, APar), TPrm(Had(n))])).withTags(t.getTags())\n ]]\n ),\n\n apply := (t,c,nt) -> c[1],\n )\n));\n\nNewRulesFor(TDCT2, rec(\n DCT2_Stream := rec(\n forTransposition := false,\n applicable := (self, nt) >> nt.params[1] > 4 and nt.isTag(1, AStream) and nt.firstTag().bs >= 4,\n children := (self, t) >> let(\n n := t.params[1],\n k := Log2Int(n),\n [[ TCompose(Concatenation(\n [Cond(t.firstTag().bs = t.params[1],\n\t\t\t TPrm(Str_DCT2_Perm(k)),\n\t\t\t TPrm(Str_DCT2_Perm_tspl(k))\n\t\t )\n\t\t ],\n Reversed(List([1..k-1], s-> TCompose([Str_DCT2_M(n, s), TDiag(fPrecompute(Str_DCT2_Diag(k, s))), Str_DCT2_H(n, s), TTensorI(F(2), n/2, APar, APar), TTensorI(TPrm(L(2^(s+1), 2^s)), 2^(k-s-1), APar, APar),\n]))),\n [TDiag(fPrecompute(Str_DCT2_Diag(k, 0))), TTensorI(F(2), n/2, APar, APar), TPrm(Had(n))])).withTags(t.getTags())\n ]]\n ),\n\n apply := (t,c,nt) -> c[1],\n )\n));\n\n", "meta": {"hexsha": "467fbe58f95a8f0dd7f2c09dc2a63bc20b6f8717", "size": 9394, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/stream/dct.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/stream/dct.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/stream/dct.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 32.9614035088, "max_line_length": 224, "alphanum_fraction": 0.5499254844, "num_tokens": 3262, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430478583168, "lm_q2_score": 0.7154239957834733, "lm_q1q2_score": 0.5946196803664516}}
{"text": "\n\nInstallMethod(ParabolicSystem,\n \"Roots of standard parabolic\",\n [IsRootSystem,IsList],\n function(R,I)\n local P,graph,order,i_levels;\n P:=Objectify(NewType(NewFamily(\"ParabolicSystemFamily\"),\n IsAttributeStoringRep and\n IsParabolicSystem),\n rec());\n SetUnderlyingRootSystem(P,R);\n SetSupportRoots(P,I);\n SetRadicalRoots(P,Filtered(positiveRoots(R),i->InRadical(P,i)));\n SetiRadicalRoots(P,List(RadicalRoots(P),i->Position(positiveRoots(R),i)));\n SetHeight(P,Maximum(List([1..Length(positiveRoots(R))],i->RootHeight(P,i))));\n SetLevels(P,List([1..Height(P)],i->Filtered(positiveRoots(R),j->RootHeight(P,j)=i)));\n i_levels:=List([1..Height(P)],i->Filtered([1..Length(positiveRoots(R))],j->RootHeight(P,positiveRoots(R)[j])=i));\n SetiLevels(P,i_levels);\n i_levels:=Concatenation(i_levels);\n Set0Level(P,Filtered([1..Length(positiveRoots(R))],i->not i in i_levels));\n SetShapes(P,Set(List(positiveRoots(R),i->Shape(P,i))));\n SetLeviModules(P,List(Levels(P),i->Set(List(i,j->LeviModule(P,j)))));\n SetiLeviModules(P,List(iLevels(P),i->Set(List(i,j->iLeviModule(P,j)))));\n SetName(P,Concatenation(\"<parabolic of \",\n SemiSimpleType(UnderlyingLieAlgebra(R)),\n \" root system with support in \",\n String(I),\">\"));\n\n order:=function(P)\n local levels,result,lung,i;\n levels:=Concatenation(iLevels(P));\n lung:=Length(levels);\n result:=List([1..lung],i->0);\n for i in [1..lung] do\n result[levels[i]]:=i;\n od;\n return result;\n end;\n\n SetOrdering(P,order(P));\n\n# SetRootGraph(P,graph(P));\n \n return P;\nend);\n\nInstallMethod(Shape,\n \"Shape of root\",\n [IsParabolicSystem,IsList],\n function(P,root_coeffs)\n local I;\n if not root_coeffs in positiveRoots(UnderlyingRootSystem(P)) then Error(\"Vector not in root system. \"); fi;\n I:=SupportRoots(P);\n return root_coeffs{Filtered([1..Length(root_coeffs)],i->not i in I)};\nend);\n\nInstallMethod(Shape,\n \"Shape of root\",\n [IsParabolicSystem,IsPosInt],\n function(P,root_index)\n if not root_index in [1..Length(positiveRoots(UnderlyingRootSystem(P)))] then Error(\"Not a root index. \"); fi;\n return Shape(P,positiveRoots(UnderlyingRootSystem(P))[root_index]);\nend);\n\nInstallMethod(LeviModule,\n \"Levi module (vectors) for root vector\",\n [IsParabolicSystem,IsList],\n function(P,root_coeffs)\n local I,s;\n if not root_coeffs in positiveRoots(UnderlyingRootSystem(P)) then Error(\"Vector not in root system. \"); fi;\n I:=SupportRoots(P);\n s:=Shape(P,root_coeffs);\n return Filtered(positiveRoots(UnderlyingRootSystem(P)),i->Shape(P,i)=s);\nend);\n\nInstallMethod(LeviModule,\n \"Levi module (vectors) for root index\",\n [IsParabolicSystem,IsPosInt],\n function(P,root_index)\n if not root_index in [1..Length(positiveRoots(UnderlyingRootSystem(P)))] then Error(\"Not a root index. \"); fi;\n return LeviModule(P,positiveRoots(UnderlyingRootSystem(P)[root_index]));\nend);\n\nInstallMethod(iLeviModule,\n \"Levi module (vectors) for root vector\",\n [IsParabolicSystem,IsList],\n function(P,root_coeffs)\n local I,s;\n if not root_coeffs in positiveRoots(UnderlyingRootSystem(P)) then Error(\"Vector not in root system. \"); fi;\n I:=SupportRoots(P);\n s:=Shape(P,root_coeffs);\n return Filtered([1..Length(positiveRoots(UnderlyingRootSystem(P)))],i->Shape(P,i)=s);\nend);\n\nInstallMethod(iLeviModule,\n \"Levi module (indices) for root vector\",\n [IsParabolicSystem,IsPosInt],\n function(P,root_index)\n if not root_index in [1..Length(positiveRoots(UnderlyingRootSystem(P)))] then Error(\"Not a root index. \"); fi;\n return iLeviModule(P,positiveRoots(UnderlyingRootSystem(P))[root_index]);\nend);\n\nInstallMethod(LeviModules,\n \"Levi modules at a given height\",\n [IsParabolicSystem,IsPosInt],\n function(P,i)\n if i > Height(P) then return []; fi;\n return Filtered(LeviModules(P),j->RootHeight(P,j[1])=i);\nend);\n\nInstallMethod(iLeviModules,\n \"Levi modules at a given height\",\n [IsParabolicSystem,IsPosInt],\n function(P,i)\n if i > Height(P) then return []; fi;\n return Filtered(iLeviModules(P),j->RootHeight(P,j[1])=i);\nend);\n\nInstallMethod(RootHeight,\n \"the level of a root\",\n [IsParabolicSystem,IsList],\n function(P,root_coeffs)\n return Sum(Shape(P,root_coeffs));\nend);\n\nInstallMethod(RootHeight,\n \"the level of a root\",\n [IsParabolicSystem,IsPosInt],\n function(P,root_index)\n return Sum(Shape(P,root_index));\nend);\n\nInstallMethod(Level,\n \"roots at level\",\n [IsParabolicSystem,IsPosInt],\n function(P,i)\n if i > Height(P) then return []; fi;\n return Levels(P)[i];\nend);\n\nInstallMethod(InRadical,\n \"Check for root in radical\",\n [IsParabolicSystem,IsList],\n function(P,root_coeffs)\n if not root_coeffs in positiveRoots(UnderlyingRootSystem(P)) then Error(\"Vector not in root system. \"); fi;\n return Length(Filtered([1..Length(root_coeffs)],i->not i in SupportRoots(P) and root_coeffs[i]<>0))>0;\nend);\n", "meta": {"hexsha": "1ea811643f326227ed89d13ca22255fa47b534a5", "size": 6199, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/psys.gi", "max_stars_repo_name": "iuliansimion/Chevalley.gap", "max_stars_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/psys.gi", "max_issues_repo_name": "iuliansimion/Chevalley.gap", "max_issues_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/psys.gi", "max_forks_repo_name": "iuliansimion/Chevalley.gap", "max_forks_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 41.6040268456, "max_line_length": 127, "alphanum_fraction": 0.5536376835, "num_tokens": 1438, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199633332891, "lm_q2_score": 0.7090191214879991, "lm_q1q2_score": 0.5938885705433786}}
{"text": "\n## Copyright (c) 2018-2021, Carnegie Mellon University\n## See LICENSE for details\n\nDeclare(PrunedMDPRDFT);\nDeclare(PrunedIMDPRDFT);\n\n# Same as (floor(n_t/2)+1)*2.\n# RClength := (n) -> (n + 1) mod 2 + n + 1;\nRClength := (n) -> PRDFT1(n).dims()[1];\n\nIJmatrix := (n) -> DirectSum(I(1), J(n-1));\n\ntensorIJmatrix := (l) -> When(Length(l) > 0,\n Tensor(IJmatrix(l[1]), tensorIJmatrix(Drop(l, 1))),\n Diag([1, -1]));\n\n# Distinct(list) means the elements of list are distinct.\nDistinct := (l) -> (Length(l) = Length(Set(l)));\n\n# pairup takes two lists of the same length,\n# returns list of ordered pairs with elements of first and second.\npairup := (l1, l2) -> When(Length(l1)=0,\n [],\n Concat([ [l1[1], l2[1]] ],\n pairup(Drop(l1, 1),\n Drop(l2, 1))));\n\n\n#F PrunedMDPRDFT(<dims>, <pat>, [<exp>=1])\n#F Pruned multi-dimensional PRDFT (packed real DFT) non-terminal\n#F dims = [ <n_1>, ..., <n_t> ] list of (positive) dimensions\n#F pat = [ <l_1>, ..., <l_t> ] lists l_i having distinct elements in 0..n_i\n#F exp = root of unity exponent scaling (see DFT for exact definition)\n#F\n#F Definition : multidimensional matrix of size M x N, where\n#F M = n_1*...*n_{t-1}*(floor(n_t/2)+1)*2\n#F N = Length(l_1)*..*Length(l_t)\n#F This matrix has real components, for an operator with\n#F N real inputs,\n#F M real outputs for interleaved real and imaginary components.\n#F\n#F Example (direct) : MDPRDFT([4,5,6], [[0..3], [2..4], [5, 3, 1]])\n#F Example (inverse) : MDPRDFT([4,5,6], [[0..3], [2..4], [5, 3, 1]], -1)\n#F\n#F In last dimension, t: real-to-complex DFT;\n#F then dimensions t-1, ..., 1: complex-to-complex DFT.\n#F\n\n# To verify that components of m are real:\n# Im(MatSPL(m)) = MatSPL(ApplyFunc(O, m.dims()));\n\nClass(PrunedMDPRDFT, TaggedNonTerminal, rec(\n a_lengths := self >> self.params[1],\n a_pat := self >> self.params[2],\n a_exp := self >> self.params[3],\n\n abbrevs := [\n (L, pat) -> Checked(IsList(L),\n ForAll(L, IsPosInt),\n ForAll(L, e->e > 1),\n IsList(pat),\n Length(pat) = Length(L),\n ForAll(pat, IsList),\n # Elements of pat[d] are distinct and in 0..L[d]-1.\n ForAll(pat, Distinct),\n Minimum(List(pat, Minimum)) >= 0,\n ForAll(L - List(pat, Maximum), IsPosInt),\n [ L, pat, 1 ]),\n (L, pat, k) -> Checked(IsList(L),\n ForAll(L, IsPosInt),\n ForAll(L, e->e > 1),\n IsList(pat),\n Length(pat) = Length(L),\n ForAll(pat, IsList),\n ForAll(pat, Distinct),\n # Elements of pat[d] are distinct and in 0..L[d]-1.\n Minimum(List(pat, Minimum)) >= 0,\n ForAll(L - List(pat, Maximum), IsPosInt),\n IsInt(k),\n Gcd(Product(L), k) = 1,\n [ L, pat, k mod Product(L) ])\n ],\n\n # dims() has 2 components, counting outputs and inputs:\n # dims()[1] is product of all but last dimension, and RClength on last.\n # dims()[2] is product of all lengths of pattern components.\n dims := self >> let(a_lengths := self.a_lengths(),\n a_pat := self.a_pat(),\n [Product(DropLast(a_lengths, 1)) *\n RClength(Last(a_lengths)),\n Product(List(a_pat, Length))\n ]),\n\n # Just pad pat[d] with zeroes to fill 0..lengths[d]-1,\n # and then call MDPRDFT. But would that be too simple?\n # It's the terminate function, not a Rule, so maybe OK?\nterminate := self >> let(\n a_lengths := self.a_lengths(),\n a_pats := self.a_pat(),\n a_exp := self.a_exp(),\n mdprdft := MDPRDFT(a_lengths, a_exp),\n lenpatpairs := pairup(a_lengths, a_pats),\n lv := List(lenpatpairs, lp->HStack(List(lp[2], e->Scat(fBase(lp[1], e))))),\n tlv := mdprdft * Tensor(lv),\n tlv),\n\n transpose := self >> PrunedIMDPRDFT(self.a_lengths(), self.a_pat(), -self.a_exp()),\n\n isReal := True,\n\n normalizedArithCost := (self) >> let(n := Product(self.a_lengths()),\n IntDouble(2 * n * d_log(n) / d_log(2)) )\n));\n\n\n\n#F PrunedIMDPRDFT(<dims>, <pat>, [<exp>=1])\n#F Pruned multi-dimensional inverse PRDFT (packed real DFT) non-terminal\n#F dims = [ <n_1>, ..., <n_t> ] list of (positive) dimensions\n#F pat = [ <l_1>, ..., <l_t> ] lists l_i having distinct elements in 0..n_i\n#F exp = root of unity exponent scaling (see DFT for exact definition)\n#F\n#F Definition : multidimensional matrix of size N x M, where\n#F N = Length(l_1)*..*Length(l_t)\n#F M = n_1*...*n_{t-1}*(floor(n_t/2)+1)*2\n#F This matrix has real components, for an operator with\n#F M real inputs for interleaved real and imaginary components,\n#F N real outputs.\n#F\n#F Example (direct) : IMDPRDFT([4,5,6], [[0..3], [2..4], [5, 3, 1]])\n#F Example (inverse) : IMDPRDFT([4,5,6], [[0..3], [2..4], [5, 3, 1]], -1)\n#F\n#F In dimensions 1, ..., t-1: complex-to-complex DFT;\n#F then in last dimension, t: complex-to-real DFT.\n#F\n\nClass(PrunedIMDPRDFT, TaggedNonTerminal, rec(\n a_lengths := self >> self.params[1],\n a_pat := self >> self.params[2],\n a_exp := self >> self.params[3],\n\n abbrevs := [\n (L, pat) -> Checked(IsList(L),\n ForAll(L, IsPosInt),\n ForAll(L, e->e > 1),\n IsList(pat),\n Length(pat) = Length(L),\n ForAll(pat, IsList),\n # Elements of pat[d] are distinct and in 0..L[d]-1.\n ForAll(pat, Distinct),\n Minimum(List(pat, Minimum)) >= 0,\n ForAll(L - List(pat, Maximum), IsPosInt),\n [ L, pat, 1 ]),\n (L, pat, k) -> Checked(IsList(L),\n ForAll(L, IsPosInt),\n ForAll(L, e->e > 1),\n IsList(pat),\n Length(pat) = Length(L),\n ForAll(pat, IsList),\n ForAll(pat, Distinct),\n # Elements of pat[d] are distinct and in 0..L[d]-1.\n Minimum(List(pat, Minimum)) >= 0,\n ForAll(L - List(pat, Maximum), IsPosInt),\n IsInt(k),\n Gcd(Product(L), k) = 1,\n [ L, pat, k mod Product(L) ])\n ],\n\n # dims() has 2 components, counting outputs and inputs:\n # dims()[1] is product of all lengths of pattern components.\n # dims()[2] is product of all but last dimension, and RClength on last.\n dims := self >> let(a_lengths := self.a_lengths(),\n a_pat := self.a_pat(),\n [Product(List(a_pat, Length)),\n Product(DropLast(a_lengths, 1)) *\n RClength(Last(a_lengths))\n ]),\n\n # Just call IMDPRDFT and then prune in each dimension according to pat.\n # It's the terminate function, not a Rule, so maybe OK?\nterminate := self >> let(\n a_lengths := self.a_lengths(),\n a_pats := self.a_pat(),\n a_exp := self.a_exp(),\n imdprdft := IMDPRDFT(a_lengths, a_exp),\n lenpatpairs := pairup(a_lengths, a_pats),\n lv := List(lenpatpairs, lp->VStack(List(lp[2], e->Gath(fBase(lp[1], e))))),\n tlv := Tensor(lv) * imdprdft,\n tlv),\n\n transpose := self >> PrunedMDPRDFT(self.a_lengths(), self.a_pat(), -self.a_exp()),\n\n isReal := True,\n\n normalizedArithCost := (self) >> let(n := Product(self.a_lengths()),\n IntDouble(2 * n * d_log(n) / d_log(2)) )\n));\n", "meta": {"hexsha": "df5eb8db89addadf81c0f8326258e440575991da", "size": 8401, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "nonterms/prunedmdprdft.gi", "max_stars_repo_name": "franzfranchetti/spiral-package-fftx", "max_stars_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-15T12:40:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-15T12:40:19.000Z", "max_issues_repo_path": "nonterms/prunedmdprdft.gi", "max_issues_repo_name": "franzfranchetti/spiral-package-fftx", "max_issues_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2021-01-05T20:58:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-18T20:10:45.000Z", "max_forks_repo_path": "nonterms/prunedmdprdft.gi", "max_forks_repo_name": "franzfranchetti/spiral-package-fftx", "max_forks_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-12-14T18:24:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T12:40:20.000Z", "avg_line_length": 42.216080402, "max_line_length": 87, "alphanum_fraction": 0.4833948339, "num_tokens": 2215, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267796346599, "lm_q2_score": 0.6825737214979745, "lm_q1q2_score": 0.5930383283123304}}
{"text": "\nInstallMethod(Witt,\n \"Constructor for Witt Structure\",\n [IsPosInt,IsAlgebraicU],\n function(dim,sys)\n local object,\n BPR,xvarnames,yvarnames,xvars,\n p,max_level,generic_poly;\n \n object:=Objectify(NewType(NewFamily(\"WittFamily\"),\n IsAttributeStoringRep and\n IsWitt),\n rec());\n\n SetDimension(object,dim);\n SetCharacteristic(object,Characteristic(sys));\n \n SetalgebraicU(object,sys);\n\n xvarnames:=List([1..dim],i->Concatenation(\"x_\",String(i)));\n yvarnames:=List([1..dim],i->Concatenation(\"y_\",String(i)));\n BPR:=PolynomialRing(ring(sys),Concatenation(xvarnames,yvarnames));\n xvars:=IndeterminatesOfPolynomialRing(BPR){[1..dim]};\n\n SetchevalleyAdjBPR(object,ChevalleyAdj(sys,BPR));\n\n SetGenericSum(object,GenericSumOp(object));# this needs to be set after Characteristic\n\n p:=Characteristic(sys);\n\n #max_level:=Maximum(List(positiveRoots(simpleAdj(sys)),i->Sum(i)));\n max_level:=20;\n generic_poly:=function(degree)\n local result,\n tuples,tuple_degreeP;\n \n tuple_degreeP:=function(t)\n return Sum(List([1..Length(t)],i->t[i]*p^(i-1)));\n end;\n\n #tuples:=Tuples([1..dim+1]-1,dim);\n tuples:=Tuples([1..max_level]-1,dim);\n tuples:=Filtered(tuples,i->tuple_degreeP(i)=degree);\n tuples:=List(tuples,t->List([1..dim],i->xvars[i]^t[i]));\n tuples:=List(tuples,t->Product(t));\n \n return tuples;\n end;\n #SetGenericLevelPolynomials(object,List([1..max_level],i->generic_poly(i)));\n\n generic_poly:=function(level)\n local result,\n i,Unu,tmp;\n \n if level=0 then return [List([1..dim],i->0)]; fi;\n if level<0 then return []; fi;\n\n Unu:=DiagonalMat(List([1..dim],i->1));\n\n result:=[];\n for i in [1..dim] do\n tmp:=generic_poly(level-p^(i-1));\n if tmp<>[] then\n result:=Concatenation(result,List(tmp,j->j+Unu[i]));\n fi;\n od;\n\n tmp:=[];\n for i in result do\n if not i in tmp then\n tmp:=Concatenation(tmp,[i]);\n fi;\n od;\n\n return tmp;#result;\n end;\n SetGenericLevelPolynomials(object,List([1..max_level],\n i->List(generic_poly(i),\n j->Product([1..dim],\n k->xvars[k]^j[k]))));\n\n SetName(object,Concatenation(\"<witt structure of dimension \",String(dim),\n \" over ring of characteristic \",String(p),\">\"));\n return object;\nend);\n\nInstallMethod(GenericSumOp,\n \"Polynomials for generic sum in the Witt structure\",\n [IsWitt],\n function(w)\n local result,\n p,dim,phiX,phiY,psiXY,phiXY,\n localIPR,Xvarnames,Yvarnames,X,Y,ext_reps,\n BPR,xyvars,i,j,k,poly,monom,pos;\n \n dim:=Dimension(w);\n p:=Characteristic(w);\n BPR:=ring(chevalleyAdjBPR(w));\n \n Xvarnames:=List([1..dim],i->Concatenation(\"X\",String(i)));\n Yvarnames:=List([1..dim],i->Concatenation(\"Y\",String(i)));\n localIPR:=PolynomialRing(Integers,Concatenation(Xvarnames,Yvarnames));\n X:=IndeterminatesOfPolynomialRing(localIPR){[1..dim]};\n Y:=IndeterminatesOfPolynomialRing(localIPR){dim+[1..dim]};\n \n phiX:=List([1..Length(X)],i->Sum(List([1..i],j->p^(j-1)*X[j]^(p^(i-j)))) );\n phiY:=List([1..Length(Y)],i->Sum(List([1..i],j->p^(j-1)*Y[j]^(p^(i-j)))) );\n \n \n psiXY:=[]; \n phiXY:=phiX+phiY;\n \n for i in [1..Length(phiXY)] do\n psiXY:=Concatenation(psiXY,[(1/p^(i-1))*(phiXY[i]-Sum(List([1..i-1],j->p^(j-1)*psiXY[j]^(p^(i-j)))))]);\n od;\n \n ext_reps:=List(Concatenation(X,Y),i->ExtRepPolynomialRatFun(i));\n ext_reps:=List(ext_reps,i->i[1][1]);\n \n xyvars:=IndeterminatesOfPolynomialRing(BPR);\n psiXY:=List(psiXY,i->List(ExtRepPolynomialRatFun(i)));\n result:=[];\n for i in [1..Length(psiXY)] do\n poly:=Zero(BPR);\n for j in [1..Length(psiXY[i])/2] do\n monom:=One(BPR);\n for k in [1..Length(psiXY[i][2*j-1])/2] do\n pos:=Position(ext_reps,psiXY[i][2*j-1][2*k-1]);\n monom:=monom*xyvars[pos]^psiXY[i][2*j-1][2*k];\n od;\n monom:=monom*psiXY[i][2*j];\n poly:=poly+monom;\n od;\n Add(result,poly);\n od;\n\n return result;\n\n # adjust the form to the one I need\n# psiXY_:=List([1..dim],i->psiXY[i]-X[i]-Y[i]);\nend);\n", "meta": {"hexsha": "3f381bf5bcc61f38074e7d2fdf19c5e70941bada", "size": 5737, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/witt.gi", "max_stars_repo_name": "iuliansimion/Chevalley.gap", "max_stars_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/witt.gi", "max_issues_repo_name": "iuliansimion/Chevalley.gap", "max_issues_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/witt.gi", "max_forks_repo_name": "iuliansimion/Chevalley.gap", "max_forks_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.4014084507, "max_line_length": 121, "alphanum_fraction": 0.438556737, "num_tokens": 1328, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970779778824, "lm_q2_score": 0.6723317057447908, "lm_q1q2_score": 0.5921878018518972}}
{"text": "\n\nInstallMethod(UnipotentClass,\n \"Unipotent conjugacy class in algebraic group\",\n [IsString,IsUnipotent,IsList,IsList],\n function(label,u,torus,parabolics)\n local object,\n sys,permute_rep,exp;\n\n Print(label,\"\\n\");\n\n object:=Objectify(NewType(NewFamily(\"UnipotentClassFamily\"),\n IsAttributeStoringRep and\n IsUnipotentClass),\n rec());\n\n sys:=chevalleyAdj(u);\n SetalgebraicU(object,sys);\n SetLabel(object,label);\n SetRepresentative(object,u);\n \n# permute_rep:=function(rep,torus)\n# local result,signs,pr,perm,perm_matrix;\n# \n# perm:=PositiveTorusPermutation(rootSystem(sys),torus);\n# perm_matrix:=Inverse(PermutationMatrix(weylGroup(sys),perm));\n# pr:=positiveRoots(sys);\n# \n# #result:=List(rep,j->perm_matrix*pr[j[1]]);\n# result:=List(rep,j->pr[j[1]]*perm_matrix);\n# signs:=List(rep,j->PermutationSign(sys,perm,pr[j[1]]));\n# #Print(List([1..Length(result)],j->[Position(pr,result[j]),signs[j]*rep[j][2]]));\n# return List([1..Length(result)],j->[Position(pr,result[j]),signs[j]*rep[j][2]]);\n# end;\n \n if torus <> [] then\n SetCocharacter(object,torus);\n SetBorelPerm(object,PositiveTorusPermutation(rootSystem(sys),torus));\n #SetBorelRep(object,Unipotent(sys,permute_rep(coefficients(u),torus)));# !!! Verifica asta\n #SetBorelRep(object,Unipotent(sys,permute_rep(coefficients(u),torus),\n # [1..Length(positiveRoots(sys))]));# !!! Verifica asta\n SetBorelRep(object,Unipotent(sys,coefficients(ToPositiveBorel(object,u)),\n [1..Length(positiveRoots(sys))]));# !!! Verifica asta\n SetOrder(BorelRep(object),Order(u));\n fi;\n \n if parabolics <> [[],[]] then\n SetSupportParabolic(object,ParabolicSystem(rootSystem(sys),parabolics[1]));\n SetDistinguishedParabolic(object,ParabolicSystem(rootSystem(sys),parabolics[2]));\n fi;\n\n if HasOrder(u) then SetOrder(object,Order(u)); fi;\n# elif Characteristic(sys)>0 then SetOrder(object,OrderOp(u)); fi; This can take to much time\n\n SetName(object,Concatenation(\"<unipotent conjugacy class \",label,\" for \",type(sys),String(rank(sys)),\n \" in characteristic \",String(Characteristic(sys)),\">\"));\n return object;\nend);\n\nInstallMethod(ToPositiveBorel,\n \"Permutes root to positive Borel subgroup with the cocharacter\",\n [IsUnipotentClass,IsPosInt],\n function(orb,root_index)\n local sys,perm,perm_mat,pr,roots;\n\n sys:=algebraicU(orb);\n perm:=PositiveTorusPermutation(rootSystem(sys),Cocharacter(orb));\n perm_mat:=Inverse(PermutationMatrix(weylGroup(sys),perm));\n pr:=positiveRoots(sys);\n roots:=allRoots(sys);\n\n #return Position(pr,perm_mat*roots[root_index]);\n return Position(pr,roots[root_index]*perm_mat);\nend);\n\nInstallMethod(ToPositiveBorel,\n \"Permutes roots (in roots_index) to positive Borel subgroup with the cocharacter\",\n [IsUnipotentClass,IsList],\n function(orb,roots_index)\n return List(roots_index,i->ToPositiveBorel(orb,i));\nend);\n\nInstallMethod(FromPositiveBorel,\n \"Permutes root from positive Borel subgroup with the cocharacter\",\n [IsUnipotentClass,IsPosInt],\n function(orb,root_index)\n local sys,perm,perm_mat,pr,roots;\n\n sys:=algebraicU(orb);\n perm:=PositiveTorusPermutation(rootSystem(sys),Cocharacter(orb));\n perm_mat:=Inverse(PermutationMatrix(weylGroup(sys),Reversed(perm)));\n #perm_mat:=PermutationMatrix(weylGroup(sys),perm);\n pr:=positiveRoots(sys);\n roots:=allRoots(sys);\n\n #return Position(pr,perm_mat*roots[root_index]);\n return Position(pr,roots[root_index]*perm_mat);\nend);\n\n\nInstallMethod(FromPositiveBorel,\n \"Permutes roots (in roots_index) from positive Borel subgroup with the cocharacter\",\n [IsUnipotentClass,IsList],\n function(orb,roots_index)\n return List(roots_index,i->FromPositiveBorel(orb,i));\nend);\n\nInstallMethod(ToPositiveBorel,\n \"Permutes roots (in roots_index) from positive Borel subgroup with the cocharacter\",\n [IsUnipotentClass,IsUnipotent],\n function(orb,u)\n local result,coeffs,sys,signs,pr,perm,perm_matrix;\n\n sys:=chevalleyAdj(u);\n \n perm:=BorelPerm(orb);\n #perm_matrix:=Inverse(PermutationMatrix(weylGroup(sys),perm));\n perm_matrix:=PermutationMatrix(weylGroup(sys),Reversed(perm));\n pr:=positiveRoots(sys);\n \n coeffs:=coefficients(u);\n result:=List(coeffs,j->pr[j[1]]*perm_matrix);\n signs:=List(coeffs,j->InversePermutationSign(sys,perm,pr[j[1]]));\n result:=List([1..Length(result)],j->[Position(pr,result[j]),signs[j]*coeffs[j][2]]);\n#### result:=List([1..Length(result)],j->[Position(pr,result[j]),coeffs[j][2]]);\n#Print(result,\"\\n\");\n if Filtered(result,i->i[1]=fail)<>[] then return fail; fi;\n \n result:=Unipotent(sys,result);#,Ordering(u));\n if HasOrder(u) then SetOrder(result,Order(u)); fi;\n \n return result;\nend);\n\nInstallMethod(FromPositiveBorel,\n \"Permutes roots (in roots_index) from positive Borel subgroup with the cocharacter\",\n [IsUnipotentClass,IsUnipotent],\n function(orb,u)\n local result,coeffs,sys,signs,pr,perm,perm_matrix;\n\n sys:=chevalleyAdj(u);\n \n perm:=BorelPerm(orb);\n #perm_matrix:=Inverse(PermutationMatrix(weylGroup(sys),perm));\n #perm_matrix:=Inverse(PermutationMatrix(weylGroup(sys),Reversed(perm)));\n perm_matrix:=PermutationMatrix(weylGroup(sys),perm);\n pr:=positiveRoots(sys);\n \n coeffs:=coefficients(u);\n result:=List(coeffs,j->pr[j[1]]*perm_matrix);\n signs:=List(coeffs,j->PermutationSign(sys,perm,pr[j[1]]));\n result:=List([1..Length(result)],j->[Position(pr,result[j]),signs[j]*coeffs[j][2]]);\n#### result:=List([1..Length(result)],j->[Position(pr,result[j]),coeffs[j][2]]);\n\n if Filtered(result,i->i[1]=fail)<>[] then return fail; fi;\n \n result:=Unipotent(sys,result);#,Ordering(u));\n if HasOrder(u) then SetOrder(result,Order(u)); fi;\n \n return result;\nend);\n\n\n#\n# ---------- Overclass for classes --------\n#\n\nInstallMethod(UnipotentClasses,\n \"Over class for unipotent orbits of a simple algebraic group\",\n [IsAlgebraicU,IsString],\n function(sys,source)\n local object,\n pr_len,p,\n APR,avarnames,\n file,dir,reps,exps,\n rep,root;\n \n object:=Objectify(NewType(NewFamily(\"UnipotentClassesFamily\"),\n IsAttributeStoringRep and\n IsUnipotentClasses),\n rec());\n\n SetalgebraicU(object,sys);\n p:=Characteristic(sys);\n\n dir:=data_dir;\n if type(sys) in [\"B\",\"C\",\"D\",\"E\",\"F\",\"G\"] and p = 2 or\n type(sys) in [\"E\",\"F\",\"G\"] and p = 3 or\n type(sys) = \"E\" and rank(sys) = 8 and p = 5 then\n# if type(sys) in [\"B\",\"C\",\"D\",\"F\"] and p = 2 or\n# type(sys) = \"E\" and rank(sys) in [7,8] and p = 2 or\n# type(sys) in [\"E\",\"G\"] and rank(sys) in [2,8] p = 3 or\n file:=Concatenation(\"data\",type(sys),String(rank(sys)),\"char\",String(p),source,\".gi\");\n Print(file,\"\\n\");\n# if source then file:=Concatenation(\"data\",type(sys),String(rank(sys)),\"char\",String(p),\"Mizuno.gi\");\n# else file:=Concatenation(\"data\",type(sys),String(rank(sys)),\"char\",String(p),\".gi\"); fi;\n else file:=Concatenation(\"data\",type(sys),String(rank(sys)),\".gi\"); fi;\n file:=Filename(dir,file);\n file:=ReadAsFunction(file);\n file:=file();\n\n if file[6]=[] then file[6]:=List([1..Length(file[1])],i->-1); fi;# if Orders not given then compute them\n reps:=List([1..Length(file[1])],i->Unipotent(sys,file[1][i],file[6][i]));\n if file[7]<>[] then\n for rep in [1..Length(reps)] do\n SetAduJordanBlocks(reps[rep],file[7][rep]);\n od;\n fi;\n\n if p<>0 then\n exps:=List(reps,i->LogInt(Order(i),p));\n SetWittStructure(object,Witt(Maximum(exps),sys));\n fi;\n \n SetAllClasses(object,List([1..Length(file[1])],i->UnipotentClass(#witt_structures[exp[i]],\n file[3][i],\n reps[i],\n file[2][i],\n [file[4][i],file[5][i]])));\n \n SetName(object,Concatenation(\"<unipotent conjugacy classes \",type(sys),String(rank(sys)),\n \" in characteristic \",String(Characteristic(sys)),\">\"));\n\n return object;\nend);\n", "meta": {"hexsha": "8e820f41318ec23a7dfe4f3720cb883125756a75", "size": 10114, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/unicls.gi", "max_stars_repo_name": "iuliansimion/Chevalley.gap", "max_stars_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/unicls.gi", "max_issues_repo_name": "iuliansimion/Chevalley.gap", "max_issues_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/unicls.gi", "max_forks_repo_name": "iuliansimion/Chevalley.gap", "max_forks_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.7522123894, "max_line_length": 120, "alphanum_fraction": 0.5277832707, "num_tokens": 2360, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681122619883, "lm_q2_score": 0.6893056040203135, "lm_q1q2_score": 0.5912643667321139}}
{"text": "# Determine images of the homomorphism between to a permutation group\n# and a matrix groups both isomorphic to S_4.\nG := Group((1, 2, 3, 4), (2, 3, 4));\nH := Group([[0, -1, 0], [1, 0, 0], [0, 0, 1]], [[0, 1, 0], [0, 0, 1], [1, 0, 0]]);\n\nhom := GroupHomomorphismByImages(G, H);\n\nfor g in G do\n l := [1..4];\n Apply(l, i -> String((i^g) - 1));\n w := Concatenation(l);\n image := Image(hom, g);\n Print(w, \" \", image, \"\\n\");\nod;", "meta": {"hexsha": "0fdfaa87dbffebc07c05b817c3dcd766faa1b7be", "size": 437, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "symmetry.gap", "max_stars_repo_name": "fifth-postulate/packing-puzzle", "max_stars_repo_head_hexsha": "162dbd13ef4fcbdddaab80722b32a8e41729054e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-05-19T04:03:17.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-07T14:17:35.000Z", "max_issues_repo_path": "symmetry.gap", "max_issues_repo_name": "fifth-postulate/packing-puzzle", "max_issues_repo_head_hexsha": "162dbd13ef4fcbdddaab80722b32a8e41729054e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2018-02-04T16:51:37.000Z", "max_issues_repo_issues_event_max_datetime": "2018-12-12T15:07:00.000Z", "max_forks_repo_path": "symmetry.gap", "max_forks_repo_name": "fifth-postulate/packing-puzzle", "max_forks_repo_head_hexsha": "162dbd13ef4fcbdddaab80722b32a8e41729054e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-05-31T08:26:54.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-31T08:26:54.000Z", "avg_line_length": 31.2142857143, "max_line_length": 82, "alphanum_fraction": 0.528604119, "num_tokens": 181, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772351648678, "lm_q2_score": 0.6757645879592641, "lm_q1q2_score": 0.5906704426657596}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(TDST2, TDST3, TDST4);\n\n_DST_CONST := 2.5;\n\n#######################################################################################\n# tSPL DST rules\n\n#F DST4(<n>) - Discrete Sine Transform, Type IV, non-terminal\n#F Definition: (n x n)-matrix [ sin((k-1/2)*(l-1/2)*pi/n) | k,l = 1...n ]\n#F Note: DST4 is symmetric\n#F Example: DST4(8)\nClass(TDST4, TaggedNonTerminal, rec(\n abbrevs := [ N -> Checked(IsInt(N), N >= 1, [N]) ] ,\n dims := self >> [self.params[1], self.params[1]],\n isReal := True,\n terminate := self >> Mat(DST_IVunscaled(self.params[1])),\n transpose := self >> Copy(self),\n SmallRandom := () -> Random([2, 3, 4, 6, 8, 9, 12, 16, 18, 24, 27, 32]),\n normalizedArithCost := (self) >> let(n := self.params[1], IntDouble(_DST_CONST * n * d_log(n) / d_log(2)))\n));\n\n\nNewRulesFor(TDST4, rec(\n DST4_CT_tSPL := rec(\n switch := false,\n\n applicable := (self, t) >> let(\n P:=t.params,\n P[1] > 2\n and ForAny(DivisorPairs(2*P[1]), d ->\n IsEvenInt(d[1]) and IsEvenInt(d[2])\n )\n and t.hasTags()\n ),\n\n children := (self, t) >> let(\n tags := t.getTags(),\n N := t.params[1],\n Map2(\n Filtered(DivisorPairs(2*N), d -> IsEvenInt(d[1]) and IsEvenInt(d[2])),\n (m,n) -> List([\n TPrm(IJ(N, n/2)),\n TTensorI(condM(m,m/2) * PRDFT3(m,-1).transpose(), n/2, AVec, AVec),\n TTensorI(L(n, 2) * PRDFT3(n) * condK(n, 2), m/2, APar, AVec),\n TPrm(IJ(N, m/2))\n ], i -> i.setTags(tags))\n )\n ),\n\n apply := (self, t, C, Nonterms) >> let(\n N:=t.params[1],\n n:=2*Rows(Nonterms[1].params[1].params[2]),\n m:=2*Rows(Nonterms[4].params[1].params[2]),\n Grp(\n C[1] * C[2]\n * ConjDiag(RC(Diag(fPrecompute(diagMul(fConst(TComplex, N/2, -E(4)),\n fCompose(dOmega(8 * N, 1),\n diagTensor(dLin(N/m, 2, 1, TInt), dLin(m/2, 2, 1, TInt))))\n ))), L(N, m), L(N, n/2))\n )\n * C[3] * C[4]\n )\n )\n));\n\n\n#F TDST2(<n>) - Discrete Sine Transform, Type II, non-terminal\n#F Definition: (n x n)-matrix [ sin(k*(l+1/2)*pi/n) | k,l = 0...n-1 ]\n#F Note: DST2 is the transpose of DST3\n#F Example: DST2(8)\nClass(TDST2, TaggedNonTerminal, rec(\n abbrevs := [ N -> Checked(IsInt(N), N >= 1, [N]) ] ,\n dims := self >> [self.params[1], self.params[1]],\n isReal := True,\n terminate := self >> Mat(DST_IIunscaled(self.params[1])),\n transpose := self >> TDST3(self.params[1]),\n SmallRandom := () -> Random([2,3,4,5,6,8,9,10,12,15,16,18,24,27,30,32]),\n normalizedArithCost := (self) >> let(n := self.params[1], IntDouble(_DST_CONST * n * d_log(n) / d_log(2)))\n));\n\n\nNewRulesFor(TDST2, rec(\n DST2_DST4_tSPL := rec(\n switch := false,\n applicable := (self, t) >> true,\n children := (self, t) >> [[ TS(t.params[1]).withTags(t.getTags()), TDST4(t.params[1]).withTags(t.getTags()) ]],\n apply := (self, t, C, Nonterms) >> let(P := t.params[1],\n Diag(Concat(List([1..P-1], i->V(1.0)), [V(2.0)])) *\n C[1] *\n C[2] *\n Diag(List([0..P - 1], i -> 1/(2 * CosPi((2*i + 1)/(4*P)))))\n )\n ))\n);\n\n\n\n#F TDST3(<n>) - Discrete Sine Transform, Type III, non-terminal\n#F Definition: (n x n)-matrix [ sin((k-1/2)*l*pi/n) | k,l = 1...n ]\n#F Note: DST3 is the transpose of DST2\n#F Example: DST3(8)\n#F Scaled variant (not supported) is:\n#F [ a_l*sin(k*(l-1/2)*pi/n) | k,l = 1...n ]\n#F with a_j = 1/sqrt(2) for j = n and = 1 else.\nClass(TDST3, TaggedNonTerminal, rec(\n abbrevs := [ N -> Checked(IsInt(N), N >= 1, [N]) ] ,\n dims := self >> [self.params[1], self.params[1]],\n isReal := True,\n terminate := self >> Mat(DST_IIIunscaled(self.params[1])),\n transpose := self >> TDST2(self.params[1]),\n SmallRandom := () -> Random([2,3,4,5,6,8,9,10,12,15,16,18,24,27,30,32]),\n normalizedArithCost := (self) >> let(n := self.params[1], IntDouble(_DST_CONST * n * d_log(n) / d_log(2)))\n));\n\n\nNewRulesFor(TDST3, rec(\n DST3_DST4_tSPL := rec(\n switch := false,\n applicable := (self, t) >> true,\n children := (self, t) >> [[ TDST4(t.params[1]).withTags(t.getTags()), TS(t.params[1]).withTags(t.getTags()) ]],\n apply := (self, t, C, Nonterms) >> let(P := t.params[1],\n Diag(List([0..P - 1], i -> 1/(2 * CosPi((2*i + 1)/(4*P))))) *\n C[1] * C[2].transpose() *\n Diag(Concat(List([1..P-1], i->V(1.0)), [V(2.0)])))\n )\n));\n", "meta": {"hexsha": "e20c9feaf414b56c8421b56ec961dfeb1ee40c97", "size": 4811, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/common/dst.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/common/dst.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/common/dst.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 36.446969697, "max_line_length": 119, "alphanum_fraction": 0.4868010809, "num_tokens": 1643, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869981319863, "lm_q2_score": 0.6723316926137812, "lm_q1q2_score": 0.5888193548232208}}
{"text": "\n#\n# Read(\"~/Workspace/groupsSB/epi/group.gi\");\n#\n#\n# needs:\n# type:=\"A\";\n# rank:=2;\n# nr_pos_roots:=3;\n#\n\n\nZZ:=Integers;\navarnames:=List([1..100],i->Concatenation(\"a_{\",String(i),\"}\"));\nbvarnames:=List([1..100],i->Concatenation(\"b_{\",String(i),\"}\"));\ncvarnames:=List([1..100],i->Concatenation(\"c_{\",String(i),\"}\"));\nxvarnames:=List([1..100],i->Concatenation(\"x_{\",String(i),\"}\"));\nvarnames:=Concatenation(avarnames,bvarnames,cvarnames,xvarnames);\nAPR:=PolynomialRing(ZZ,varnames);\nvars:=IndeterminatesOfPolynomialRing(APR);\nxvars:=vars{[301..400]};\n\nsla:=SimpleLieAlgebraTypeA_G(type,rank,APR);\n\ncb:=CanonicalBasis(sla);\n\ne:=cb[1];\n\nid_mat:=DiagonalMat(List([1..2*nr_pos_roots+rank],i->1));\n\n\nade:=function(e)\n\tlocal result,v;\n\tresult:=[];\n\tfor v in cb do\n\t\tAppend(result,[Coefficients(cb,e*v)]);\n\tod;\n\tresult:=TransposedMat(result);\n\treturn result;\nend;\n\n\nroot_group:=function(index,t)\n\tlocal ee,tmp,result,i;\n\tee:=ade(cb[index]);\n\ttmp:=ee;\n\tresult:=One(APR)*tmp^0;\n\ti:=1;\n\twhile Length(Set(Concatenation(tmp)))<>1 do\n\t\tresult:=result+t^i*tmp/Factorial(i);\n\t\ti:=i+1;\n\t\ttmp:=tmp*ee;\n\tod;\n\treturn result;\nend;\n#u1a1:=root_group(1,vars[1]);\n\n\npos_root_groups:=function(start_a_index)\n\treturn List([1..nr_pos_roots],i->root_group(i,vars[start_a_index+i]));\nend;\n\ngeneric_U:=function(start_a_index)\n\tlocal Uas;\n\tUas:=pos_root_groups(start_a_index);\n\treturn Product(Uas);\nend;\n\nUa:=generic_U(0);\nUb:=generic_U(10);\nUc:=generic_U(20);\n\n#\n#\n#\n\nevaluate_U:=function(u,vals)\n\tlocal i,j,result,v;\n\tresult := [];\n\tfor i in [1..Length(u)] do\n\t\tAppend(result,[[1..Length(u)]]);\n\t\tfor j in [1..Length(u)] do\n\t\t\tresult[i][j]:=u[i][j];\n\t\tod;\n\tod;\n\tPrint(result);\n\tfor i in [1..Length(u)] do\n\t\tfor j in [1..Length(u)] do\n\t\t\tfor v in vals do\n\t\t\t\tresult[i][j]:=One(APR)*Value(One(APR)*result[i][j],v[1],v[2]);\n\t\t\tod;\n\t\tod;\n\tod;\n\treturn result;\nend;\n\n\n\nevaluate_U:=function(u,vals)\n\tlocal i,j,result,v;\n\tresult := [];\n\tfor i in [1..Length(u)] do\n\t\tAppend(result,[[1..Length(u)]]);\n\t\tfor j in [1..Length(u)] do\n\t\t\tresult[i][j]:=u[i][j];\n\t\tod;\n\tod;\n\tPrint(result);\n\tfor i in [1..Length(u)] do\n\t\tfor j in [1..Length(u)] do\n\t\t\tfor v in vals do\n\t\t\t\tresult[i][j]:=One(APR)*Value(One(APR)*result[i][j],v[1],v[2]);\n\t\t\tod;\n\t\tod;\n\tod;\n\treturn result;\nend;\n\nevaluate_rels:=function(rels,vals)\n\tlocal i,result,v;\n\tresult :=List([1..Length(rels)],i->rels[i]);\n\tfor i in [1..Length(rels)] do\n\t\tfor v in vals do\n\t\t\t#Print(Length(rels),\": \",rels[i],\"\\n\");\n\t\t\tresult[i]:=One(APR)*Value(result[i],v[1],v[2]);\n\t\t\t#nn[i]:=One(APR)*Value(nn[i],v[1],v[2]);\n\t\tod;\n\tod;\n\treturn result;\nend;", "meta": {"hexsha": "844aae7f77172c90f6948dc9f53301fbe5af6e34", "size": 2547, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "epi/group.gi", "max_stars_repo_name": "iuliansimion/groupsSB", "max_stars_repo_head_hexsha": "db7494e81bb03f76c20fa181e358ba1cc2d28975", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "epi/group.gi", "max_issues_repo_name": "iuliansimion/groupsSB", "max_issues_repo_head_hexsha": "db7494e81bb03f76c20fa181e358ba1cc2d28975", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "epi/group.gi", "max_forks_repo_name": "iuliansimion/groupsSB", "max_forks_repo_head_hexsha": "db7494e81bb03f76c20fa181e358ba1cc2d28975", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19.5923076923, "max_line_length": 71, "alphanum_fraction": 0.6336866902, "num_tokens": 899, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339676722393, "lm_q2_score": 0.6992544147913993, "lm_q1q2_score": 0.5871876841451115}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n#F NthRootCyc(<cyc>, <nroot>) - <nroot>-th root of <cyc>\n#F to get a root we take all powers of cyc of order n,\n#F and make them powers of cyc of order nroot*n (effectively dividing these\n#F powers by nroot). This is done by appending n*(nroot-1) zeros to list of\n#F coeffs and using CoeefsCyc.\nNthRootCyc := (cyc, nroot) -> let(n := OrderCyc(cyc),\n coeffs := CoeffsCyc(cyc,n), # -1 must be E(2), not -E(1)\n sum := Sum(coeffs),\n Cond( # GAP normalization of cyc's (to [-j,j], and not [1,-1]) give headache here\n\tsum = 1, CycList(Concatenation(coeffs, Replicate(n*(nroot-1), 0))),\n\tsum = -1, CycList(Concatenation(Replicate(n/2, 0), -coeffs{[1..n/2]}, Replicate(n*(nroot-1), 0))),\n\tError(\"E(N) or E(-N) where N is positive integer is expected\")));\n\t\n\n#F SkewDFT(n, alpha, k) - Fourier transform for algebra C[x]/x^n - omega_1^alpha\n#F k - rotation\n#F matrix [ w_n ^ (r+alpha)c ]_{r,c}\n#F\nClass(SkewDFT, TaggedNonTerminal, rec(\n abbrevs := [ (n) -> Checked(IsPosIntSym(n), [n, 1, 1]),\n\t (n,alpha) -> Checked(IsPosIntSym(n), IsRatSym(alpha), [n, alpha, 1]),\n\t (n,alpha,k) -> Checked(IsPosIntSym(n), IsIntSym(k), AnySyms(n,k) or Gcd(_unwrap(n),_unwrap(k))=1, IsRatSym(alpha), [n, alpha, k]) ],\n\n dims := self >> [ self.params[1], self.params[1] ],\n terminate := self >> let(\n\tN := self.params[1], rot := self.params[3], a := self.params[2], j := Ind(N-1), \n mat := DFT(N).terminate() *\n Diag(diagDirsum(fConst(TReal, 1, 1.0), fPrecompute(\n Lambda(j, cospi(fdiv(2*a*rot*(j+1), N)) + E(4)*sinpi(fdiv(2*a*rot*(j+1), N)))))),\n Cond(self.transposed, mat.transpose(), mat)),\n\n conjTranspose := self >> ObjId(self)(self.params[1], self.params[2], -self.params[3]).transpose(),\n\n isReal := False,\n\n hashAs := self >> let(t:=ObjId(self)(self.params[1], 1/16, 1).withTags(self.getTags()),\n When(self.transposed, t.transpose(), t)),\n\n normalizedArithCost := self >> let(n := self.params[1], \n floor(5.0 * n * log(n) / log(2.0))),\n));\n\nClass(OnlineDiag, Diag, rec(\n isReal := self >> let(t := self.element.range(),\n\tCond(IsVecT(t), t.t <> TComplex and ObjId(t.t) <> T_Complex,\n\t t <> TComplex and ObjId(t)<>T_Complex)), \n));\n\nGlobal.compiler.DefaultCodegen.OnlineDiag := (self, o, y, x, opts) >> let(\n cc := o.element.compute(),\n decl(cc.values, \n chain(\n cc.code,\n List([1..Length(cc.values)], i -> assign(nth(y, i-1), cc.values[i] * nth(x, i-1)))\n )\n ));\n\nClass(RCOnlineDiag, Diag, rec(\n dims := self >> Replicate(2, 2*self.element.domain())\n));\n\nGlobal.compiler.DefaultCodegen.RCOnlineDiag := (self, o, y, x, opts) >> let(\n cxmul := (y, x, c) -> assign(y, c*x),\n cxmul_conj := (y, x, c) -> assign(y, conj(c)*x),\n cc := o.element.computeWithOps(cxmul, cxmul_conj),\n\n decl(cc.values, chain(\n\tcc.code,\n\tList([0..Length(cc.values)-1], i -> chain(\n\t\tassign(nth(y, 2*i), nth(x, 2*i) * re(cc.values[i+1]) - nth(x, 2*i+1) * im(cc.values[i+1])),\n\t\tassign(nth(y, 2*i+1), nth(x, 2*i) * im(cc.values[i+1]) + nth(x, 2*i+1) * re(cc.values[i+1]))))\n ))\n);\n\nRewriteRules(RulesDiag, rec(\n RC_OnlineDiag := Rule([RC, [OnlineDiag, @(1)]], e-> RCOnlineDiag(@(1).val))\n));\n\n\n#F SkewTwid(<n>, <a>) -- twiddle factor function II(n-1) -> TComplex\n#F j -> omegapi(2*a*(j+1) / n)\n#F\nClass(SkewTwid, RewritableObject, Function, rec(\n updateParams := self >> Checked(IsPosIntSym(self.params[1]), IsRatSym(self.params[2]), 0),\n\n lambda := self >> let(\n n := self.params[1], a := self.params[2], j := Ind(n-1),\n Lambda(j, omegapi(fdiv(2*a*(j+1), n)))),\n\n range := self >> TComplex,\n\n domain := self >> self.params[1]-1,\n));\n\n\n#F OnlineSkewTwid(<n>, <a>, <seed_exps>, <seed_twiddle_func>) -- same as SkewTwid but twiddles are computed\n#F online from seed values given by <seed_twiddle_func>.tolist()\n#F\n#F Example:\n#F OnlineSkewTwid(13,1/7,[1], fCompose(SkewTwid(13,1/7), FList(TInt, [0]))).compute();\nClass(OnlineSkewTwid, SkewTwid, rec(\n # params[2] is only used by super-class's .lambda(), but not here, not in compute()\n updateParams := self >> Checked(IsPosIntSym(self.params[1]), IsRatSym(self.params[2]), \n IsList(self.params[3]), ForAll(self.params[3], IsIntSym),\n IsFunction(self.params[4])),\n\n range := self >> self.params[4].range(),\n\n # compute() returns [ code := ..., values := ... ],\n compute := self >> self.computeWithOps((res,a,b) -> assign(res, a*b), \n\t (res,a,b) -> assign(res, a*conj(b))),\n\n computeWithOps := meth(self, cxmul, cxmul_conj)\n local exp, W, n, c, new_exp, new_W, i, a, b, v, val, num, perm;\n n := EvalScalar(self.params[1]);\n\n exp := List(self.params[3], EvalScalar);\n W := List([1..Length(exp)], i -> var.fresh_t(Concat(\"W\",StringInt(exp[i]), \"_\"), self.range()));\n c := List([1..Length(exp)], i -> assign(W[i], self.params[4].at(i-1)));\n \n\n # NOTE: check if stuck\n while Length(exp) <> (n-1) do\n new_exp := Cartesian(exp, exp);\n new_W := Cartesian(W, W);\n num := Length(exp);\n for i in [1..Length(new_exp)] do\n [a, b] := new_exp[i];\n if (a+b) > 0 and (a+b) < n and not ((a+b) in exp) then\n v := var.fresh_t(Concat(\"W\",StringInt(a+b), \"_\"), self.range());\n Add(exp, a+b);\n Add(W, v);\n Add(c, cxmul(v, new_W[i][1], new_W[i][2]));\n fi;\n if (a-b) > 0 and (a-b) < n and not ((a-b) in exp) then\n v := var.fresh_t(Concat(\"W\",StringInt(a-b), \"_\"), self.range());\n Add(exp, a-b);\n Add(W, v);\n Add(c, cxmul_conj(v, new_W[i][1], new_W[i][2]));\n fi;\n od;\n if Length(exp) = num then Error(\"OnlineSkewTwid.compute is stuck, not enough twiddle seed values given\"); fi;\n od;\n perm := SortingPerm(exp);\n return rec(values := Permuted(W,perm), exp := Permuted(exp,perm), code := chain(c)); \n end\n));\n\n\nClass(ATwidOnline, AGenericTag, rec(isPushTag := true));\nClass(ATwidSplit, AGenericTag, rec(isPushTag := true));\n\nNewRulesFor(SkewDFT, rec(\n SkewDFT_Base2 := rec(\n\tapplicable := t -> t.params[1] = 2,\n\tapply := (t, C, Nonterms) -> let(\n den:=Denominator(t.params[2]), num:=Numerator(t.params[2]), k:=t.params[3],\n\t F(2) * Diag(1,E(2*den)^(k*num)))),\n\n SkewDFT_toDFT := rec(\n\tapplicable := (self, t) >> logic_or(eq(self.a.maxSize, -1), leq(t.params[1], self.a.maxSize)),\n children := t -> [[ DFT(_unwrap(t.params[1]), _unwrap(t.params[3])).withTags(\n\t\t Filtered(t.getTags(), t -> not ObjId(t) in [ATwidOnline, ATwidSplit])) ]],\n\n a := rec(\n diagMode := \"normal\", # \"normal\" | \"split\" | \"online\" \n maxSize := -1\n ),\n\n forTransposition := true,\n\n onlineSeeds := n -> Cond(n<=4, [1],\n n<=8, [1, 3], \n [1, 3, n-1]),\n\n\tapply := (self, t, C, Nonterms) >> let(\n N := t.params[1], rot := t.params[3], a := t.params[2], j := Ind(N-1), \n tw := SkewTwid(N, a*rot),\n mode := Cond(t.firstTag()=ATwidOnline(), \n\t\t # if other tags are present, do not use \"online\" mode\n\t\t # this is necessary because we can't vectorize a standalone SkewDFT in this mode\n\t\t Cond(Length(t.getTags())>1, self.a.diagMode, \"online\"),\n t.firstTag()=ATwidSplit(), \"split\", \n self.a.diagMode),\n\n\t C[1] * \n Cond(mode = \"split\", \n DiagCpxSplit(diagDirsum(FList(TReal, [1.0, 0.0]), fPrecompute(RCData(tw)))),\n mode = \"normal\" or N=2, \n Diag( diagDirsum(fConst(TReal, 1, 1.0), fPrecompute(tw))), # XXX\n\n mode = \"online\", let(seeds := self.onlineSeeds(N), \n DirectSum(I(1), OnlineDiag(OnlineSkewTwid(N, a*rot, seeds, fPrecompute(fCompose(tw, FList(TInt, seeds-1))))))),\n Error(\"<self>.diagMode must be \\\"split\\\" | \\\"normal\\\" | \\\"online\\\"\"))\n ) \n ),\n\n #F SkewDFT_Fact : PDFT_2n_a -> L (PDFT_n_r0 dirsum PDFT_n_r1) L \n #F (I2 tensor [[1,r0],[1,r1]]) L\n #F Derived using polynomial factorization:\n #F (x^2n - a) == (x^n - r0) * (x^n - r1)\n #F where r0 and r1 are two different quadratic roots of a\n #F\n SkewDFT_Fact := rec(\n\tapplicable := t -> t.params[1] > 2 and t.params[1] mod 2 = 0,\n\n\tchildren := t -> let(\n\t n:=t.params[1]/2, r0:=t.params[2]/2, r1:=r0+1/2, k:=t.params[3],\n\t [[ SkewDFT(n, r0, k), SkewDFT(n, r1, k) ]]),\n\n\tapply := (t, C, Nonterms) -> let(\n\t n:=t.params[1]/2, den:=Denominator(t.params[2]), num:=Numerator(t.params[2]), k:=t.params[3],\n\t DirectSum(C[1], C[2]) ^ L(2*n, 2) * \n\t Tensor(I(n), F(2)*Diag(1,E(2*den)^(k*num))) *\n\t L(2*n, n))\n ), \n\n #F SkewDFT_CT : SkewDFT_mn(r) -> (SkewDFT_m(.) tensor I_n) (I_m tensor SkewDFT_n(r)) L\n #F\n #F Derived using polynomial decomposition\n #F x^mn - a == (x^m)^n - a\n #F\n SkewDFT_CT := rec(\n applicable := (self, t) >> logic_and(gt(t.params[1], 2), logic_neg(t.hasTags()), logic_neg(isPrime(t.params[1]))), \n freedoms := t -> [ divisorsIntNonTriv(t.params[1]) ], \n child := (t, fr) -> let(\n N := t.params[1], m := fr[1], n := div(N, m), \n a := t.params[2], rot := t.params[3], j := Ind(n), \n\n [ IDirSum(j, SkewDFT(m, fdiv(a+j, n), rot)), \n SkewDFT(n, a, rot) ]),\n\n apply := (nt, C, Nonterms) -> let(m := Rows(Nonterms[1].child(1)), n := Rows(Nonterms[2]),\n Tr(n, m) * C[1] * Tr(m, n) * Tensor(I(m), C[2]) * Tr(n, m)\n )\n )\n));\n", "meta": {"hexsha": "056d0dc710f7366f184bdd2258e10e98e1123d85", "size": 10082, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/dft/skewdft.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/dft/skewdft.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/dft/skewdft.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 41.4897119342, "max_line_length": 142, "alphanum_fraction": 0.5282682008, "num_tokens": 3267, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.585935242014824}}
{"text": "#############################################################################\n##\n#W union.gi Karel Dekimpe\n#W Bettina Eick\n##\n\n#############################################################################\n##\n#F GenericDeterminantMat( mat )\n##\nGenericDeterminantMat := function( mat )\n local d, det, sig, i, sub;\n \n # set up\n d := Length( mat );\n if ForAny( mat, x -> Length(x) <> d ) then return fail; fi;\n\n # the trivial cases\n if d = 1 then return mat[1][1]; fi;\n if d = 2 then return mat[1][1] * mat[2][2] - mat[1][2] * mat[2][1]; fi;\n\n # otherwise use first row and recursion\n det := 0;\n sig := 1;\n for i in [1..d] do\n sub := Concatenation( [1..i-1], [i+1..d] );\n sub := mat{[2..d]}{sub};\n det := det + sig * mat[1][i] * GenericDeterminantMat( sub );\n sig := - sig;\n od;\n\n return det;\nend;\n\n#############################################################################\n##\n#F NullspaceIntMod( base, vec, p ) . . . . . . . . . . . . b * vec = 0 mod p\n##\n## computes those elements b in <base> with b * vec = 0 mod p. Returns a \n## triangulized basis with respect to <base>.\n##\nNullspaceIntMod := function( base, vec, p )\n local imgs, d, null;\n\n # get images\n imgs := List( base, x -> x * vec );\n imgs := List( imgs, x -> x mod p );\n d := Length( imgs );\n if ForAll( imgs, x -> x = 0 ) then return IdentityMat( d ); fi;\n\n # compute kernel of imgs vector - must have rank d-1\n Add( imgs, p );\n null := NullspaceIntMat( TransposedMat( [imgs] ) );\n null := List( null, x -> x{[1..d]} );\n null := NormalFormIntMat( null, 0 ).normal;\n\n # return this images nullspace\n return Filtered( null, x -> PositionNonZero(x) <= d );\nend;\n\n#############################################################################\n##\n#F FindMaximals( sub ) . . . . . . . .subgroups which are maximal within sub\n##\nFindMaximals := function( sub )\n local new, i, tmp;\n new := [];\n for i in [1..Length(sub)] do\n if Size( sub[i] ) > 1 then\n if Length(new) = 0 then\n Add( new, sub[i] );\n elif not ForAny( new, x -> IsSubset( x, sub[i] ) ) then\n tmp := Filtered( new, x -> not IsSubset( sub[i], x ) );\n Add( new, sub[i] );\n fi; \n fi;\n od;\n return new;\nend;\n\nif not IsBound( SizeOfUnion ) then SizeOfUnion := false; fi;\n#############################################################################\n##\n#F SizeOfUnionRec( sub ) -- recursive version\n##\nSizeOfUnionRec := function( list )\n local s, i, int, t, n;\n if Length( list ) = 0 then return 1; fi;\n s := Size( list[1] );\n n := Length( list );\n for i in [2..n] do\n int := List( list{[1..i-1]}, x -> Intersection( x, list[i]));\n t := SizeOfUnion( int );\n s := s + Size( list[i] ) - t;\n od;\n return s;\nend;\n\n#############################################################################\n##\n#F SizeOfUnionTriv -- trivial version\n##\nSizeOfUnionTriv := function( list )\n return Length( Union( List( list, Elements ) ) );\nend;\n\n#############################################################################\n##\n#F SizeOfUnion -- main function \n##\nSizeOfUnion := function( sub )\n local list;\n list := FindMaximals( sub );\n if Length(list) = 0 then return 1; fi;\n if Length(list) = 1 then return Size(list[1]); fi;\n if Sum(List(list, Size)) < 2000 then\n return SizeOfUnionTriv(list); \n fi;\n return SizeOfUnionRec(list);\nend;\n\n#############################################################################\n##\n#F SizeOfUnionMod( subs, e ) . . . . . . . . .size of the union of subs mod e\n##\n## <subs> is a list of bases containing (eZ)^d. Compute the size of the union\n## of <subs> in (Z/eZ)^d. \n##\n## This function needs to be profiled.\n##\nSizeOfUnionMod := function( subs, e )\n local d, F, V, b, news;\n\n # the trivial case\n if Length( subs ) = 0 then return 1; fi;\n d := Length( subs[1] );\n\n if IsPrimeInt( e ) then \n F := GF(e);\n V := F^d;\n b := BasisVectors( Basis( V ) );\n news := List( subs, x -> x * b );\n news := List( news, x -> Subspace( V, x ) );\n if ForAny( news, x -> Size(x) = e^d ) then return e^d; fi;\n # return SizeOfUnion( news );\n return Length( Union( List( news, Elements ) ) );\n fi;\n\n V := AbelianGroup( List( [1..d], x -> e ) );\n b := GeneratorsOfGroup(V);\n news := List( subs, x -> List( x, y -> MappedVector( y, b ) ) );\n news := List( news, x -> Subgroup( V, x ) );\n if ForAny( news, x -> Size(x) = e^d ) then return e^d; fi;\n\n # return SizeOfUnion( news );\n return Length( Union( List( news, Elements ) ) );\nend;\n\n", "meta": {"hexsha": "855ec666b1f5fc06815e2665e4bd9e3a0d01b6da", "size": 4847, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "gap/union.gi", "max_stars_repo_name": "alex-konovalov/aclib", "max_stars_repo_head_hexsha": "d1afb020805bfd60a8bbb0a9a4adac77fe9b44f1", "max_stars_repo_licenses": ["Artistic-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gap/union.gi", "max_issues_repo_name": "alex-konovalov/aclib", "max_issues_repo_head_hexsha": "d1afb020805bfd60a8bbb0a9a4adac77fe9b44f1", "max_issues_repo_licenses": ["Artistic-2.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2018-03-07T16:35:34.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-26T23:51:07.000Z", "max_forks_repo_path": "gap/union.gi", "max_forks_repo_name": "alex-konovalov/aclib", "max_forks_repo_head_hexsha": "d1afb020805bfd60a8bbb0a9a4adac77fe9b44f1", "max_forks_repo_licenses": ["Artistic-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-03-10T19:58:42.000Z", "max_forks_repo_forks_event_max_datetime": "2018-03-10T19:58:42.000Z", "avg_line_length": 30.4842767296, "max_line_length": 77, "alphanum_fraction": 0.4536826903, "num_tokens": 1338, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789086703225, "lm_q2_score": 0.7217431943271998, "lm_q1q2_score": 0.5849576364785414}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nIsASPAlgebra := x -> IsRec(x) and IsBound(x.isASPAlgebra) and x.isASPAlgebra;\n\nClass(AlgebraOps, PrintOps, rec(\n \\= := (b1, b2) -> Cond(\n not IsASPAlgebra(b1) or not IsASPAlgebra(b2), false,\n ObjId(b1)=ObjId(b2) and b1.rChildren() = b2.rChildren())\n));\n\nClass(ASPAlgebra, rec(\n isASPAlgebra:=true,\n codeletShape := self >> Concatenation([ObjId(self)], List(self.rChildren(), CodeletShape)),\n from_rChildren := (self, rch) >> ApplyFunc(ObjId(self), rch),\n unparse := \"RewritableObjectExp\",\n)); \n\n\nDeclare(XN_skew, XN_plus_1, XN_min_1, XN_min_w);\n\n#F XN_min_1(n) -- represents x^n - 1 polynomial\n#F Spectral decomposition: 1d and 2d components \n#F <n> even or odd\n#F\nClass(XN_min_1, ASPAlgebra, rec(\n __call__ := (self, n, rot) >> let(nn:=_unwrap(n), Checked(IsPosIntSym(nn), IsIntSym(rot), WithBases(self, \n rec(n := nn, rot := rot, operations := PrintOps)))),\n\n hashAs := self >> ObjId(self)(self.n, 1),\n rChildren := self >> [self.n, self.rot],\n rSetChild := rSetChildFields(\"n\", \"rot\"),\n print := self >> Print(self.__name__, \"(\", self.n, \", \", self.rot,\")\"),\n\n conj := self >> CopyFields(self, rec(rot := -self.rot)),\n\n prettyPrint := self >> PrintEval(\"x$1 - 1\", When(self.n=1, \"\", Concat(\"^\", StringInt(self.n)))),\n\n rspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n n <= 1, [self], # if n<=1 then then can't decompose further\n Concatenation(\n [ XN_min_1(1, rot) ],\n Cond(IsOddInt(n), [], [XN_plus_1(1, rot)]),\n List([1..Int((n-1)/2)], i -> XN_skew(2, i/n, rot)))\n )),\n\n cspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n n = 1, [self],\n n = 2, [XN_min_1(1,self.rot), XN_plus_1(1, self.rot)],\n n > 2, ConcatList(self.rspectrum(), x -> x.cspectrum())\n )),\n\n # rfactor(1) == rspectrum()\n # rfactor(n) == self\n rfactor := (self, m) >> Checked((self.n mod m) = 0,\n List(XN_min_1(self.n/m, self.rot).rspectrum(), x -> CopyFields(x, rec(n := x.n * m)))),\n\n shift := self >> Z(self.n, -1)\n));\n\n#F XN_min_1U(n) -- represents x^n - 1 polynomial\n#F Spectral decomposition: 2d components only\n#F <n> must be even\n#F\nClass(XN_min_1U, XN_min_1, rec(\n __call__ := (self, n, rot) >> let(nn:=_unwrap(n), Checked(IsPosIntSym(nn), IsSymbolic(nn) or IsEvenInt(nn),\n IsIntSym(rot), WithBases(self, \n rec(n := nn, rot := rot, operations := PrintOps)))),\n\n rspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n self.n <= 1, [self], # if n==1 then then can't decompose further\n Concatenation(\n Cond(IsOddInt(n), [XN_min_1(1, rot)], [XN_min_1(2, rot)]),\n List([1..Int((n-1)/2)], i -> XN_skew(2, i/n, rot)))\n ))\n)); \n\nClass(XN_skew_base, ASPAlgebra, rec(\n prettyPrint := self >> Cond(IsOddInt(self.n) or self.a=1/4,\n PrintEval(\"x$1 + 1\", When(self.n=1, \"\", Concat(\"^\", StringInt(self.n)))),\n PrintEval(\"x^$1 - 2 x$2 cos($3*pi) + 1\", self.n, When(self.n=2, \"\", Concat(\"^\", StringInt(self.n/2))), 2*self.a)\n ),\n\n conj := self >> CopyFields(self, rec(rot := -self.rot)),\n\n shift := self >> let(n:=self.n, cos:=CosPi(self.rot*2*self.a), i := Ind(n),\n HStack(VStack(O(1,n-1),I(n-1)), \n Mat([List([0..n-1], i -> Cond(i=0, -1, i=n/2, 2*cos, 0))]).transpose())),\n\n cspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n n = 1, [self],\n n = 2, [XN_min_w(1,self.a, rot), XN_min_w(1,1-self.a, rot)],\n n > 2, ConcatList(self.rspectrum(), x -> x.cspectrum())\n ))\n));\n\n#F XN_skew(n, a, rot) -- represents x^n - 2x^{n/2} cospi(2*a) + 1 polynomial\n#F Spectral decomposition: 2d components only\n#F <n> must be even\n#F\nClass(XN_skew, XN_skew_base, rec(\n __call__ := (self, n, a, rot) >> let(nn := _unwrap(n), \n\tChecked(IsPosIntSym(nn), IsSymbolic(nn) or IsEvenInt(nn), IsIntSym(rot), \n\t IsRatSym(a), IsSymbolic(a) or (0 < a and a < 1), \n\t\tWithBases(self, \n\t\t rec(n := nn, a := a, rot := rot, operations := PrintOps)))),\n\n hashAs := self >> XN_skew(self.n, 1/16, 1),\n rChildren := self >> [self.n, self.a, self.rot],\n rSetChild := rSetChildFieldsF(_unwrap, \"n\", \"a\", \"rot\"),\n print := self >> Print(self.__name__, \"(\", self.n, \", \", self.a, \", \", self.rot, \")\"),\n\n rspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n n <= 2, [self], # if n<=2 then then can't decompose further\n List([0..Int(n/2)-1], i -> XN_skew(2, (i + self.a)/(n/2), rot)))),\n\n # rfactor(1) == rspectrum(), rfactor(n) == self\n rfactor := (self, m) >> Checked(IsEvenInt(m), m > 1, (self.n mod m) = 0, \n List(XN_skew(2*self.n/m, self.a, self.rot).rspectrum(), x -> CopyFields(x, rec(n := x.n * m/2)))),\n));\n\n#F XN_plus_1(n, rot) -- represents x^n + 1 polynomial\n#F Spectral decomposition: 1d and 2d components \n#F <n> even or odd\n#F\nClass(XN_plus_1, XN_skew_base, rec(\n __call__ := (self, n, rot) >> let(nn:=_unwrap(n), Checked(IsPosIntSym(nn), IsIntSym(rot), \n WithBases(self, rec(n := nn, a := 1/4, rot := rot, operations := PrintOps)))),\n\n rspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n n <= 2, [self], # if n<=2 then then can't decompose further\n Concatenation(\n List([0..Int(n/2)-1], i -> XN_skew(2, (i + 1/2)/(n), rot)),\n Cond(IsEvenInt(n), [], [XN_plus_1(1, rot)]))\n )),\n\n rfactor := (self, mm) >> Checked(mm >= 1, (self.n mod mm) = 0, Cond(\n IsOddInt(mm) and not IsOddInt(self.n), Error(\"<mm> can only be odd if polynomial degree (self.n) is odd\"),\n let(m := When(IsOddInt(self.n), mm, mm/2), \n List(XN_plus_1(self.n/m, self.rot).rspectrum(), x -> CopyFields(x, rec(n := x.n * m)))))),\n\n hashAs := self >> XN_plus_1(self.n, 1),\n rChildren := self >> [self.n, self.rot],\n rSetChild := rSetChildFields(\"n\", \"rot\"),\n print := self >> Print(self.__name__, \"(\", self.n, \", \", self.rot, \")\"),\n));\n\n#F XN_min_w(n, a, rot) -- represents x^n - w_a polynomial\n#F Spectral decomposition: 1d components only over complex numbers\n#F\nClass(XN_min_w, XN_skew_base, rec(\n __call__ := (self, n, a, rot) >> let(nn:=_unwrap(n), Checked(\n\tIsPosIntSym(nn), IsRatSym(a), IsSymbolic(a) or (0 < a and a < 1), IsIntSym(rot), \n WithBases(self, rec(n := nn, a := a, rot := rot, operations := PrintOps)))),\n\n hashAs := self >> XN_min_w(self.n, 1/16, 1),\n rChildren := self >> [self.n, self.a, self.rot],\n rSetChild := rSetChildFields(\"n\", \"a\", \"rot\"),\n print := self >> Print(self.__name__, \"(\", self.n, \", \", self.a, \", \", self.rot, \")\"),\n\n rspectrum := self >> Error(\"Polynomial algebra is complex, no real spectrum\"),\n\n cspectrum := self >> let(rot := EvalScalar(self.rot), n := EvalScalar(self.n), Cond(\n n = 1, [self], # if n<=2 then then can't decompose further\n List([0..n-1], i -> XN_min_1(1, (i + self.a)/n, rot)))),\n\n prettyPrint := self >> PrintEval(\"x^$1 - w_$2\", self.n, self.a),\n\n shift := self >> let(n:=self.n, cos:=CosPi(self.rot*2*self.a), i := Ind(n),\n DirectSum(_omega(EvalScalar(self.a))*I(1), When(n=1, [], I(n-1)))*\n Prm(Z(n,-1)))\n));\n", "meta": {"hexsha": "b0d2e47a5f2fbd35ab827c4ad67d7d07857770f4", "size": 7373, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/sym/asp_algebra.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/sym/asp_algebra.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/sym/asp_algebra.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 42.1314285714, "max_line_length": 120, "alphanum_fraction": 0.5715448257, "num_tokens": 2499, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569016, "lm_q2_score": 0.7279754548076477, "lm_q1q2_score": 0.5846908096925004}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\napply_nt := (NT, input) -> \n List(TransposedMat(MatSPL(NT) * TransposedMat([input]))[1], EvalScalar);\n\ndft_a := [0, 0, 1/2, 1/2];\ndft_b := [0, 1/2, 0, 1/2];\n\ndft_algo := [ [DFT1, DFT1], # f1 -> f1, f1\n [DFT2, DFT1], # f2 -> f2, f1\n\t [DFT1, DFT3], # f3 -> f1, f3\n\t [DFT2, DFT3] # f4 -> f2, f3\n\t ];\ntwid := (type,N,m,i) -> List(\n Twid(N,m,1,dft_a[type], dft_b[type],i).lambda().tolist(), EvalScalar);\n\n# F_N -> Tensor(F_m, I_n) * T(mn, n) * Tensor(I_m, F_n) * L(mn, m)\n#\n[n, inputs, dfts, inputs2, twids, tinputs2, outputs, out, tdfts] := [0,0,0,0,0,0,0,0,0];\n\ndft_projection := function(type, N, m, input)\n n := N/m;\n inputs := List([0..m-1], x->part(input,m,x)); \n dfts := List(inputs, x->apply_nt(dft_algo[type][2](Length(x)), x));\n inputs2 := TransposedMat(dfts);\n twids := List([0..n-1], i -> twid(type,N,m,i));\n tinputs2 := List([1..n], i -> listmul(inputs2[i], twids[i]));\n outputs := List(tinputs2, x->apply_nt(dft_algo[type][1](Length(x)), x));\n return List([inputs, dfts, inputs2, tinputs2, outputs], x->List(x,csym));\nend;\n\ntdft_projection := function(type, N, m, input)\n n := N/m;\n inputs := List([0..n-1], x->part(input,n,x)); \n dfts := List(inputs, x->apply_nt(dft_algo[type][2](Length(x)), x));\n twids := List([0..n-1], i->twid(Cond(type=2,3,type=3,2,type),N,m,i)); \n tdfts := List([1..n], i -> listmul(dfts[i], twids[i]));\n tinputs2 := TransposedMat(tdfts);\n outputs := List(tinputs2, x->apply_nt(dft_algo[type][1](Length(x)), x));\n return List([inputs, dfts, tdfts, tinputs2, outputs], x->List(x,csym));\nend;\n\nDeclare(inp, p1, p2, imid, dft1, dft2);\ndft1_radproj := function(N, input)\n local mid; #,imid, p1, p2, inp, out;\n mid := DFT_Rader.raderMid(N,1,PrimitiveRootMod(N));\n input := apply_nt(RR(N), input);\n p1 := [input[1]]; inp := Drop(input,1);\n dft1 := apply_nt(DFT(N-1,-1), inp);\n imid := apply_nt(mid, Concat(p1, dft1));\n p2 := [imid[1]]; imid := Drop(imid, 1); \n dft2 := apply_nt(DFT(N-1,-1), imid);\n out := apply_nt(RR(N).transpose(), Concat(p2, dft2));\n return List([inp, dft1, imid, dft2, out], csym);\nend;\n# left transform in Rader rule: \n# jDFT1 -> IRDFT1 dirsum jIRDFT2\n# jDFT1 -> (jDFT1 dirsum jDFT3 )^L (R^2 dirsum C^2 ... I^2)\n# jDFT3 -> (jDFT1 D dirsum jDFT1 D)^L (R^2 dirsum C^2 ... R^2)\n#\n#\nrcexp := l -> ConcatList(l, \n e -> let(ee := Complex(e), [ReComplex(ee), ImComplex(ee)]));\n\n\n# DFT_mn = CRT(m,n,1,1)^T (OS(m,n) F_m x I_n) (I_m x OS(n,m) F_n) CRT(m,n,1,1)\npf_projection := function(N, m, input)\n local i, j;\n n := N/m;\n inputs := List([0..m-1], j -> List([0..n-1], i->input[1+ (j*n + i*m) mod N]));\n dfts := List(inputs, x->apply_nt(OS(n,m)*DFT(n), x));\n inputs2 := TransposedMat(dfts);\n outputs := List(inputs2, x->apply_nt(OS(m,n)*DFT(m), x));\n out := [1..N];\n for j in [0..n-1] do \n for i in [0..m-1] do \n out[1+ (j*m + i*n) mod N] := outputs[1+j][1+i];\n od;\n od;\n return List([inputs, dfts, inputs2, outputs], x->List(x,csym));\nend;\n\n", "meta": {"hexsha": "2a622648afe1b70cc0bb21566ab6421951ec6d39", "size": 3143, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/sym/proj.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/sym/proj.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/sym/proj.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 36.5465116279, "max_line_length": 88, "alphanum_fraction": 0.5609290487, "num_tokens": 1236, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577680904463333, "lm_q2_score": 0.6791787121629466, "lm_q1q2_score": 0.5825778270038106}}
{"text": "# Built-in\n\nFiltered([1 .. 100], IsPrime);\n# [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 ]\n\nFiltered([1 .. 10], IsEvenInt);\n# [ 2, 4, 6, 8, 10 ]\n\nFiltered([1 .. 10], IsOddInt);\n# [ 1, 3, 5, 7, 9 ]\n", "meta": {"hexsha": "558737868ea2551503c982ce8c85f3de0d4ead28", "size": 250, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "Task/Filter/GAP/filter.gap", "max_stars_repo_name": "LaudateCorpus1/RosettaCodeData", "max_stars_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d", "max_stars_repo_licenses": ["Info-ZIP"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-09T22:08:38.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-09T22:08:38.000Z", "max_issues_repo_path": "Task/Filter/GAP/filter.gap", "max_issues_repo_name": "seanwallawalla-forks/RosettaCodeData", "max_issues_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d", "max_issues_repo_licenses": ["Info-ZIP"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Task/Filter/GAP/filter.gap", "max_forks_repo_name": "seanwallawalla-forks/RosettaCodeData", "max_forks_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d", "max_forks_repo_licenses": ["Info-ZIP"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-11-09T22:08:40.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-09T22:08:40.000Z", "avg_line_length": 22.7272727273, "max_line_length": 100, "alphanum_fraction": 0.488, "num_tokens": 147, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8175744850834648, "lm_q2_score": 0.7122321720225278, "lm_q1q2_score": 0.5823028513011959}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n# Transform symbol: Toeplitz\n#\n# Parameters: <list>\n#\n# Definition: Toeplitz(L) represents the (n X n) toeplitz matrix. \n# L must contain the coefficients of the first row (from\n# right to left) followed by all but first coefficents \n# \t\t on the first column specified. Toeplitz matrices have \n# constant elements along all diagonals.\n#\n# \t\t n = (len(L)+1) / 2.\n#\n# Example: Transform( \"Toeplitz\", [1, 2, 3, 4, 5, 6, 7]) is the matrix\n# [ [4, 3, 2, 1],\n# [5, 4, 3, 2],\n# [6, 5, 4, 3],\n# [7, 6, 5, 4] ]\nClass(Toeplitz, NonTerminal, DataNonTerminalMixin, rec(\n # above DataNonTerminalMixin must come after NonTerminal to pickup\n # NonTerminal.operations instead of DataNonTerminalMixin.operations\n # which is actually ClassBase.operations\n abbrevs := [ \n\tL -> let(f:=toFunc(L), \n\t [ Checked(IsOddInt(f.domain()), f), 0, f.domain()-1 ]),\n\t(L, l, r) -> let(f:=toFunc(L), \n\t [ Checked(IsOddInt(f.domain()), f), l, r ] )\n ],\n\n dims := self >> Replicate(2, (self.params[1].domain()+1)/2),\n\n terminate := self >> let(\n\tcoeffs := self.params[1],\n\t#lcoeffs := coeffs.lambda(),\n\tcoeffs_ev := coeffs.lambda().tolist(),\n\tlen := coeffs.domain(),\n\tl := self.params[2],\n\tr := self.params[3],\n\t#v := Ind(len),\n #toeplitz( Lambda(v, cond(leq(l,v,r), lcoeffs.at(v), 0)).tolist() )),\n toeplitz(coeffs_ev)),\n\n transpose := self >> let(nums := self.params[1],\n Toeplitz(fCompose(nums, J(nums.domain())))),\n \n isReal := self >> true,\n\n HashId := self >> let(n := self.params[1].domain(), l := self.params[2], r := self.params[3],\n#\t[n, When(IsInt(l) and IsInt(r), QuantizeQuarters(((r-l) mod n)/(n-1)), 1)]),\n\tn),\n\n hprint := self >> let(n := self.params[1].domain(), h := self.HashId, \n\tPrint(self.name, \"(\", n, \")\")), #, \", 0, \", \", Int((n-1)*h[2]), \")\")),\n\n SmallRandom := () -> [1 .. 1+2*Random([1..8])],\n\n setNonZero := meth(self, l, r)\n self.params[2] := l;\n\tself.params[3] := r;\n end\n));\n\n## \n## Rules\n##\nRulesFor(Toeplitz, rec(\n ###################################################################\n ## Time domain methods\n ###################################################################\n \n #F Toeplitz_Base: (base case)\n #F\n #F NonTerm_Filter -> SPLMat\n #F Computes convolution by definition\n #F\n Toeplitz_Base := rec(\n\tinfo := \"Toeplitz -> Mat\",\n\tforTransposition := false,\n\tlimit := 8,\n\tisApplicable := (self, P) >> let(n := (P[1].domain()+1)/2, n <= self.limit),\n\tallChildren := P -> [[ ]],\n\trule := (P, C) -> ApplyFunc(Toeplitz, P).terminate()\n ),\n\n Toeplitz_SmartBase := rec(\n\tinfo := \"Toeplitz -> Lower-Triangular | Upper-Triangular | Full matrix\",\n\tforTransposition := false,\n\tlimit := 5,\n\tisApplicable := (self, P) >> let(n := (P[1].domain()+1)/2, n <= self.limit),\n\tallChildren := P -> [[ ]],\n\n\trule := (P, C) -> let(\n\t coeffs := P[1],\n\t coeffs_ev := coeffs.lambda().tolist(),\n\t len := coeffs.domain(), # 7 (r 6,5,4,<3>,2,1,0 l)\n\t halflen := (len-1) / 2, # 3 \n\t l := P[2],\n\t r := P[3],\n\t closed := leq(l, r),\n\n\t A := leq(halflen, l),\n\t B := leq(r, halflen),\n\n\t lout := leq(len, l),\n\t rout := leq(r, -1),\n\n\t COND(logic_and(A, logic_or(closed, rout)), # lower triangular\n\t\t toeplitz(Concat(Replicate(halflen,0), Drop(coeffs_ev, halflen))), \n\t\t COND(logic_and(B, logic_or(closed, lout)), # upper triangular\n\t\t toeplitz(Concat(Take(coeffs_ev, halflen+1), Replicate(halflen,0))),\n\t\t toeplitz(coeffs_ev)))) # full\n ),\n\n Toeplitz_PreciseBase := rec(\n\tinfo := \"Toeplitz -> toeplitz of non-zero elements only\",\n\tforTransposition := false,\n\tswitch := false,\n\tisApplicable := P -> let(len := P[1].domain(), len = 3),\n\tallChildren := P -> [[ ]],\n\trule := (P, C) -> let(\n\t lcoeffs := P[1].lambda(),\n\t len := P[1].domain(),\n\t l := P[2],\n\t r := P[3],\n\t v := Ind(len),\n\t toeplitz( Lambda(v, cond(leq(l,v,r), lcoeffs.at(v), 0)).tolist() ))\n ),\n\n #F Toeplitz_Blocking\n #F \n #F Toeplitz -> Blocks (Toeplitzes)\n #F\n #F Toeplitz is divided into square blocks of sizes given by all\n #F proper divisors of the input size.\n #F \n Toeplitz_Blocking := rec(\n\tinfo := \"Toeplitz_nk -> Toeplitz_k\",\n\tforTransposition := false,\n\n\tisApplicable := P -> let(N := (P[1].domain() + 1) / 2,\n\t N > 2 and not IsPrime(N)),\n\n\tallChildren := P -> let(\n\t len := P[1].domain(), N := (len+1)/2, \n\t l := P[2], r:= P[3], nzlen := r-l+1, ratio := When(IsInt(nzlen), nzlen/len, 1),\n\t List(DivisorPairs(N), d -> let(newlen := 2*d[1]-1, \n\t\t[ Toeplitz(FUnk(newlen), newlen - CeilingRat(newlen*ratio), newlen-1) ]))),\n\n\trule := (P, C, Nonterms) -> let(\n\t len := P[1].domain(), \n\t N := (len + 1) / 2,\n\t bksize := Rows(C[1]),\n\t bklen := 2*bksize - 1,\n\t bkdim := N / bksize,\t \n\t numblocks := 2 * bkdim - 1, \n\t i := Ind(bkdim),\n\t k := Ind(bkdim),\n\t ofs := DataInd(TInt, N*2-bklen).setAttr(\"live_out\"), \n\t gfunc := fAdd(len, bklen, ofs), \n\n\t l := P[2], \n\t r := P[3],\n\t open := leq(r+1, l), \n\t A := leq(l-bklen+1, ofs), \n\t B := leq(ofs, r),\n\t isNonZero := logic_or(logic_and(A, B), logic_and(open, logic_or(A, B))),\n\n nt := Nonterms[1].setData(fCompose(P[1], gfunc))\n\t .setNonZero(l-ofs, r-ofs),\n\t \n\t ISum(i, i.range, \n\t\tScat(fTensor(fBase(i), fId(bksize))) * \n\t\tISumAcc(k, k.range, \n\t\t Data(ofs, bksize*((bkdim-1)+i-k),\n\t\t COND(isNonZero, C[1],\n\t\t\t O(bksize))) * \n\t\t Gath(fTensor(fBase(k), fId(bksize)))))\n\t)\n ),\n\n Toeplitz_BlockingDense := rec(\n\tinfo := \"Toeplitz_nk -> Toeplitz_k\",\n\tforTransposition := false,\n\n\tisApplicable := P -> let(N := (P[1].domain() + 1) / 2,\n\t N > 2 and not IsPrime(N)),\n\n\tallChildren := P -> let(\n\t len := P[1].domain(), N := (len+1)/2, \n\t l := P[2], r:= P[3], nzlen := r-l+1, ratio := When(IsInt(nzlen), nzlen/len, 1),\n\t List(DivisorPairs(N), d -> let(newlen := 2*d[1]-1, \n\t\t[ Toeplitz(FUnk(newlen), newlen - CeilingRat(newlen*ratio), newlen-1) ]))),\n\n\trule := (P, C, Nonterms) -> let(\n\t len := P[1].domain(), \n\t N := (len + 1) / 2,\n\t bksize := Rows(C[1]),\n\t bklen := 2*bksize - 1,\n\t bkdim := N / bksize,\t \n\t numblocks := 2 * bkdim - 1, \n\t i := Ind(bkdim),\n\t k := Ind(bkdim),\n\t ofs := DataInd(TInt, N*2-bklen).setAttr(\"live_out\"), \n\t gfunc := fAdd(len, bklen, ofs), \n\t isNonZero := When(P[3]-P[2]+1=len, V(1), leq(P[2]-bklen+1, ofs, P[3])), \n nt := Nonterms[1].setData(fCompose(P[1], gfunc))\n\t .setNonZero(P[2]-ofs, P[3]-ofs),\n\t \n\t ISum(i, i.range, \n\t\tScat(fTensor(fBase(i), fId(bksize))) * \n\t\tISumAcc(k, k.range, \n\t\t Data(ofs, bksize*((bkdim-1)+i-k),\n\t\t C[1]) * \n\t\t Gath(fTensor(fBase(k), fId(bksize)))))\n\t)\n ),\n ###################################################################\n ## Frequency domain methods\n ###################################################################\n\n #F Toeplitz_ExpandedConvolution\n #F\n #F Toeplitz -> Toeplitz_n -> submatrix Circulant(k) where k>=2*n-1\n #F \n #F Computes Toeplitz matrix through convolution of expanded size.\n #F\n #F Van Loan, C. \"Computational Frameworks for the Fast Fourier Transform\",\n #F SIAM Philadelphia 1992, p208.\n #F\n Toeplitz_ExpandedConvolution := rec(\n\tinfo := \"Toeplitz_n -> submatrix Circulant(k), k>=2*n-1 \",\n\tforTransposition := false,\n\tswitch := false,\n\tisApplicable := P -> P[1].domain() >= 5, \n\tallChildren := function( P )\n\t local conv_size,l,L,toep_size;\n\t l := P[1].domain();\n\t L := P[1].lambda().tolist();\n\t conv_size := 2^LogInt(l, 2);\n\t while conv_size < l do conv_size := conv_size*2; od;\n\t return [[ Circulant(\n\t\tConcatenation(\n\t\t List([1..(l+1)/2], x->L[(l+1)/2+x-1]),\n\t\t List([1..conv_size-l], x->0),\n\t\t List([1..(l-1)/2], x->L[x]))) ]];\n\tend, \n\t\n\trule := (P, C) -> let(n := (P[1].domain() + 1)/2, \n\t RI(n, Rows(C[1])) * \n\t C[1] *\n\t RI(Rows(C[1]), n)\n\t)\n )\n));\n\n", "meta": {"hexsha": "9d5d361c3d505eb98c3503902b4ce69114aa0fd0", "size": 8333, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/filtering/toeplitz.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/filtering/toeplitz.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/filtering/toeplitz.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 32.05, "max_line_length": 97, "alphanum_fraction": 0.5088203528, "num_tokens": 2737, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382094310357, "lm_q2_score": 0.6757645944891558, "lm_q1q2_score": 0.5821970187330772}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nClass(VecRaderMid, BaseMat, SumsBase, rec(\n sums := self >> self,\n isReal := False,\n dims := self >> self.dimensions,\n #-----------------------------------------------------------------------\n new := (self, p, k, r, v) >> SPL(WithBases(self,\n rec(p := p, k := k, r := r, v := v, dimensions := [v+_roundup(p-1,v), v+_roundup(p-1,v)]))),\n #-----------------------------------------------------------------------\n area := self >> self.dimensions[1] + 2,\n transpose := self >> self,\n #-----------------------------------------------------------------------\n print := (self,i,is) >> Print(self.name, \"(\", self.p, \", \", self.k, \", \", self.r, \", \", self.v, \")\"),\n #-----------------------------------------------------------------------\n toAMat := self >> self.term().toAMat(),\n rChildren := self >> [],\n from_rChildren := (self, rch) >> self,\n #-----------------------------------------------------------------------\n term := meth(self)\n local dl, d, e0, ep, blk, p, k, root, v;\n p := self.p; k:=self.k; root :=self.r; v:= self.v;\n dl := Concat(TRaderMid.raderDiag(p, k, root), List([p-1..v], i->V(0.0)));\n e0 := Concat([V(1.0)], List([2..v], i->V(0.0)));\n ep := Concat([V(-1/(p-1))], dl{[1..v-1]});\n blk := VBlk([[V(e0),V(e0)],[V(e0),V(ep)]], v).setSymmetric();\n\n if p > 2*v then\n d := VDiag(fStretch(FList(TComplex, dl{[v..p-2]}), _roundup(p-1-v, v), p-1-v), v);\n return DelayedDirectSum(blk, d);\n else\n return blk;\n fi;\n end,\n #-----------------------------------------------------------------------\n stretchCT := meth(self, N)\n local dl, d, e0, ep, blk, p, k, root, v;\n p := self.p;\n k:=self.k;\n root:=self.r;\n v:= self.v;\n dl := fStretch(FList(TComplex, Concat([-1/(p-1)], TRaderMid.raderDiag(p, k, root))), _roundup(N, v), N).tolist();\n d := VDiag(FList(TComplex, Drop(dl, v)), v);\n e0 := Concat([V(1.0)], List([2..v], i->V(0.0)));\n ep := dl{[1..v]};\n blk := VBlk([[e0,e0],[e0,ep]], v).setSymmetric();\n return DelayedDirectSum(blk, d);\n end,\n #-----------------------------------------------------------------------\n stretchPFA := meth(self, part, N, func)\n local dl, d, e0, ep, blk, p, k, root, v;\n p := self.p;\n k:=self.k;\n root:=self.r;\n v:= self.v;\n# Error();\n dl := fStretch(fCompose(FList(TComplex, Concat([-1/(p-1)], TRaderMid.raderDiag(p, k, root))), func), _roundup(N/part, v), N/part).tolist();\n d := VDiag(FList(TComplex, Drop(dl, v)), v);\n e0 := Concat([V(1.0)], List([2..v], i->V(0.0)));\n ep := dl{[1..v]};\n blk := VBlk([[e0,e0],[e0,ep]], v).setSymmetric();\n return DelayedDirectSum(blk, d);\n end,\n));\n", "meta": {"hexsha": "f8b8a0f4c09f6467155f7a44f29b9e1f7607d109", "size": 2931, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/vector/sigmaspl/rader.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/vector/sigmaspl/rader.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/vector/sigmaspl/rader.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 43.1029411765, "max_line_length": 147, "alphanum_fraction": 0.3998635278, "num_tokens": 861, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339596505965, "lm_q2_score": 0.6926419767901475, "lm_q1q2_score": 0.5816349897902071}}
{"text": "\n## Copyright (c) 2018-2021, Carnegie Mellon University\n## See LICENSE for details\n\nDeclare(MDRConv);\n# From IOPrunedMDRConv, signature (n,h,oblk,opat,iblk,ipat,isFreqData)\n# but this one has oblk=1, iblk=1, opat=ipat=[[0..n(1)-1], ...]\n# Left with n (was [1]), h, (was [2]), isFreqData (was [7]).\nClass(MDRConv, TaggedNonTerminal, rec(\n a_n := self >> self.params[1],\n a_h := self >> self.params[2],\n a_isFreqData := self >> self.params[3],\n\n abbrevs := [\n (n, h) -> Checked(ForAll(n, IsPosIntSym),\n [_unwrap(n), h, false]),\n (n, h, isFreqData) -> Checked(ForAll(n, IsPosIntSym),\n [_unwrap(n), h, isFreqData])\n ],\n dims := self >> let(nprod := Product(self.a_n()),\n [nprod, nprod]),\n isReal := self >> true,\n normalizedArithCost := self >> let(n := self.a_n(),\n IntDouble(5 * n * d_log(n) / d_log(2))),\n TType := TReal,\n terminate := self >> When(self.a_isFreqData(),\n # case of isFreqData = true\n let(nlist := self.a_n(),\n n1 := nlist[1],\n nfreq := RClength(n1)/2, # WAS n1/2 + 1\n nrest := Drop(nlist, 1),\n idft := Tensor(IPRDFT(n1, -1), I(Product(nrest))) *\n Tensor(I(nfreq), L(2*Product(nrest), 2)) *\n Tensor(I(nfreq), RC(MDDFT(nrest, -1))),\n tlist := MatSPL(idft) * self.a_h().list,\n MDRConv(nlist,\n FList(TReal, tlist),\n false).terminate()\n ),\n # case of isFreqData = false\n let(nlist := self.a_n(),\n scat3d := Tensor(List(nlist, n->I(n))::[Mat([[1], [0]])]),\n gath3d := Tensor(List(nlist, n->I(n))::[Mat([[1, 0]])]),\n dft3dr := RC(MDDFT(nlist, -1)),\n idft3dr := RC(MDDFT(nlist, 1)),\n gfd := List((1/Product(nlist)) *\n MatSPL(MDDFT(nlist, 1)) *\n self.a_h().list,\n ComplexAny),\n gdiagr := RC(Diag(gfd)),\n t := gath3d * idft3dr * gdiagr * dft3dr * scat3d,\n t.terminate()\n )\n ), # end of When\n\n hashAs := self >> ApplyFunc(ObjId(self),\n [self.a_n(),\n fUnk(self.a_h().range(),\n self.a_h().domain())]::Drop(self.params, 2))\n));\n\n\n# used to represent convolution with real valued conjugate even symbol\nClass(MDRConvR, MDRConv);\n\n", "meta": {"hexsha": "281270afa7e7dd58ba0d84a9974c9315c9e11759", "size": 2801, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "nonterms/mdrconv.gi", "max_stars_repo_name": "franzfranchetti/spiral-package-fftx", "max_stars_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-15T12:40:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-15T12:40:19.000Z", "max_issues_repo_path": "nonterms/mdrconv.gi", "max_issues_repo_name": "franzfranchetti/spiral-package-fftx", "max_issues_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2021-01-05T20:58:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-18T20:10:45.000Z", "max_forks_repo_path": "nonterms/mdrconv.gi", "max_forks_repo_name": "franzfranchetti/spiral-package-fftx", "max_forks_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-12-14T18:24:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T12:40:20.000Z", "avg_line_length": 42.4393939394, "max_line_length": 79, "alphanum_fraction": 0.4280614066, "num_tokens": 727, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297914570319, "lm_q2_score": 0.6442250928250375, "lm_q1q2_score": 0.580143888493118}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n#\n# Using these \"radix-2\" rules will yield optimal 2nlog(n)-4n+6 \n# arithmetic cost for PRDFT1 (Split-Radix), and an almost equivalent \n# cost of 2nlog(n)-4n+8 for PDHT1 (better than the literature).\n#\n\n# Each entry is J(2) times conjugated twiddle w* times PDHT3(2)=F(2), \n# twiddles are accessed at stride 2.\n# (w^*) * F_2 = [[r,i],[-i,r]] * F_2 = [[r+i, r-i], [r-i], [-i-r]]\nClass(H3_CasTwid, Sym, rec(\n def := (n, k) -> \n\tDirectSum(List([0..n/2-1], j -> let(w := E(2*n)^(k*j),\n\t\t J(2) * Mat([[Re(w)+Im(w), Re(w)-Im(w)],\n\t\t\t [Re(w)-Im(w), -Re(w)-Im(w)]]))))\n));\n\n# These twiddles are combined with PRDFT3(2) (just as for PDHT3 above)\n# since PRDFT3(2,1)=I(2), and PRDFT3(2,-1)=Diag(1,-1) we have the \n# variable 'm' scaling the second column of rotations.\nClass(R3_Twid, Sym, rec(\n def := (n, k) -> let(m := When(k mod 4 = 1, 1, -1), \n\tDirectSum(List([0..n/2-1], j -> let(w := E(2*n)^(k*j),\n\t\t Mat([[Re(w), -Im(w)*m],\n\t\t\t\t[Im(w), Re(w)*m]])))))\n));\n# since IPRDFT2(2,1)=Diag(1,-1), and IPRDFT2(2,-1)=I(2) we have 'm' again,\n# it scales second row\nClass(IR3_Twid, Sym, rec(\n def := (n, k) -> let(m := When(k mod 4 = 1, -1, 1), \n\tDirectSum(List([0..n/2-1], j -> let(w := E(2*n)^(k*j),\n\t\t Mat(2* [ [Re(w), -Im(w)],\n\t\t\t\t m*[Im(w), Re(w)]])))))\n));\n\nRulesFor(PDHT3, rec(\n PDHT3_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ DFT1(P[1]/2, P[2]) ]],\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t RC(LIJ(N/2)) *\n\t\tDirectSum(Tensor(I(N/4), J(2)), I(N/2)) * \n\t\tRC(C[1]) * \n\t\tH3_CasTwid(N,k) *\n\t\tL(N,N/2)\n\t))\n));\nRulesFor(PRDFT3, rec(\n PRDFT3_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ DFT1(P[1]/2, P[2]) ]], # SkewDFT(n, E(4)), and then no twids are necessary\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t RC(LIJ(N/2)) *\n\t\tDiag(BHD(N/2, 1, -1)) *\n\t\tRC(C[1]) * \n\t\tR3_Twid(N,k) *\n\t\tL(N,N/2)\n\t))\n));\nRulesFor(IPRDFT2, rec(\n IPRDFT2_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ DFT1(P[1]/2, P[2]) ]], # SkewDFT(n, E(4)), and then no twids are necessary\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t\tL(N,2) *\n\t\tIR3_Twid(N,k) *\n\t\tRC(C[1]) * \n\t\tDiag(BHD(N/2, 1, -1)) *\n\t RC(LIJ(N/2).transpose())\n\t))\n));\n\nRulesFor(PDHT1, rec(\n PDHT1_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ PDHT1(P[1]/2, P[2]), PDHT3(P[1]/2, P[2]) ]],\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t RC(OddStride(N/2+1, N/4+1)) * \n\t\tDirectSum(C[1], C[2]) * \n\t\tTensor(F(2), I(N/2))\n\t))\n));\n\nRulesFor(PRDFT1, rec(\n PRDFT1_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ PRDFT1(P[1]/2, P[2]), PRDFT3(P[1]/2, P[2]) ]],\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t RC(L_or_OS(N/2+1, Int(N/4)+1)) * \n\t\tDirectSum(C[1], C[2]) * \n\t\tTensor(F(2), I(N/2))\n\t))\n));\nRulesFor(IPRDFT1, rec(\n IPRDFT1_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ IPRDFT1(P[1]/2, P[2]), IPRDFT2(P[1]/2, P[2]) ]],\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t\tTensor(F(2), I(N/2)) *\n\t\tDirectSum(C[1], C[2]) * \n\t RC(OddStride(N/2+1, 2))\n\t))\n));\n\nRulesFor(PRDFT2, rec(\n PRDFT2_CT_Radix2 := rec(\n\tisApplicable := P -> P[1] > 2 and IsEvenInt(P[1]),\n\tallChildren := P -> [[ PRDFT2(P[1]/2, P[2]), PRDFT4(P[1]/2, P[2]) ]],\n\trule := (P,C) -> let(N := P[1], k := P[2], \n\t RC(OddStride(N/2+1, N/4+1)) * \n\t\tDirectSum(C[1], C[2]) * \n\t\tTensor(I(N/2), F(2)) ^ L(N, N/2)\n\t))\n));\n\n# SwitchRules(PRDFT3, [1,3]);\n# SwitchRules(PRDFT1, [1,7]);#H3_CasTwid.cost := n -> 4 + (n/2-1)*6;\n\n#DHT1.cost := n -> n + DHT1.cost(n/2) + DHT3.cost(n/2);\n#DHT3.cost := n -> H3_CasTwid.cost(n) + DFT.cost(n/2);\n\n#DHT1.cost := n -> n + DHT1.cost(n/2) + H3_CasTwid.cost(n/2) + DFT.cost(n/4);\n# DHT1(32) cost = 16*2 (F2) + size 64\n\n# DFT_8 = 56\n# DFT_16 = 168\n# DFT_32 = 456\n# DFT_64 = 1160\n", "meta": {"hexsha": "871caa4577f56b53147a39dfb0d3879647c73b22", "size": 4077, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/realdft/prf_radix2.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/realdft/prf_radix2.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/realdft/prf_radix2.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 30.6541353383, "max_line_length": 99, "alphanum_fraction": 0.5172921266, "num_tokens": 1831, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8902942144788076, "lm_q2_score": 0.6513548714339144, "lm_q1q2_score": 0.5798974736102015}}
{"text": "# Takes two groups, and builds the pregroup underlying the free product of\n# these two groups\n#\n# don't try using this on large groups.\n#\nInstallMethod(PregroupOfFreeProduct, \"for two finite groups\",\n [IsGroup and IsFinite, IsGroup and IsFinite],\nfunction(G, H)\n local i, j, size, table, eltn;\n\n size := Size(G) + Size(H) - 1;\n table := NullMat(size,size);\n\n table{[2..Size(G)]}{[2..Size(G)]} := MultiplicationTable(G){[2..Size(G)]}{[2..Size(G)]};\n table{[Size(G)+1..size]}{[Size(G)+1..size]} := Size(G) - 1 + MultiplicationTable(H){[2..Size(H)]}{[2..Size(H)]};\n\n for i in [Size(G) + 1 .. size ] do\n for j in [Size(G) + 1 .. size ] do\n if table[i][j] = Size(G) then\n table[i][j] := 1;\n fi;\n od;\n od;\n\n for i in [1..size] do\n table[1][i] := i;\n table[i][1] := i;\n od;\n\n eltn := List([1..size], String);\n return PregroupByTable(eltn, table);\nend);\n\n# Pregroup of free product of entered groups\nInstallGlobalFunction(PregroupOfFreeProductList,\nfunction(l)\n local r;\n\n r.groups := l;\n\n return Objectify(PregroupOfFreeProductType, r);\nend);\n\n\nInstallMethod(PregroupByRedRelators,\n \"for a free group, and a list of words of length 3\",\n [ IsFreeGroup, IsList, IsList ],\nfunction(F, rred, inv)\n local rkF, n, enams, table, i, j, r, pg, convert, ic;\n\n rkF := Length(GeneratorsOfGroup(F));\n\n if ForAny(rred, x -> not ( (x in F) and ( Length(x) = 3 ) ) ) then\n Error(\"rred has to be a list of words of length 3 over F\");\n fi;\n\n ic := Length(inv);\n n := 1 + 2 * rkF;\n enams := Concatenation([\"1\"]\n , Concatenation( List([1..rkF],\n x -> [ Concatenation(\"x\", String(x))\n , Concatenation(\"X\", String(x)) ] )));\n table := NullMat(n, n);\n\n # Multiplication by 1\n for i in [1..n] do\n table[1,i] := i;\n table[i,1] := i;\n od;\n\n # Multiplication of mutual inverse generators in\n # Free group\n for i in [2, 4..2 * rkF] do\n table[i, i+1] := 1;\n table[i+1, i] := 1;\n od;\n\n for i in inv do\n table[ 2*i, 2*i] := 1;\n table[ 2*i, 2*i + 1] := 0;\n table[ 2*i + 1, 2*i] := 0;\n table[ 2*i+1 , 2*i+1] := 1;\n\n od;\n\n convert := function(x)\n if x > 0 then\n return 2 * x;\n else\n # involution\n if -x in inv then\n return 2 * (-x);\n else\n return 2 * (-x) + 1;\n fi;\n fi;\n end;\n\n # Enter red relators\n # for r = x * y * z we get \n # - x * y = z^-1\n # - x = z^-1 * y^-1\n # - y * z = x ^ -1\n # - z = y^-1 * x^-1\n # - y = x^-1 * z^-1\n # - y^-1 = z * x\n for r in List(rred, LetterRepAssocWord) do\n table[ convert(r[1]), convert(r[2]) ] := convert(-r[3]);\n table[ convert(-r[3]), convert(-r[2]) ] := convert(r[1]);\n table[ convert(r[2]), convert(r[3]) ] := convert(-r[1]);\n table[ convert(-r[2]), convert(-r[1]) ] := convert(r[3]);\n table[ convert(-r[1]), convert(-r[3]) ] := convert(r[2]);\n table[ convert(r[3]), convert(r[1]) ] := convert(-r[2]);\n od;\n pg := PregroupByTable(enams, table);\n pg!.freegroup := F;\n pg!.convert_word := w -> List(LetterRepAssocWord(w), l -> pg[convert(l)]);\n return pg;\nend);\n\n\n", "meta": {"hexsha": "dcd08b439b34505811e7e801624a6046d945aadd", "size": 3412, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "gap/pregroupconstr.gi", "max_stars_repo_name": "RussWoodroofe/walrus", "max_stars_repo_head_hexsha": "f7a4e3597f288c6d9518aaa39091826dadc864b8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-02T14:55:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-02T14:55:52.000Z", "max_issues_repo_path": "gap/pregroupconstr.gi", "max_issues_repo_name": "RussWoodroofe/walrus", "max_issues_repo_head_hexsha": "f7a4e3597f288c6d9518aaa39091826dadc864b8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2018-11-22T11:15:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-21T13:31:01.000Z", "max_forks_repo_path": "gap/pregroupconstr.gi", "max_forks_repo_name": "RussWoodroofe/walrus", "max_forks_repo_head_hexsha": "f7a4e3597f288c6d9518aaa39091826dadc864b8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-02-11T14:47:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-20T10:22:09.000Z", "avg_line_length": 27.9672131148, "max_line_length": 116, "alphanum_fraction": 0.4938452521, "num_tokens": 1109, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789086703225, "lm_q2_score": 0.7154240079185319, "lm_q1q2_score": 0.5798360691743598}}
{"text": "# Calculate over the field Q(a) where a is a solution to x^2-3 = 0\nx := Indeterminate(Rationals, \"x\");\np := x^2-3;\ne := AlgebraicExtension(Rationals, p);\na := RootOfDefiningPolynomial(e);\n\nb1 := [1, 0] * One(e);\nb2 := [1/2, 1/2*a] * One(e);\n\ns := [-1/2, 1/2*a] * One(e);\nt := [-1/2, -1/2*a] * One(e);\n\nu := s - b1;\nv := t - b1;\n\nToFloat := function(element)\n local coefficients;\n coefficients := ExtRepOfObj(element);\n return Float(coefficients[1]) + Sqrt(3.0)*Float(coefficients[2]);\nend;\n\nscale := 4;\nn := 3;\nradius := 2*Ceil(n/2.0);\n\npoints := [];\nfor a in [-n..n] do\n for b in [-n..n] do\n for c in [b1, b2] do\n w := (a*u + b*v) + c;\n norm := ToFloat(w * w);\n if norm <= radius^2 then\n w := scale * w;\n Add(points, w);\n fi;\n od;\n od;\nod;\n\nPrintToConsole := function(index, element)\n Print(element, \"\\n\");\nend;\n\npsFile := \"data.ps\";\nPrintToPS := function(index, element)\n AppendTo(psFile, \"\\t[\", ToFloat(element[1]), \" \", ToFloat(element[2]), \"]\\n\"); \nend;\n\ntspFile := \"data.tsp\";\nPrintToTSP := function(index, element)\n AppendTo(tspFile, index, \" \", ToFloat(element[1]), \" \", ToFloat(element[2]), \"\\n\");\nend;\n\nheader := Concatenation(\"NAME: hex-paper\\n\\\nTYPE: TSP\\n\\\nCOMMENT: Taking concorde for a run on a small problem\\n\\\nDIMENSION: \", String(Length(points)), \"\\n\\\nEDGE_WEIGHT_TYPE: EUC_2D\\n\\\nNODE_COORD_TYPE: TWOD_COORDS\\n\\\nNODE_COORD_SECTION:\\n\");\n \nPrintTo(psFile);\nPrintTo(tspFile, header);\n\nindex := 0;\nfor w in points do\n PrintToConsole(index, w);\n PrintToPS(index, w);\n PrintToTSP(index, w);\n index := index + 1;\nod;", "meta": {"hexsha": "24857707766fa5a97146e5d72279f8beaf57c9cb", "size": 1580, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "hex.gap", "max_stars_repo_name": "dvberkel/hexpaper-tsp", "max_stars_repo_head_hexsha": "7d49f74ef448686982ac1c624dc03d6211aa7505", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "hex.gap", "max_issues_repo_name": "dvberkel/hexpaper-tsp", "max_issues_repo_head_hexsha": "7d49f74ef448686982ac1c624dc03d6211aa7505", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hex.gap", "max_forks_repo_name": "dvberkel/hexpaper-tsp", "max_forks_repo_head_hexsha": "7d49f74ef448686982ac1c624dc03d6211aa7505", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.2535211268, "max_line_length": 85, "alphanum_fraction": 0.603164557, "num_tokens": 545, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8757869981319862, "lm_q2_score": 0.6619228825191872, "lm_q1q2_score": 0.5797034542763503}}
{"text": "################################################################################\n##\n#W DwG_rank.gi GroupTheoretical Package\n##\n#W Paul Bruillard, Cesar Galindo, Siu-Hung Ng, Julia Plavnik, Eric Rowell, \n#W Zhenghan Wang\n##\n## Installation file for DwG_rank functions of the GroupTheoretical Package\n##\n#Y Copyright (C) 2016, Battelle Memorial Institute\n##\n################################################################################\n\n\n###############################################################################\n##\n#F DwG_rank(<group>,<bool>). . . . . . . .compute rank of D^w(G)\n##\nInstallGlobalFunction(DwG_rank, function(G,display)\n local A,R,C,CH,H,classes,cs,fs,CC,Counter,f,DwG_rank,x,Zx,ZxReps,alpha_regular,g,is_alpha_regular,Zg_in_Zx,h,alpha_g_h,alpha_h_g,DwG_ranks,last_rank,H3G;\n\n # compute H_3(G,Z)\n H3G:=GroupHomology(G,3);;\n A:=CyclicGroup(Lcm(H3G));;\n #A:=CyclicGroup(Order(G));\n A:=TrivialGModuleAsGOuterGroup(G,A);;\n R:=ResolutionFiniteGroup(G,4);;\n C:=HomToGModule(R,A);;\n CH:=CohomologyModule(C,3);;\n H:=ActedGroup(CH);\n classes:=Elements(ActedGroup(CH));;\n Print(Length(classes));;\n Print(\"\\n Cohomology group:\");;\n Print(StructureDescription(H));;\n Print(\"\\n\");\n\n # get the 3-cocycle rerpresenting the second cohomology classes\n cs:=List(classes,x->CH!.representativeCocycle(x));\n\n # get a cocycle f:GxGxG->A corresponding to this cohomology class\n fs:=List(cs,x->Mapping(x));\n\n # get group conjugacy class represenatives\n CC:=List(ConjugacyClasses(G),Representative);;\n\n # for each cocycle f and each conjugacy class x compute alpha the 2-cocycle on\n # the centralizer\n Counter:=0;\n DwG_ranks:=[];\n for f in fs\n do\n Counter:=Counter+1;\n DwG_rank:=0;\n for x in CC\n do\n # compute the centralizer of X\n Zx:=Centralizer(G,x);;\n ZxReps:=List(ConjugacyClasses(Zx),Representative); # compute the alpha-regular elements of Zx\n alpha_regular:=[];;\n for g in ZxReps\n do\n is_alpha_regular:=true;;\n Zg_in_Zx:=Centralizer(Zx,g);\n for h in Zg_in_Zx\n do\n alpha_g_h:=f(g,h,x)*f(x,g,h)*(f(g,x,h)^-1);;\n alpha_h_g:=f(h,g,x)*f(x,h,g)*(f(h,x,g)^-1);;\n if not(alpha_g_h=alpha_h_g) then\n is_alpha_regular:=false;;\n break;;\n fi;\n od;\n if is_alpha_regular=true then\n Append(alpha_regular,[g]);\n DwG_rank:=DwG_rank+1;\n fi;\n od;\n od;\n if display then\n Print(\"\\nThe cohomology class is: \");\n Print(classes[Counter]);\n Print(\"\\nRank is: \");\n Print(DwG_rank);\n else\n Print(\".\");\n fi;\n Append(DwG_ranks,[[classes[Counter],DwG_rank]]);\n if Counter=1 then\n last_rank:=DwG_rank;\n fi;\n od;\n Print(\"\\n\");\n\n return DwG_ranks;;\nend);\n\n#E DwG_rank.gi . . . . . . . . . . . . . . . . . . . . . . . . . . . . ends here\n", "meta": {"hexsha": "4e6697658837ff3606fcdac02484ed775082f0ce", "size": 2874, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/DwG_rank.gi", "max_stars_repo_name": "pnnl/GroupTheoretical", "max_stars_repo_head_hexsha": "d60aaec27d2ca98ec55b12b78213538a346eef27", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/DwG_rank.gi", "max_issues_repo_name": "pnnl/GroupTheoretical", "max_issues_repo_head_hexsha": "d60aaec27d2ca98ec55b12b78213538a346eef27", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-20T21:43:28.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-20T21:43:28.000Z", "max_forks_repo_path": "lib/DwG_rank.gi", "max_forks_repo_name": "pnnl/GroupTheoretical", "max_forks_repo_head_hexsha": "d60aaec27d2ca98ec55b12b78213538a346eef27", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-12-07T13:46:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-12T22:39:35.000Z", "avg_line_length": 29.3265306122, "max_line_length": 155, "alphanum_fraction": 0.5668058455, "num_tokens": 841, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392695254319, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5789526578784581}}
{"text": "##############################################################\n##\n## Helps compute the decomposition of\n## the ramification module and the equivariant\n## degree of a multiple of a simple orbit for\n## the modular curves X(p) with automorphism group\n## G = PSL(2,p), p a prime.\n##\n## Using these computations and Borne's formula, the\n## G-module structure of the RR spaces of equivariant\n## divisors can be determined explicitly.\n##\n## Reference: D. Joyner and A. Ksir, \"Modular representations\n## on some Riemann-Roch spaces of modular curves\n## $X(N)$, Computational Aspects of Algebraic Curves,\n## (Editor: T. Shaska) Lecture Notes in Computing,\n## WorldScientific, 2005.)\n##\n##\n## 12-30-2004, wdj\n###########################################################\n\n## To read this in, use for example:\n### Read(\"/home/wdj/gapfiles/curves/mod_crv_aut_gp3.gap\");\n## To log your results, use for example:\n### LogTo(\"/home/wdj/gapfiles/mod_crv_aut_gp1.log\");\n\nram_module_X:=function(p)\n## p is a prime\n## output is [m1,...,mn]\n## where n = # conj classes of G=PSL(2,p)\n## and mi = mult of pi_i in ram mod of modular curve\n## X with AutGp(X) = G.\n## Here Irr(G) = [pi_1,...,pi_n] (in that order).\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,w,m,theta,pi_theta_to_the;\n G:=PSL(2,p);\n H:=[];\n H_chars:=[];\n n0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\n CG:=ConjugacyClassesSubgroups(G);\n H[1]:=Representative(CG[2]); # size 2\n H[2]:=Representative(CG[3]); # size 3\n n :=Size(CG);\n for i in [1..n] do\n if Size(Representative(CG[i]))=p then\n H[3]:=Representative(CG[i]);\n fi;\n od;\n## H[3]:=Group(n0); # size p\n for i in [1..Size(H)] do\n H_chars[i]:=Irr(H[i]);\n od;\n G_chars:=Irr(G);\n m:=[];\n m[1]:=[];m[2]:=[];m[3]:=[];\n theta:=List([1..3],i->H_chars[i][2]);\n pi_theta_to_the:=List([1..3],i->Sum([1..(Size(H[i])-1)],\n j->j*InducedClassFunction(theta[i]^(j),G)));\n#Print(\"\\n\\n pi_theta_to_the = \",Sum(pi_theta_to_the),\"\\n\\n\");\n for i in [1..3] do\n m[i]:=List(G_chars, pi->ScalarProduct(pi_theta_to_the[i],pi))/Size(H[i]);\n od;\n#Print(\"\\n\\n m = \",m,\"\\n\\n\");\nreturn Sum(m);\nend;\n\n#ram_module_X(5);\n#[ 0, 3, 3, 4, 5 ]\n#ram_module_X(7);\n#[ 0, 4, 3, 6, 7, 8 ]\n#ram_module_X(11);\n#[ 0, 5, 6, 11, 10, 12, 12, 12 ]\n#ram_module_X(13);\n#[ 0, 7, 7, 13, 13, 13, 13, 14, 15 ]\n#ram_module_X(17);\n#[ 0, 9, 9, 18, 17, 17, 17, 18, 18, 19, 19 ]\n#ram_module_X(19);\n#[ 0, 9, 10, 20, 20, 19, 19, 20, 20, 21, 21, 21 ]\n#ram_module_X(23);\n#[ 0, 14, 11, 24, 24, 24, 23, 23, 25, 25, 25, 25, 25, 25 ]\n#ram_module_X(29);\n#[ 0, 16, 16, 30, 31, 31, 30, 30, 30, 30, 31, 32, 32, 32, 31, 31, 31 ]\n#ram_module_X(31);\n#[ 0, 18, 15, 33, 33, 33, 32, 32, 32, 32, 33, 34, 33, 33, 34, 34, 34, 34 ]\n#ram_module_X(37);\n#[ 0, 20, 20, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 40, 39, 41, 41, 41, 40, 40, 40 ]\n\nram_module_X_JK:=function(p)\n## p is a prime\n## output is (m1,...,mn)\n## where n = # conj classes of G=PSL(2,p)\n## and mi = \"mult of pi_i in ram mod of G\" using JK formula\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,A,B,C,D,pi;\n G:=PSL(2,p);\n H:=[];\n H_chars:=[];\n n0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\n CG:=ConjugacyClassesSubgroups(G);\n H[1]:=Representative(CG[2]); # size 2\n H[2]:=Representative(CG[3]); # size 3\n n:=Size(CG);\n for i in [1..n] do\n if Size(Representative(CG[i]))=p then\n H[3]:=Representative(CG[i]);\n fi;\n od;\n## H[3]:=Group(n0); # size p\n for i in [1..Size(H)] do\n H_chars[i]:=Irr(H[i]);\n od;\n G_chars:=Irr(G);\n n:=Length(G_chars);\n A:=[];\n for i in [1..n] do\n pi:=G_chars[i];\n A[i]:=ScalarProduct(H_chars[1][1],RestrictedClassFunction(pi,H[1]));\n od;\n B:=[];\n for i in [1..n] do\n pi:=G_chars[i];\n B[i]:=ScalarProduct(H_chars[2][1],RestrictedClassFunction(pi,H[2]));\n od;\n C:=[];\n for i in [1..n] do\n pi:=G_chars[i];\n C[i]:=ScalarProduct(H_chars[3][1],RestrictedClassFunction(pi,H[3]));\n od;\n D:=[];\n for i in [1..n] do\n pi:=G_chars[i];\n D[i]:=DegreeOfCharacter(pi);\n od;\n return (1/2)*(3*D-A-B-C);\nend;\n\n#ram_module_X_JK(5);\n#[ 0, 3, 3, 4, 5 ]\n#ram_module_X_JK(7);\n#[ 0, 7/2, 7/2, 6, 7, 8 ]\n#ram_module_X_JK(11);\n#[ 0, 11/2, 11/2, 11, 10, 12, 12, 12 ]\n#ram_module_X_JK(13);\n#[ 0, 7, 7, 13, 13, 13, 13, 15, 14 ]\n#ram_module_X_JK(17);\n#[ 0, 9, 9, 18, 17, 17, 17, 18, 18, 19, 19 ]\n#ram_module_X_JK(19);\n#[ 0, 19/2, 19/2, 20, 20, 19, 19, 20, 20, 21, 21, 21 ]\n#ram_module_X_JK(23);\n#[ 0, 25/2, 25/2, 24, 24, 24, 23, 23, 25, 25, 25, 25, 25, 25 ]\n#ram_module_X_JK(29);\n#[ 0, 16, 16, 30, 31, 31, 30, 30, 30, 30, 31, 32, 32, 32, 31, 31, 31 ]\n\npieces_ram_module_X:=function(p)\n## p is a prime\n## output is (m1,...,mn)\n## where n = # conj classes of G=PSL(2,p)\n## and mi = mult of pi_i in ram mod of G\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,w,m,theta,pi_theta_to_the;\n G:=PSL(2,p);\n H:=[];\n H_chars:=[];\n n0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\n CG:=ConjugacyClassesSubgroups(G);\n H[1]:=Representative(CG[2]); # size 2\n H[2]:=Representative(CG[3]); # size 3\n n :=Size(CG);\n for i in [1..n] do\n if Size(Representative(CG[i]))=p then\n H[3]:=Representative(CG[i]);\n fi;\n od;\n## H[3]:=Group(n0); # size p\n for i in [1..Size(H)] do\n H_chars[i]:=Irr(H[i]);\n od;\n G_chars:=Irr(G);\n m:=[];\n m[1]:=[];m[2]:=[];m[3]:=[];\n theta:=List([1..3],i->H_chars[i][2]);\n pi_theta_to_the:=List([1..3],i->Sum([1..(Size(H[i])-1)],\n j->j*InducedClassFunction(theta[i]^(j),G)));\n#Print(\"\\n\\n pi_theta_to_the = \",Sum(pi_theta_to_the),\"\\n\\n\");\n for i in [1..3] do\n m[i]:=List(G_chars, pi->ScalarProduct(pi_theta_to_the[i],pi));\n od;\n#Print(\"\\n\\n m = \",m,\"\\n\\n\");\nreturn m;\nend;\n\nequiv_deg_module_X:=function(p,ii,r)\n## p is a prime\n## ii = 1 for H[1], size 2\n## ii = 2 for H[2], size 3\n## ii = 3 for H[3], size p\n## output is (m1,...,mn)\n## where n = # conj classes of G=PSL(2,p)\n## and mi = mult of pi_i in deg_equiv module of G\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,w,m,theta,pi_theta,pi_theta_to_the;\nG:=PSL(2,p);\nH:=[]; # 3 decomp gps\nH_chars:=[];\nn0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\nCG:=ConjugacyClassesSubgroups(G);\nH[1]:=Representative(CG[2]); # size 2\nH[2]:=Representative(CG[3]); # size 3\nn:=Size(CG);\nfor i in [1..n] do\n if Size(Representative(CG[i]))=p then\n H[3]:=Representative(CG[i]);\n fi;\nod;\n## H[3]:=Group(n0); # size p\nfor i in [1..3] do\n H_chars[i]:=Irr(H[i]);\nod;\nG_chars:=Irr(G);\nm:=[];\nm[1]:=[];m[2]:=[];m[3]:=[];\ntheta:=List([1..3],i->H_chars[i][2]);\npi_theta_to_the:=List([1..3],i->List([1..r],j->InducedClassFunction(theta[i]^(-j),G)));\nfor i in [1..3] do\n for j in [1..r] do\n m[i][j]:=List(G_chars, pi->ScalarProduct(pi_theta_to_the[i][j],pi));\n od;\nod;\nreturn Sum(m[ii]);\nend;\n\n\n# equiv_deg_module_X(7,2,1);\n#[ 0, 1, 1, 2, 2, 3 ]\n# equiv_deg_module_X(7,1,1);\n#[ 0, 2, 2, 2, 4, 4 ]\n# equiv_deg_module_X(7,3,1);\n#[ 0, 1, 0, 1, 1, 1 ]\n# equiv_deg_module_X(7,3,7);\n#[ 1, 3, 3, 6, 7, 8 ]\n# equiv_deg_module_X(7,1,2);\n#[ 1, 3, 3, 6, 7, 8 ]\n", "meta": {"hexsha": "e281ff178cec5c62b92ba04528016b578f24bf8b", "size": 7030, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "src/ext/gap/joyner/modular_crv_rr_sp.gap", "max_stars_repo_name": "bopopescu/sage", "max_stars_repo_head_hexsha": "2d495be78e0bdc7a0a635454290b27bb4f5f70f0", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1742, "max_stars_repo_stars_event_min_datetime": "2015-01-04T07:06:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T11:32:52.000Z", "max_issues_repo_path": "src/sage/ext_data/gap/joyner/modular_crv_rr_sp.gap", "max_issues_repo_name": "Ivo-Maffei/sage", "max_issues_repo_head_hexsha": "467fbc70a08b552b3de33d9065204ee9cbfb02c7", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 66, "max_issues_repo_issues_event_min_datetime": "2015-03-19T19:17:24.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-16T11:59:30.000Z", "max_forks_repo_path": "src/sage/ext_data/gap/joyner/modular_crv_rr_sp.gap", "max_forks_repo_name": "dimpase/sage", "max_forks_repo_head_hexsha": "468f23815ade42a2192b0a9cd378de8fdc594dcd", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 495, "max_forks_repo_forks_event_min_datetime": "2015-01-10T10:23:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T22:06:11.000Z", "avg_line_length": 28.8114754098, "max_line_length": 87, "alphanum_fraction": 0.5516358464, "num_tokens": 2943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199673867852, "lm_q2_score": 0.6893056231680121, "lm_q1q2_score": 0.577376153597518}}
{"text": "\nInstallMethod(AlgebraicU,\n \"Simple algebraic of adjoint type\",\n [IsString,IsPosInt,IsRing],\n function(Type,Rank,Ring)\n local object,\n avarnames;\n object:=Objectify(NewType(NewFamily(\"AlgebraicUFamily\"),\n IsAttributeStoringRep and\n IsChevalleyAdj and\n IsAlgebraicU),\n rec());\n\n Settype(object,Type);\n Setrank(object,Rank);\n\n SetchevalleyAdj(object,ChevalleyAdj(Type,Rank,Ring));\n\n SetBaseRing(object,Ring);\n avarnames:=List([1..2*Length(positiveRoots(chevalleyAdj(object)))],i->Concatenation(\"a_{\",String(i),\"}\"));\n Setring(object,PolynomialRing(Ring,avarnames));\n\n SetCharacteristic(object,Characteristic(Ring));\n\n SetlieAlgebra(object,SimpleLieAlgebraTypeA_G(Type,Rank,ring(object)));\n SetrootSystem(object,RootSystem(SimpleLieAlgebra(Type,Rank,Integers)));\n SetpositiveRoots(object,positiveRoots(rootSystem(object)));\n SetallRoots(object,Concatenation(\n positiveRoots(rootSystem(object)),\n -positiveRoots(rootSystem(object))));\n SetweylGroup(object,WeylGroup(rootSystem(object)));\n\n SetA(object,A_rs(object));\n SetH(object,Eta(object));\n SetN(object,N_rs(object));\n SetM(object,M_rsi(object));\n SetC(object,C_ijrs(object));\n\n SetName(object,Concatenation(\"<simple adjoint \",Type,String(Rank),\n \" in characteristic \",String(Characteristic(Ring)),\">\"));\n \n return object;\nend);\n\nInstallMethod(AlgebraicU,\n \"Simple algebraic of adjoint type\",\n [IsChevalleyAdj],\n function(sys)\n local object,\n avarnames;\n object:=Objectify(NewType(NewFamily(\"AlgebraicUFamily\"),\n IsAttributeStoringRep and\n IsChevalleyAdj and\n IsAlgebraicU),\n rec());\n\n Settype(object,type(sys));\n Setrank(object,rank(sys));\n\n avarnames:=List([1..2*Length(positiveRoots(sys))],i->Concatenation(\"a_{\",String(i),\"}\"));\n Setring(object,PolynomialRing(ring(sys),avarnames));\n\n SetCharacteristic(object,Characteristic(sys));\n\n SetlieAlgebra(object,SimpleLieAlgebraTypeA_G(type(object),rank(object),ring(object)));\n SetrootSystem(object,rootSystem(sys));\n SetpositiveRoots(object,positiveRoots(sys));\n SetallRoots(object,allRoots(sys));\n SetweylGroup(object,weylGroup(sys));\n\n SetA(object,A(sys));\n SetH(object,H(sys));\n SetN(object,N(sys));\n SetM(object,M(sys));\n SetC(object,C(sys));\n\n SetBaseRing(object,ring(sys));\n SetchevalleyAdj(object,sys);\n\n SetName(object,Concatenation(\"<simple adjoint \",type(object),String(rank(object)),\n \" in characteristic \",String(Characteristic(object)),\">\"));\n \n return object;\nend);\n\n", "meta": {"hexsha": "6091c1cd0a06c6d3dc767ab4c1fd0439f0593462", "size": 3470, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/algU.gi", "max_stars_repo_name": "iuliansimion/Chevalley.gap", "max_stars_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/algU.gi", "max_issues_repo_name": "iuliansimion/Chevalley.gap", "max_issues_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/algU.gi", "max_forks_repo_name": "iuliansimion/Chevalley.gap", "max_forks_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.3488372093, "max_line_length": 120, "alphanum_fraction": 0.5207492795, "num_tokens": 684, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744850834649, "lm_q2_score": 0.7057850154599562, "lm_q1q2_score": 0.577031820594299}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nRulesFor(DCT2, rec(\n #F DCT2_DCT2and4: 1977\n #F\n #F DCT2_n = perm * (DCT2_n/2 dirsum DCT4_n/2^perm) * (1 tensor DFT_2)^perm\n #F\n #F Chen/Fralick/Smith: \n #F A Fast Computational Algorithm for the\n #F Discrete Cosine Transform, IEEE Trans. on Comm., 1977, pp. 1004--1009.\n #F Wang: \n #F Reconsideration of --above--\n #F Circ., Systems, and Signal Proc., 1983, 121--123.\n #F Rao/Yip: \n #F Discrete Cosine Transform, Academic Press, 1990, pp. 53\n #F\n DCT2_DCT2and4 := rec(\n\tinfo := \"DCT2'_n --> DCT2'_n/2, DCT4_n/2\",\n\tisApplicable := P -> P[1] > 2 and P[1] mod 2 = 0,\n\tallChildren := P -> [[ DCT2(P[1]/2), DCT4(P[1]/2) ]],\n\trule := (P, C) -> \n\t LIJ(P[1]) *\n\t DirectSum(C[1], C[2] ^ J(P[1]/2)) *\n\t Tensor(I(Int((P[1] / 2))), F(2)) ^ LIJ(P[1]) # this line was blocks1(P[1])\n ),\n\n #F DCT2_toRDFT:\n #F\n #F DCT2_n = blocks * RDFT_n * perm\n #F \n #F for n even\n #F\n DCT2_toRDFT := rec (\n\tinfo := \"DCT2_n -> RDFT_n\",\n\tisApplicable := P -> IsEvenInt(P[1]), \n\tallChildren := P -> [[ SRDFT(P[1]) ]], \n\n\trule := (P, C) -> let(i := Ind(P[1]/2-1),\n # first an X shaped matrix where opposite diagonal is lowered by 1\n LIJ(P[1]).transpose() *\n\t DirectSum(I(1), \n\t\t When(i.range > 0, IterDirectSum(i, i.range, Rot(fdiv(1+i, 2*P[1]))*J(2)), []),\n\t\t Diag(Sqrt(1/2))) *\n\t C[1] * K(P[1], 2)\n\t)\n ),\n#rdft = d os dct p7\n#dct = os^-1 d^-1 rdft * p7^-1\n DCT2_toRDFT_odd := rec(\n\tinfo := \"DCT2_n -> RDFT_n\",\n\tisApplicable := P -> IsOddInt(P[1]),\n allChildren := P -> [[ PRDFT1(P[1]) ]], \n\tforTransposition := true,\n\trule := (P, C) -> let(N := P[1], \n\t OS(N, 2).transpose() *\n\t Diag(List([0..N-1], i -> (-1)^i)) *\n\t DirectSum(Mat([[1,0]]), LIJ(N-1).transpose()) *\n\t C[1] *\n\t perm7(N).transpose()\n\t)\n ),\n\n #F DCT2_PrimePowerInduction:\n #F\n #F DCT2'_n = perm * sparse * (1 tensor DCT2'_n/3) * \n #F ( dirsum of 3x3 blocks ) ^ perm * perm\n #F\n #F Pueschel/Moura: Discrete Cosine and Sine Transforms\n #F \n DCT2_PrimePowerInduction := rec (\n\tinfo := \"DCT2_3n -> DCT2_n\",\n\tisApplicable := P -> P[1] mod 3 = 0 and P[1] <> 3,\n\tallChildren := P -> [[ DCT2(P[1]/3) ]],\n\n # the sparse matrix occuring in the rule; it has the form\n # [ [ I_n, Z_n ], [ Z_n, I_n ] ], Z_n has only 1's on the upper \n # diagonal; n = L/3\n\tsparsemat := function ( n )\n\t local L, i;\n # diagonal 1's\n\t L := List([1..2*n], i -> [i, i, 1]);\n # the other 1's\n\t for i in [1..n-1] do Add(L, [i, n+1+i, 1]); od;\n\t for i in [1..n-1] do Add(L, [n+i, i+1, 1]); od;\n\t return Sparse(L);\n\tend,\n\n # the 3x3 blocks occuring; so to say the twiddle factors\n # note: the block for i = (n-1)/2 is a DCT of size 3 and can be done\n # in 4 adds, 2 mults; but here only in 5 adds and 2 mults\n\tblock3 := function ( i, n )\n\t local M, H, M1, ii;\n\t ii := i + 1/2;\n\t M := TransposedMat(\n\t\t[ [ 1, 1, 1 ],\n\t\t [CosPi( ii/(3*n)), CosPi( (2*n-ii)/(3*n)), CosPi( (2*n+ii)/(3*n))],\n\t\t [CosPi(2*ii/(3*n)), CosPi(2*(2*n-ii)/(3*n)), CosPi(2*(2*n+ii)/(3*n))] ]\n\t );\n\t M := 3 * DiagonalMat([1, 1/2, 1/2]) * M^-1;\n # now M has 1's in the first row\n\t H := [[1, 1, 1], [1, -1, 0], [1, 0, -1]];\n\t M1 := M*H^-1;\n # M*H has the structure 1 dirsum 2x2 block\n # get the 2x2 block\n\t M1 := Sublist(List(M1, r -> Sublist(r, [2,3])), [2,3]);\n\t return DirectSum(I(1), Mat(M1)) * Mat(H);\n\tend,\n\n\trule := (self, P, C) >> let(n := P[1]/3, \n\t L(3*n, n) *\n\t DirectSum(I(n), self.sparsemat(n)) *\n\t Tensor(I(3), C[1]) *\n\t (DirectSum(List([1..n], i -> self.block3(i, n))) ^ L(3*n, n)) *\n\t IJ(3*n, n))\n ),\n\n#F DCT2_PrimeFactor: 1985\n#F\n#F DCT2_nm = P1 * (1_(n+m-1) dirsum (1_(nm-n-m+1) tensor F_2)) *\n#F P2 * (DCT2_n tensor DCT2_m) * P3, gcd(n, m) = 1\n#F\n#F Yang/Narasimha: Prime Factor Decomposition of the Discrete Cosine Transform,\n#F Proc. ICASSP, pp. 772--775, 1985\n#F\n#F see also:\n#F Feig/Linzer: Scaled DCT's on Input Sizes that Are Composite, IEEE Transactions on \n#F Signal Processing 43(1), pp. 43--50, 1995\n#F\nDCT2_PrimeFactor := rec (\n info := \"DCT2_nm -> DCT2_n tensor DCT2_m\",\n isApplicable := P -> not IsPrimePowerInt(P[1]), \n allChildren := P -> List(DivisorPairsRP(P[1]), p -> [ DCT2(p[1]), DCT2(p[2]) ]),\n\n rule := function ( P, C )\n local n, n1, n2, dctperm1, dctperm2;\n\n n1 := C[1].dimensions[1];\n n2 := C[2].dimensions[1];\n n := P[1];\n\n # first permutation\n dctperm1 := function ( n1, n2 )\n local n, g1, g2, L, i, j;\n\n n := n1*n2; \n g1 := QuotientMod(1, n2, n1);\n g2 := n2 - QuotientMod(1, n1, n2);\n\n # indices\n L := [ ];\n for i in [0..n1 - 1] do\n\tfor j in [0..n2 - 1] do\n\t if (i + j) mod 2 = 0 then\n\t Add(L, ((2*i + 1)*g1*n2 - (2*j + 1)*g2*n1) mod (4*n));\n\t else\n\t Add(L, ((2*i + 1)*g1*n2 + (2*j + 1)*g2*n1) mod (4*n));\n\t fi;\n\tod;\n od;\n\n for i in [1..Length(L)] do\n\tif L[i] < 2*n then\n\t L[i] := (L[i] - 1)/2;\n\telse\n\t L[i] := (4*n - L[i] - 1)/2;\n\tfi;\n od;\n\n return PermList(L + 1);\n end;\n\n # second and third permutation\n dctperm2 := function ( n1, n2 )\n local n, K, L, i, j, q2;\n\n n := n1*n2;\n\n L := [ ];\n K := [ ];\n\n # start with the border\n # i = 0\n for j in [0..n2 - 1] do\n\tAdd(L, j);\n\tAdd(K, j*n1);\n od;\n\n # j = 0\n for i in [1..n1 - 1] do\n\tAdd(L, i*n2);\n\tAdd(K, i*n2);\n od;\n\n # now the interior; two cases\n if n1 mod 2 = 0 then\n\tfor i in [1..n1/2 - 1] do\n\t for j in [1..n2 - 1] do\n\t q2 := i*n2 + j*n1;\n\t if q2 > n then\n\t q2 := q2 - 2*n;\n\t Add(L, (n1 - i)*n2 + (n2 - j));\n\t Add(L, i*n2 + j);\n\t else\n\t Add(L, i*n2 + j);\n\t Add(L, (n1 - i)*n2 + (n2 - j));\n\t fi;\n\t Add(K, AbsInt(i*n2 - j*n1));\n\t Add(K, AbsInt(q2));\n\t od;\n\tod;\n\ti := n1/2;\n\tfor j in [1..(n2 - 1)/2] do\n\t q2 := i*n2 + j*n1;\n\t if q2 > n then\n\t q2 := q2 - 2*n;\n\t Add(L, (n1 - i)*n2 + (n2 - j));\n\t Add(L, i*n2 + j);\n\t else\n\t Add(L, i*n2 + j);\n\t Add(L, (n1 - i)*n2 + (n2 - j));\n\t fi;\n\t Add(K, AbsInt(i*n2 - j*n1));\n\t Add(K, AbsInt(q2));\n\tod;\n else # n1 mod 2 <> 0\n\tfor i in [1..(n1 - 1)/2] do\n\t for j in [1..n2 - 1] do\n\t q2 := i*n2 + j*n1;\n\t if q2 > n then\n\t q2 := q2 - 2*n;\n\t Add(L, (n1 - i)*n2 + (n2 - j));\n\t Add(L, i*n2 + j);\n\t else\n\t Add(L, i*n2 + j);\n\t Add(L, (n1 - i)*n2 + (n2 - j));\n\t fi;\n\t Add(K, AbsInt(i*n2 - j*n1));\n\t Add(K, AbsInt(q2));\n\t od;\n\tod;\n fi;\n\n return [PermList(L + 1), PermList(K + 1)];\n end;\n\n # actual rule\n return\n Perm(dctperm2(n1, n2)[2]^-1, n) *\n DirectSum(\n\tI(n1 + n2 - 1),\n\tTensor(I((n - n1 - n2 + 1)/2), F(2))\n ) *\n Perm(dctperm2(n1, n2)[1], n) *\n Tensor(C) *\n Perm(dctperm1(n1, n2), n);\n end\n)\n));\n", "meta": {"hexsha": "cb0225c9488a0d9b232787ae6dbbaad55925699b", "size": 7143, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/dct_dst/dct2rules.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/dct_dst/dct2rules.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/dct_dst/dct2rules.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 27.2633587786, "max_line_length": 87, "alphanum_fraction": 0.4720705586, "num_tokens": 2926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673178375734, "lm_q2_score": 0.7090191337850932, "lm_q1q2_score": 0.5763384815754083}}
{"text": "\nInstallMethod(ChevalleyAdj,\n \"Simple algebraic of adjoint type\",\n [IsString,IsPosInt,IsRing],\n function(Type,Rank,Ring)\n local object,test;\n object:=Objectify(NewType(NewFamily(\"ChevalleyAdjFamily\"),\n IsAttributeStoringRep and\n IsChevalleyAdj),\n rec());\n\n Settype(object,Type);\n Setrank(object,Rank);\n\n SetlieAlgebra(object,SimpleLieAlgebraTypeA_G(Type,Rank,Ring));\n SetrootSystem(object,RootSystem(SimpleLieAlgebraTypeA_G(Type,Rank,Integers)));\n SetpositiveRoots(object,positiveRoots(rootSystem(object)));\n SetallRoots(object,Concatenation(\n positiveRoots(rootSystem(object)),\n -positiveRoots(rootSystem(object))));\n SetweylGroup(object,WeylGroup(rootSystem(object)));\n\n\n Setring(object,Ring);\n\n SetCharacteristic(object,Characteristic(Ring));\n\n\n SetA(object,A_rs(object));\n SetN(object,N_rs(object));\n SetH(object,Eta(object));\n SetM(object,M_rsi(object));\n SetC(object,C_ijrs(object));\n\n SetName(object,Concatenation(\"<simple adjoint \",Type,String(Rank),\n \" in characteristic \",String(Characteristic(Ring)),\">\"));\n \n return object;\nend);\n\nInstallMethod(ChevalleyAdj,\n \"Simple algebraic of adjoint type\",\n [IsChevalleyAdj,IsRing],\n function(sys,Ring)\n local object;\n object:=Objectify(NewType(NewFamily(\"ChevalleyAdjFamily\"),\n IsAttributeStoringRep and\n IsChevalleyAdj),\n rec());\n\n Settype(object,type(sys));\n Setrank(object,rank(sys));\n\n SetlieAlgebra(object,SimpleLieAlgebraTypeA_G(type(object),rank(object),Ring));\n SetrootSystem(object,rootSystem(sys));\n SetpositiveRoots(object,positiveRoots(sys));\n SetallRoots(object,allRoots(sys));\n SetweylGroup(object,weylGroup(sys));\n\n Setring(object,Ring);\n\n SetCharacteristic(object,Characteristic(Ring));\n\n SetA(object,A(sys));\n SetH(object,H(sys));\n SetN(object,N(sys));\n SetM(object,M(sys));\n SetC(object,C(sys));\n\n SetName(object,Concatenation(\"<simple adjoint \",type(object),String(rank(object)),\n \" in characteristic \",String(Characteristic(object)),\">\"));\n \n return object;\nend);\n\nInstallMethod(A_rs,\n \"Extended Cartan Matrix\",\n [IsChevalleyAdj],\n function(sys)\n local A,\n root_len,L,B,cochars,\n r,s;\n \n root_len:=2*Length(positiveRoots(sys));\n L:=UnderlyingLieAlgebra(rootSystem(sys));\n cochars:=Cocharacters(L);\n cochars:=Concatenation(cochars,-cochars);\n B:=Basis(L);\n\n A:=NullMat(root_len,root_len,Integers);\n for r in [1..root_len] do\n for s in [1..root_len] do\n A[r][s]:=Sum(Coefficients(Basis(L),cochars[r]*B[s]));\n od;\n od;\n\n return A;\nend);\n\neta:=function(r,s,roots,NN)\n local p,q,sus,jos;\n \n p:=0;\n while Position(roots,-(p+1)*roots[r]+roots[s])<>fail do p:=p+1; od;\n q:=0;\n while Position(roots,(q+1)*roots[r]+roots[s])<>fail do q:=q+1; od;\n\n sus:=List([1..p],i->SignInt(NN[r][Position(roots,(i-1-p)*roots[r]+roots[s])]));\n if sus=[] then sus:=1; else sus:=Product(sus); fi;\n if sus=0 then sus:=1; fi;\n \n jos:=List([1..q],i->SignInt(NN[r][Position(roots,(i-1-p)*roots[r]+roots[s])]));\n if jos=[] then jos:=1; else jos:=Product(jos); fi;\n if jos=0 then jos:=1; fi;\n\n return (-1)^p*sus/jos;\nend;\n\nInstallMethod(Eta,\n \"The matrix \\eta with the signs (see Carter page 95)\",\n [IsChevalleyAdj],\n function(sys)\n local H,\n NN,roots,roots_len,r,s;\n\n roots:=allRoots(sys);\n roots_len:=Length(roots);\n\n NN:=N_rs(sys);\n \n H:=NullMat(roots_len,roots_len,Integers);\n# for r in [1..roots_len/2] do\n# H[r][r]:=-1;\n# H[r][Position(roots,-roots[r])]:=-1;\n# H[Position(roots,-roots[r])][r]:=-1;\n# H[Position(roots,-roots[r])][Position(roots,-roots[r])]:=-1;\n# od;\n\n for r in [1..roots_len] do\n for s in [1..roots_len] do\n if r<>s and r<>Position(roots,-roots[s]) then H[r][s]:=eta(r,s,roots,NN);\n else H[r][s]:=-1; fi;\n od;\n od;\n\n return H;\nend);\n\n#InstallMethod(Eta,\n# \"The matrix \\eta with the signs (see Carter page 95)\",\n# [IsChevalleyAdj],\n# function(sys)\n# local H,\n# A_rs,pr,roots,pr_len,root_refs,\n# r,s,\n# wr_on_s,flag;\n#\n# A_rs:=A(sys);\n# pr:=positiveRoots(sys);\n# roots:=allRoots(sys);\n# pr_len:=Length(pr);\n# root_refs:=RootReflections(weylGroup(sys));\n#\n# H:=NullMat(2*pr_len,2*pr_len,Integers);\n# for r in [1..pr_len] do\n# H[r][r]:=-1;\n# H[r][Position(roots,-roots[r])]:=-1;\n# H[Position(roots,-roots[r])][r]:=-1;\n# H[Position(roots,-roots[r])][Position(roots,-roots[r])]:=-1;\n# od;\n#\n# for s in [1..2*pr_len] do\n# flag:=false;\n# for r in [1..2*pr_len] do\n# wr_on_s:=Position(roots,roots[s]*root_refs[((r-1) mod pr_len) +1]);\n# if H[r][s]<>0 and H[r][wr_on_s]=0 then\n# H[r][wr_on_s]:=H[r][s]*(-1)^A_rs[r][s];\n# H[r][Position(roots,-roots[wr_on_s])]:=H[r][wr_on_s];\n# flag:=true;\n# elif H[r][s]=0 and H[r][wr_on_s]<>0 then\n# H[r][s]:=H[r][wr_on_s]*(-1)^A_rs[r][s];\n# H[r][Position(roots,-roots[s])]:=H[r][s];\n# flag:=true;\n# fi;\n# od;\n# if not flag then\n# for r in [1..2*pr_len] do\n# wr_on_s:=Position(roots,roots[s]*root_refs[((r-1) mod pr_len)+1]);\n# if H[r][s]=0 then\n# H[r][s]:=1;\n# H[r][Position(roots,-roots[s])]:=1;\n# H[r][wr_on_s]:=(-1)^A_rs[r][s];\n# H[r][Position(roots,-roots[wr_on_s])]:=H[r][wr_on_s];\n# fi;\n# od;\n# fi;\n# od;\n#\n# return H;\n#end);\n\nInstallMethod(N_rs,\n \"Lie Algebra structure constants (see Carter page 52)\",\n [IsChevalleyAdj],\n function(sys)\n local N,\n L,B,pr_len,\n r,s;\n \n L:=UnderlyingLieAlgebra(rootSystem(sys));\n B:=Basis(L);\n pr_len:=Length(positiveRoots(sys));\n\n N:=NullMat(2*pr_len,2*pr_len,Integers);\n for r in [1..pr_len*2] do\n for s in [1..pr_len*2] do\n if r=s+pr_len or s=r+pr_len then N[r][s]:=fail;\n else N[r][s]:=Sum(Coefficients(B,B[r]*B[s])); fi;\n od;\n od;\n\n return N;\nend);\n\nInstallMethod(M_rsi,\n \"The M_rsi (see Certer page 61)\",\n [IsChevalleyAdj],\n function(sys)\n local M,\n pr,pr_len,roots,n,\n i,j,k,tmp,poz;\n \n pr:=positiveRoots(sys);\n roots:=allRoots(sys);\n pr_len:=Length(pr);\n n:=N(sys);\n \n M:=List([1..pr_len*2],i->List([1..pr_len*2],j->[]));\n for i in [1..pr_len*2] do\n for j in [1..pr_len*2] do\n if i=j+pr_len or j=i+pr_len then M[i][j]:=fail;\n else\n tmp:=[n[i][j]];\n for k in [2..4] do\n poz:=Position(roots,(k-1)*roots[i]+roots[j]);\n if poz<>fail then Add(tmp,n[i][poz]); fi; \n od;\n M[i][j]:=List([1..Length(tmp)],i->1/Factorial(i)*Product(tmp{[1..i]}));\n M[i][j]:=Filtered(M[i][j],k->k<>0);\n fi;\n od;\n od;\n\n return M;\nend);\n\n\nInstallMethod(C_ijrs,\n \"Algebraic group structure constants (see Carter page 76)\",\n [IsChevalleyAdj],\n function(sys)\n local C,\n pr,pr_len,roots,m,\n r,s,poz;\n \n pr:=positiveRoots(sys);\n roots:=allRoots(sys);\n pr_len:=Length(pr);\n m:=M(sys);\n \n C:=List([1..pr_len*2],i->List([1..pr_len*2],j->[]));\n for r in [1..pr_len*2] do\n for s in [1..pr_len*2] do\n if r=s+pr_len or s=r+pr_len then C[r][s]:=fail;\n else\n #C_i1rs=M_rsi\n Add(C[r][s],List([1..Length(m[r][s])],i->[i,1,m[r][s][i]]));\n #C_1jrs=(-1)^j*M_srj\n Add(C[r][s],List([2..Length(m[s][r])],j->[1,j,m[s][r][j]*(-1)^j]));#(1,1) apare mai sus\n #C_32rs=1/3*M_(r+s)r2\n poz:=Position(roots,3*roots[r]+2*roots[s]);\n if poz <> fail then\n poz:=Position(roots,roots[r]+roots[s]);\n Add(C[r][s],[[3,2,(1/3)*m[poz][r][2]]]);\n fi;\n #C_23rs=1/3*M_(r+s)r2\n poz:=Position(roots,2*roots[r]+3*roots[s]);\n if poz <> fail then\n poz:=Position(roots,roots[r]+roots[s]);\n Add(C[r][s],[[2,3,-(2/3)*m[poz][s][2]]]);\n fi;\n C[r][s]:=Concatenation(C[r][s]);\n Sort(C[r][s],function(a,b) return a[1]+a[2]<b[1]+b[2]; end);\n fi; \n od;\n od;\n\n return C;\nend);\n\nInstallMethod(PermutationSign,\n \"Uses the \\eta's to give the sign of the permutation on an e_alpha\",\n [IsChevalleyAdj,IsList,IsPosInt],\n function(sys,perm,root_index)\n local result,\n eta,ref_mats,roots,\n i;\n \n eta:=H(sys);\n ref_mats:=RootReflections(weylGroup(sys));\n roots:=allRoots(sys);\n \n result:=1;\n for i in Reversed(perm) do # !!! ATENTIE AICI .. conteaza daca e actiune stanga sau dreapta\n #for i in perm do\n result:=result*eta[i][root_index];\n root_index:=Position(roots,roots[root_index]*ref_mats[i]);\n# root_index:=Position(roots,ref_mats[i]*roots[root_index]);\n od;\n\n return result;\nend);\n\nInstallMethod(PermutationSign,\n \"Uses the \\eta's to give the sign of the permutation on an e_alpha\",\n [IsChevalleyAdj,IsList,IsList],\n function(sys,perm,root)\n return PermutationSign(sys,perm,Position(positiveRoots(sys),root));\nend);\n\nInstallMethod(InversePermutationSign,\n \"Uses the \\eta's to give the sign of the permutation on an e_alpha\",\n [IsChevalleyAdj,IsList,IsPosInt],\n function(sys,perm,root_index)\n local result,\n eta,ref_mats,roots,\n i;\n \n eta:=H(sys);\n ref_mats:=RootReflections(weylGroup(sys));\n roots:=allRoots(sys);\n \n result:=1;\n #for i in Reversed(perm) do # !!! ATENTIE AICI .. conteaza daca e actiune stanga sau dreapta\n for i in perm do\n #result:=result*eta[i][root_index];\n root_index:=Position(roots,roots[root_index]*ref_mats[i]);\n result:=result*eta[i][root_index];\n# root_index:=Position(roots,ref_mats[i]*roots[root_index]);\n od;\n\n return result;\nend);\n\nInstallMethod(InversePermutationSign,\n \"Uses the \\eta's to give the sign of the permutation on an e_alpha\",\n [IsChevalleyAdj,IsList,IsList],\n function(sys,perm,root)\n return InversePermutationSign(sys,perm,Position(positiveRoots(sys),root));\nend);\n\n", "meta": {"hexsha": "2df79872c88fd0afe705da4eb7138faf130f5f48", "size": 13348, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/chvadj.gi", "max_stars_repo_name": "iuliansimion/Chevalley.gap", "max_stars_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/chvadj.gi", "max_issues_repo_name": "iuliansimion/Chevalley.gap", "max_issues_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/chvadj.gi", "max_forks_repo_name": "iuliansimion/Chevalley.gap", "max_forks_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.8729281768, "max_line_length": 109, "alphanum_fraction": 0.445459994, "num_tokens": 3256, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519527944504227, "lm_q2_score": 0.6757646010190476, "lm_q1q2_score": 0.5757195402288525}}
{"text": "##############################################################\n##\n## Helps compute the decomposition of\n## the ramification module and the equivariant\n## degree of a multiple of a simple orbit for\n## the Hurwitz curves X with automorphism group\n## G = PSL(2,q), q a prime.\n##\n## Using these computations and Borne's formula, the\n## G-module structure of the RR spaces of equivariant\n## divisors can be determined explicitly.\n##\n## Reference: David Joyner, Amy Ksir, Roger Vogeler,\n## \"Group representations on Riemann-Roch spaces\n## of some Hurwitz curves,\" preprint, 2006.\n##\n## 6-9-2006, wdj\n##############################################################\n\n## To read this in, use for example:\n## Read(\"/home/wdj/gapfiles/curves/hurwitz_crv_rr_sp.gap\");\n## To log your results, use for example:\n## LogTo(\"/home/wdj/gapfiles/curves/hurwitz_crv_rr_sp1.log\");\n\nhurwitz_primes:=function(n)\n# Returns the primes < n s.t. PSL(2,p) is a Hurwitz gp\n# Assumes n<1000.\nlocal p,L;\nL:=[];\nfor p in Primes do\n if Int((p+1)/7)=((p+1)/7) and p<n then\n L:=Concatenation(L,[p]);\n fi;\n if Int((p-1)/7)=((p-1)/7) and p<n then\n L:=Concatenation(L,[p]);\n fi;\nod;\nreturn L;\nend;\n\nhurwitz_prime_powers:=function(n)\n## Returns the prime powers q=p^3 < n s.t. PSL(2,q)\n## is a Hurwitz gp\n## Assumes n<1000.\nlocal p,L;\nL:=[];\nfor p in Primes do\n if Int((p+2)/7)=((p+2)/7) and p^3<n then\n L:=Concatenation(L,[p^3]);\n fi;\n if Int((p-2)/7)=((p-2)/7) and p^3<n then\n L:=Concatenation(L,[p^3]);\n fi;\n if Int((p+3)/7)=((p+3)/7) and p^3<n then\n L:=Concatenation(L,[p^3]);\n fi;\n if Int((p-3)/7)=((p-3)/7) and p^3<n then\n L:=Concatenation(L,[p^3]);\n fi;\nod;\nreturn L;\nend;\n\n\n\nram_module_hurwitz:=function(p)\n##\n## input: p is a Hurwitz prime; output: [m1,...,mn],\n## where n = # conj classes of G=PSL(2,p)\n## and mi = mult of pi_i in ram mod of Hurwitz crv with\n## aut gp G.\n## Here Irr(G) = [pi_1,...,pi_n] (in that order).\n##\nlocal A,B,C,D,pi,G,i,j,n,n0,H,G1,H_chars,CG,G_chars,w,m,theta,pi_theta_to_the;\n if not(p in hurwitz_primes(500)) then\n Print(\"Input is not a (small) Hurwitz prime.\\n\");\n return [];\n fi;\n G:=PSL(2,p);\n H:=[];\n H_chars:=[];\n n0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\n CG:=ConjugacyClassesSubgroups(G);\n H[1]:=Representative(CG[2]); # size 2\n H[2]:=Representative(CG[3]); # size 3\n n :=Size(CG);\n for i in [1..n] do\n if Size(Representative(CG[i]))=7 then\n H[3]:=Representative(CG[i]);\n fi;\n od;\n## H[3]:=Group(n0); # size 7\n for i in [1..Size(H)] do\n H_chars[i]:=Irr(H[i]);\n od;\n G_chars:=Irr(G);\n m:=[];\n m[1]:=[];m[2]:=[];m[3]:=[];\n theta:=List([1..3],i->H_chars[i][2]);\n pi_theta_to_the:=List([1..3],i->Sum([1..(Size(H[i])-1)],\n j->j*InducedClassFunction(theta[i]^(j),G)));\n#Print(\"\\n\\n pi_theta_to_the = \",Sum(pi_theta_to_the),\"\\n\\n\");\n for i in [1..3] do\n m[i]:=List(G_chars, pi->ScalarProduct(pi_theta_to_the[i],pi))/Size(H[i]);\n od;\n#Print(\"\\n\\n m = \",m,\"\\n\\n\");\n#Print(\"Multiplicities (by definition):\\n \",Sum(m),\"\\n\");\nreturn Sum(m);\n####\nn:=Length(G_chars);\nA:=[];\nB:=[];\nC:=[];\nD:=[];\nfor i in [1..n] do\n pi:=G_chars[i];\n A[i]:=ScalarProduct(H_chars[1][1],RestrictedClassFunction(pi,H[1]));\n B[i]:=ScalarProduct(H_chars[2][1],RestrictedClassFunction(pi,H[2]));\n C[i]:=ScalarProduct(H_chars[3][1],RestrictedClassFunction(pi,H[3]));\n D[i]:=DegreeOfCharacter(pi);\nod;\n#Print(\"Multiplicities (predicted by JK - assumes all R_\\ell=1):\\n \",(1/2)*(3*D-A-B-C),\"\\n\");\nend;\n\n#########example\n#gap> ram_module_hurwitz(13); time;\n#\n#m = [ [0,2,2,3,3,3,3,4,3],[0,2,2,4,4,4,4,5,5],[0,3,3,5,5,5,6,6,6] ]\n#\n#Multiplicities (by definition):\n# [ 0, 7, 7, 12, 12, 12, 13, 15, 14 ]\n#Multiplicities (predicted by JK - assumes all R_ell=1):\n# [ 0, 7, 7, 12, 12, 12, 13, 15, 14 ]\n#1640\n#\n\nram_module_X:=function(p)\n## p is a Hurwitz prime\n## output is (m1,...,mn)\n## where n = # conj classes of G=PSL(2,p)\n## and mi = mult of pi_i in ram mod of G\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,w,m,theta,pi_theta_to_the;\n if not(p in hurwitz_primes(500)) then\n Print(\"Input is not a (small) Hurwitz prime.\\n\");\n return [];\n fi;\n G:=PSL(2,p);\n H:=[];\n H_chars:=[];\n n0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\n CG:=ConjugacyClassesSubgroups(G);\n H[1]:=Representative(CG[2]); # size 2\n H[2]:=Representative(CG[3]); # size 3\n n :=Size(CG);\n for i in [1..n] do\n if Size(Representative(CG[i]))=7 then\n H[3]:=Representative(CG[i]);\n fi;\n od;\n## H[3]:=Group(n0); # size 7\n for i in [1..Size(H)] do\n H_chars[i]:=Irr(H[i]);\n od;\n G_chars:=Irr(G);\n m:=[];\n m[1]:=[];m[2]:=[];m[3]:=[];\n theta:=List([1..3],i->H_chars[i][2]);\n pi_theta_to_the:=List([1..3],i->Sum([1..(Size(H[i])-1)],\n j->j*InducedClassFunction(theta[i]^(j),G)));\n#Print(\"\\n\\n pi_theta_to_the = \",Sum(pi_theta_to_the),\"\\n\\n\");\n for i in [1..3] do\n m[i]:=List(G_chars, pi->ScalarProduct(pi_theta_to_the[i],pi))/Size(H[i]);\n od;\n#Print(\"\\n\\n m = \",m,\"\\n\\n\");\nreturn Sum(m);\nend;\n\n\nram_module_X_JK:=function(p)\n## p is a Hurwitz prime\n## output is (m1,...,mn)\n## where n = # conj classes of G=PSL(2,p)\n## and mi = \"mult of pi_i in ram mod of G\" using JK formula\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,A,B,C,D,pi;\nG:=PSL(2,p);\nH:=[];\nH_chars:=[];\nn0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\nCG:=ConjugacyClassesSubgroups(G);\nH[1]:=Representative(CG[2]); # size 2\nH[2]:=Representative(CG[3]); # size 3\nn:=Size(CG);\nfor i in [1..n] do\n if Size(Representative(CG[i]))=7 then\n H[3]:=Representative(CG[i]);\n fi;\nod;\n## H[3]:=Group(n0); # size 7\nfor i in [1..Size(H)] do\n H_chars[i]:=Irr(H[i]);\nod;\nG_chars:=Irr(G);\nn:=Length(G_chars);\nA:=[];\nB:=[];\nC:=[];\nD:=[];\nfor i in [1..n] do\n pi:=G_chars[i];\n A[i]:=ScalarProduct(H_chars[1][1],RestrictedClassFunction(pi,H[1]));\n B[i]:=ScalarProduct(H_chars[2][1],RestrictedClassFunction(pi,H[2]));\n C[i]:=ScalarProduct(H_chars[3][1],RestrictedClassFunction(pi,H[3]));\n D[i]:=DegreeOfCharacter(pi);\nod;\nreturn (1/2)*(3*D-A-B-C); #assumes all R_\\ell=1\nend;\n\n\nequiv_deg_module_hurwitz:=function(p,ii,r)\n## p is a Hurwitz prime\n## ii = 1 for H[1], size 2\n## ii = 2 for H[2], size 3\n## ii = 3 for H[3], size p\n## output is (m1,...,mn)\n## where n = # conj classes of G=PSL(2,p)\n## and mi = mult of pi_i in deg_equiv module of G\n##\nlocal G,i,j,n,n0,H,G1,H_chars,CG,G_chars,w,m,theta,pi_theta,pi_theta_to_the;\nG:=PSL(2,p);\nH:=[]; # 3 decomp gps\nH_chars:=[];\nn0:=[ [ Z(p)^0, Z(p) ], [ Z(p)*0, Z(p)^0 ] ];\nCG:=ConjugacyClassesSubgroups(G);\nH[1]:=Representative(CG[2]); # size 2\nH[2]:=Representative(CG[3]); # size 3\nn:=Size(CG);\nfor i in [1..n] do\n if Size(Representative(CG[i]))=7 then\n H[3]:=Representative(CG[i]);\n fi;\nod;\n## H[3]:=Group(n0); # size 7\nfor i in [1..3] do\n H_chars[i]:=Irr(H[i]);\nod;\nG_chars:=Irr(G);\nm:=[];\nm[1]:=[];m[2]:=[];m[3]:=[];\ntheta:=List([1..3],i->H_chars[i][2]);\npi_theta_to_the:=List([1..3],i->List([1..r],j->InducedClassFunction(theta[i]^(-j),G)));\nfor i in [1..3] do\n for j in [1..r] do\n m[i][j]:=List(G_chars, pi->ScalarProduct(pi_theta_to_the[i][j],pi));\n od;\nod;\nreturn Sum(m[ii]);\nend;\n\n\n# equiv_deg_module_X(7,2,1);\n#[ 0, 1, 1, 2, 2, 3 ]\n# equiv_deg_module_X(7,1,1);\n#[ 0, 2, 2, 2, 4, 4 ]\n# equiv_deg_module_X(7,3,1);\n#[ 0, 1, 0, 1, 1, 1 ]\n# equiv_deg_module_X(7,3,7);\n#[ 1, 3, 3, 6, 7, 8 ]\n# equiv_deg_module_X(7,1,2);\n#[ 1, 3, 3, 6, 7, 8 ]\n\n\ncuberoots:=function(q)\nlocal x,L;\n L:=[];\n for x in GF(q^2) do\n if x<>Zero(GF(q^2)) and x<>One(GF(q^2)) and x^3=One(GF(q^2)) then\n L:=Concatenation(L,[x]);\n fi;\n od;\n return L;\nend;\n\n#gap> cuberoots(41);\n#[ Z(41^2)^560, Z(41^2)^1120 ]\n#gap> cuberoots(43);\n#[ Z(43)^14, Z(43)^28 ]\n#gap> fourthroots(43);\n#[ Z(43^2)^462, Z(43^2)^1386 ]\n#gap> fourthroots(41);\n#[ Z(41)^10, Z(41)^30 ]\n#gap> fourteenthroots(41);\n#[ Z(41^2)^120, Z(41^2)^600, Z(41^2)^1560, Z(41^2)^1320, Z(41^2)^1080, Z(41^2)^360 ]\n#gap> fourteenthroots(43);\n#[ Z(43)^3, Z(43)^9, Z(43)^15, Z(43)^27, Z(43)^33, Z(43)^39 ]\n\n\nfourteenthroots:=function(q)\nlocal x,L;\n L:=[];\n for x in GF(q^2) do\n if x<>Zero(GF(q^2)) and x<>One(GF(q^2)) and x^2<>One(GF(q^2))\n and x^7<>One(GF(q^2)) and x^(14)=One(GF(q^2)) then\n L:=Concatenation(L,[x]);\n fi;\n od;\n return L;\nend;\n\nfourthroots:=function(q)\nlocal x,L;\n L:=[];\n for x in GF(q^2) do\n if x<>Zero(GF(q^2)) and x<>One(GF(q^2)) and\n x^2<>One(GF(q^2)) and x^(4)=One(GF(q^2)) then\n L:=Concatenation(L,[x]);\n fi;\n od;\n return L;\nend;\n\nNalpha:=function(alpha,q)\n # alpha a character of GF(q)^x\n local root3,root4,root14,count;\n count := 0;\n root3:=cuberoots(q)[1];\n root4:=fourthroots(q)[1];\n root14:=fourteenthroots(q)[1];\n if root3 in GF(q) and root3^alpha<>1 then count:=count+1; fi;\n if root4 in GF(q) and root4^alpha<>1 then count:=count+1; fi;\n if root14 in GF(q) and root14^alpha<>1 then count:=count+1; fi;\n return count;\nend;\n\nNbeta:=function(beta,q)\n # beta a character of GF(q^2)^x\n local root3,root4,root14,count;\n count := 0;\n root3:=cuberoots(q)[1];\n root4:=fourthroots(q)[1];\n root14:=fourteenthroots(q)[1];\n if root3 in GF(q) and root3^beta<>1 then count:=count+1; fi;\n if root4 in GF(q) and root4^beta<>1 then count:=count+1; fi;\n if root14 in GF(q) and root14^beta<>1 then count:=count+1; fi;\n return count;\nend;\n", "meta": {"hexsha": "8f3e921a41c815bc738849f91b96c724fd4c45fe", "size": 9287, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "src/ext/gap/joyner/hurwitz_crv_rr_sp.gap", "max_stars_repo_name": "bopopescu/sage", "max_stars_repo_head_hexsha": "2d495be78e0bdc7a0a635454290b27bb4f5f70f0", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 1742, "max_stars_repo_stars_event_min_datetime": "2015-01-04T07:06:13.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T11:32:52.000Z", "max_issues_repo_path": "src/sage/ext_data/gap/joyner/hurwitz_crv_rr_sp.gap", "max_issues_repo_name": "Ivo-Maffei/sage", "max_issues_repo_head_hexsha": "467fbc70a08b552b3de33d9065204ee9cbfb02c7", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 66, "max_issues_repo_issues_event_min_datetime": "2015-03-19T19:17:24.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-16T11:59:30.000Z", "max_forks_repo_path": "src/sage/ext_data/gap/joyner/hurwitz_crv_rr_sp.gap", "max_forks_repo_name": "dimpase/sage", "max_forks_repo_head_hexsha": "468f23815ade42a2192b0a9cd378de8fdc594dcd", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": 495, "max_forks_repo_forks_event_min_datetime": "2015-01-10T10:23:18.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-24T22:06:11.000Z", "avg_line_length": 26.6867816092, "max_line_length": 93, "alphanum_fraction": 0.5794120814, "num_tokens": 3602, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.828938799869521, "lm_q2_score": 0.6926419767901475, "lm_q1q2_score": 0.5741578089796775}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n# Base change for DST-3\n# def := (mn, n) -> Let(m=>mn/n,\n# Conjugate(DirectSum(Tensor(I(n-1), S(m)), I(m)),\n#\t L(mn, n) * IP(mn, DirectSum(J(n-1), I(1))))),\nClass(B_DST3_U, Sym, rec(\n def := (mn, m) -> let(n := mn/m,\n\tDoNotReorder(SUMAcc(\n\t\tMon(fId(mn), \n\t\t II(mn), \n\t\t II(mn)),\n\t\tMon(fTensor(Z(m,1), fDirsum(J(n-1), fId(1))),\n\t\t II(mn),\n\t\t diagTensor(II(m, 1, m), II(n,n-1))))))));\n#B_DST3_U := (mn,m) -> I(mn);\n\nClass(B_DST4_U, Sym, rec(\n def := (mn, m) -> let(n := mn/m,\n\tDoNotReorder(SUMAcc(\n\t\tMon(fId(mn), \n\t\t II(mn),\n\t\t II(mn)),\n\t\tMon(fTensor(Z(m,1), J(n)),\n\t\t II(mn),\n\t\t diagTensor(II(m, 1, m), II(n))))))));\n\nClass(B_DCT4_U, Sym, rec(\n def := (mn, m) -> let(n := mn/m,\n\tDoNotReorder(SUMAcc(\n\t\tMon(fId(mn), \n\t\t II(mn), \n\t\t II(mn)),\n\t\tMon(fTensor(Z(m,1), J(n)),\n\t\t fConst(mn, -1), \n\t\t diagTensor(II(m, 1, m), II(n))))))));\n\nClass(B_DCT3_U, Sym, rec(\n def := (mn, m) -> let(n := mn/m,\n\tDoNotReorder(SUMAcc(\n\t\tMon(fId(mn), II(mn), diagTensor(II(m,0,1), II(n,0,1))),\n\t\tMon(fId(mn), fConst(mn, 1/2), diagTensor(II(m,1,m), II(n,0,1))),\n\t\tMon(fId(mn), II(mn), diagTensor(II(m,0,m), II(n,1,n))),\n\n\t\tMon(fTensor(Z(m,1), fDirsum(fId(1), J(n-1))),\n\t\t II(mn),\n\t\t diagTensor(II(m, 1, m), II(n,1,n))),\n\n\t\tMon(fTensor(Z(m,2), fId(n)),\n\t\t fConst(mn, -1/2), \n\t\t diagTensor(II(m, 2, m), II(n,0,1))))))));\n\n# inverse-transpose T-basis for DCT3\nClass(B_DCT3_T_IT, Sym, rec(\n def := (mn, m) -> let(n := mn/m,\n\tDoNotReorder(SUMAcc(\n\t\tMon(fId(mn),\n\t\t II(mn),\n\t\t II(mn)),\n\t\tMon(fTensor(Z(m,m-1), fDirsum(fId(1), J(n-1))),\n\t\t II(mn),\n\t\t diagTensor(II(m, 0, m-1), II(n,1,n))))))));\n\n\nClass(B_DCT3_T_Radix2, Sym, rec(\n def := (mn, r) -> let(n := mn/2, \n\tDoNotReorder(SUMAcc(\n\t\tMon(fId(mn), II(mn), diagTensor(II(2,0,1), II(n,0,n))),\n\t\tMon(fId(mn), fConst(mn, cos(r)), diagTensor(II(2,1,2), II(n,0,1))),\n\t\tMon(fId(mn), fConst(mn, 2*cos(r)), diagTensor(II(2,1,2), II(n,1,n))),\n\n\t\tMon(fTensor(Z(2,1), fDirsum(fId(1), J(n-1))),\n\t\t fConst(mn, -1), \n\t\t diagTensor(II(2, 1, 2), II(n,1,n))))))));\n\n\n", "meta": {"hexsha": "bcdfa3eee4995ddf1b803734d2aaf11066f179df", "size": 2215, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/dtt/basechange.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/dtt/basechange.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/dtt/basechange.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 27.6875, "max_line_length": 71, "alphanum_fraction": 0.5029345372, "num_tokens": 929, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515684, "lm_q2_score": 0.6791787121629466, "lm_q1q2_score": 0.5717500589660591}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(IMDCT_Odd, IMDST_Odd);\n\nClass(MDCTBase, DTTBase, rec(\n dims := self >> [ self.params, 2*self.params ],\n SmallRandom := () -> Random([2,4,6,8,12,16,18,24])\n));\n\nClass(IMDCTBase, DTTBase, rec(\n dims := self >> [ 2*self.params, self.params ],\n SmallRandom := () -> Random([2,4,6,8,12,16,18,24])\n));\n\n#F MDCT_Odd(<n>) - Modified Discrete Cosine Transform non-terminal, (oddly-stacked system)\n#F Definition: (n x 2n)-matrix [ cos((2i+1)(2j+1+n)/(4n)) | i = 0..n-1, j = 0..2n-1 ]\n#F Note: MDCT_Odd is the transpose of IMDCT_Odd\n#F Example: MDCT_Odd(8)\n#F \nClass(MDCT_Odd, MDCTBase, rec(\n terminate := self >> let(n := self.params, Mat(\n\tList([0 .. n-1], i ->\n\t List([0 .. 2*n - 1], j -> \n\t\tCosPi((2*j + 1 + n)*(2*i + 1)/(4*n)))))),\n\n transpose := self >> IMDCT_Odd(self.params), \n));\n\nMDCT := MDCT_Odd;\n\n#F MDST_Odd(<n>) - Modified Discrete Sine Transform non-terminal, (oddly-stacked system)\n#F Definition: (n x 2n)-matrix [ sin((2i+1)(2j+1+n)/(4n)) | i = 0..n-1, j = 0..2n-1 ]\n#F Note: MDST_Odd is the transpose of IMDST_Odd\n#F Example: MDST_Odd(8)\n#F \nClass(MDST_Odd, MDCTBase, rec(\n terminate := self >> let(n := self.params, Mat(\n\tList([0 .. n-1], i ->\n\t List([0 .. 2*n - 1], j -> \n\t\tSinPi((2*j + 1 + n)*(2*i + 1)/(4*n)))))),\n\n transpose := self >> IMDST_Odd(self.params), \n));\n\n\n#F MDCT_Even(<n>) - Modified Discrete Cosine Transform non-terminal, (evenly-stacked system)\n#F Definition: (n x 2n)-matrix [ cos((2i)(2j+1+n)/(4n)) | i = 0..n-1, j = 0..2n-1 ], n even\n#F (n+1 x 2n)-matrix [ cos((2i)(2j+1+n)/(4n)) | i = 0..n, j = 0..2n-1 ], n odd\n#F\n#F Example: MDCT_Even(8)\n#F \nClass(MDCT_Even, MDCTBase, rec(\n dims := self >> [ self.params + When(IsOddInt(self.params), 1, 0), 2*self.params ],\n\n terminate := self >> let(n := self.params, isodd := When(IsOddInt(n), 1, 0), Mat(\n\tList([0 .. n-1 + isodd], i ->\n\t List([0 .. 2*n - 1], j -> \n\t\tCosPi((2*j + 1 + n)*(2*i)/(4*n)))))),\n\n# transpose := self >> IMDCT_Even(self.params), \n));\n\n#F MDST_Even(<n>) - Modified Discrete Sine Transform non-terminal, (evenly-stacked system)\n#F Definition: (n x 2n)-matrix [ sin((2i)(2j+1+n)/(4n)) | i = 1..n, j = 0..2n-1 ], n even\n#F (n-1 x 2n)-matrix [ sin((2i)(2j+1+n)/(4n)) | i = 1..n-1, j = 0..2n-1 ], n odd\n#F\n#F Example: MDST_Even(8)\n#F \nClass(MDST_Even, MDCTBase, rec(\n dims := self >> [ self.params - When(IsOddInt(self.params), 1, 0), 2*self.params ],\n\n terminate := self >> let(n := self.params, isodd := When(IsOddInt(n), 1, 0), Mat(\n\tList([1 .. n-isodd], i ->\n\t List([0 .. 2*n - 1], j -> \n\t\tSinPi((2*j + 1 + n)*(2*i)/(4*n)))))),\n\n# transpose := self >> IMDST_Even(self.params), \n));\n\n\n#F IMDCT_Odd(<n>) - Inverse Modified Discrete Cosine Transform non-terminal (oddly-stacked system)\n#F Definition: (2n x n)-matrix [ cos((2j+1)(2i+1+n)/(4n)) | i=0..2n-1, j=0..n-1 ]\n#F Note: IMDCT_Odd is the transpose of MDCT_Odd\n#F Example: IMDCT_Odd(8)\n#F \nClass(IMDCT_Odd, IMDCTBase, rec(\n terminate := self >> let(n:=self.params, Mat(\n\tList([0 .. 2*n-1], i ->\n\t List([0 .. n-1], j -> \n\t\tCosPi((2*i + 1 + n)*(2*j + 1)/(4*n)))))),\n\n transpose := self >> MDCT_Odd(self.params), \n));\n\nIMDCT := IMDCT_Odd;\n\n#F IMDST_Odd(<n>) - Inverse Modified Discrete Sine Transform non-terminal (oddly-stacked system)\n#F Definition: (2n x n)-matrix [ cos((2j+1)(2i+1+n)/(4n)) | i=0..2n-1, j=0..n-1 ]\n#F Note: IMDST_Odd is the transpose of MDST_Odd\n#F Example: IMDST_Odd(8)\n#F \nClass(IMDST_Odd, IMDCTBase, rec(\n terminate := self >> let(n:=self.params, Mat(\n\tList([0 .. 2*n-1], i ->\n\t List([0 .. n-1], j -> \n\t\tSinPi((2*i + 1 + n)*(2*j + 1)/(4*n)))))),\n\n transpose := self >> MDST_Odd(self.params), \n));\n\n\n_shiftcut := (transform, n, start, cut, shift, boundary) -> Checked(cut in [\"re\", \"im\"], \n let(ofs := When(cut=\"re\", 0, 1),\n\tN := Cols(transform),\n\ti := Ind(N),\n\n\tGath(H(Rows(transform), n, ofs+start, 2)) * \n\ttransform * \n\tWhen(boundary=1, I(N), Diag(Lambda(i, cond(leq(i,shift-1), boundary, 1)))) *\n\tZ(N, -shift))\n);\n\nRulesFor(MDCT_Odd, rec(\n #F MDCT_toDCT4: MDCT_n = DCT4_n * sums\n #F\n MDCT_Odd_toDCT4 := rec (\n\tinfo := \"MDCT_n -> DCT4_n\",\n\tisApplicable := P -> P mod 2 = 0,\n\tallChildren := P -> [[ DCT4(P) ]], \n\trule := (P, C) -> \n\t C[1] * \n\t J(P) *\n\t DirectSum(Tensor(Mat([[1, -1]]), I(P/2)),\n\t\t Tensor(Mat([[-1, -1]]), I(P/2))) *\n\t DirectSum(J(P/2), I(P/2), I(P/2), J(P/2))\n ),\n\n MDCT_Odd_toPRDFT34 := rec(\n\tinfo := \"MDCT_n -> PRDFT4_2n or PRDFT3_2n\",\n\tisApplicable := P -> true,\n\tallChildren := P -> When(IsEvenInt(P), [[ PRDFT4(2*P) ]], [[ PRDFT3(2*P) ]]), \n\trule := (P, C) -> let(n:=P, \n\t _shiftcut(C[1], n, 0, \"re\", Int((n+1)/2), -1))\n )\n\n));\n\nRulesFor(MDST_Odd, rec(\n #F MDST_toDST4: MDST_n = DST4_n * sums\n #F\n MDST_Odd_toDST4 := rec (\n\tinfo := \"MDST_n -> DST4_n\",\n\tisApplicable := P -> P mod 2 = 0, \n # NOTE: implement rule for n odd, converts to DST3\n\tallChildren := P -> [[ DST4(P) ]], \n\trule := (P, C) -> let(n:=P,\n\t C[1] * \n\t J(n) *\n\t DirectSum(Tensor(Mat([[1, 1]]), I(n/2)),\n\t\t Tensor(Mat([[1, -1]]), I(n/2))) *\n\t DirectSum(J(n/2), I(n/2), I(n/2), J(n/2)))\n ),\n\n MDST_Odd_toPRDFT34 := rec(\n\tinfo := \"MDST_n -> PRDFT4_2n or PRDFT3_2n\",\n\tisApplicable := P -> true,\n\tallChildren := P -> When(IsEvenInt(P), [[ PRDFT4(2*P) ]], [[ PRDFT3(2*P) ]]), \n\trule := (P, C) -> let(n:=P, \n\t _shiftcut(C[1], n, 0, \"im\", Int((n+1)/2), -1))\n )\n\n));\n\n\nRulesFor(MDCT_Even, rec(\n MDCT_Even_toPRDFT12 := rec(\n\tinfo := \"MDCT_n -> PRDFT1_2n or PRDFT2_2n\",\n\tisApplicable := P -> true,\n\tallChildren := P -> When(IsEvenInt(P), [[ PRDFT2(2*P) ]], [[ PRDFT1(2*P) ]]), \n\trule := (P, C) -> let(n:=P, \n\t _shiftcut(C[1], n+(n mod 2), 0, \"re\", Int((n+1)/2), 1))\n )\n));\n\n\nRulesFor(MDST_Even, rec(\n MDST_Even_toPRDFT12 := rec(\n\tinfo := \"MDST_n -> PRDFT1_2n or PRDFT2_2n\",\n\tisApplicable := P -> true,\n\tallChildren := P -> When(IsEvenInt(P), [[ PRDFT2(2*P) ]], [[ PRDFT1(2*P) ]]), \n\trule := (P, C) -> let(n:=P, \n\t _shiftcut(C[1], n-(n mod 2), 2, \"im\", Int((n+1)/2), 1))\n )\n));\n", "meta": {"hexsha": "759c5d613c12b99068ad74cfbd9531f977b01b8e", "size": 6222, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/dct_dst/mdct.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/dct_dst/mdct.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/dct_dst/mdct.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 31.4242424242, "max_line_length": 98, "alphanum_fraction": 0.5450016072, "num_tokens": 2502, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.84997116805678, "lm_q2_score": 0.6688802735722129, "lm_q1q2_score": 0.5685289474183124}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n# Cross-compatibility\n#\n\n\n#######################################################################################\n# tSPL DFT rules\nNewRulesFor(DFT, rec(\n #F DFT_CT: 1965\n #F General Cooley-Tukey Rule\n #F DFT_n = (DFT_n/d tensor I_d) * diag * (I_n/d tensor F_d) * perm\n #F\n #F Cooley/Tukey:\n #F An Algorithm for the Machine Calculation of Complex Fourier Series.\n #F Mathematics of Computation, Vol. 19, 1965, pp. 297--301.\n #F\n DFT_tSPL_CT := rec(\n info := \"tSPL DFT(mn,k) -> DFT(m, k%m), DFT(n, k%n)\",\n\n maxSize := false,\n filter := e->true,\n\n applicable := (self, nt) >> nt.params[1] > 2\n and (self.maxSize = false or nt.params[1] <= self.maxSize)\n and not IsPrime(nt.params[1])\n and nt.hasTags(),\n\n children := (self, nt) >> Map2(Filtered(DivisorPairs(nt.params[1]), self.filter), (m,n) -> [\n TCompose([\n TGrp(TCompose([\n TTensorI(DFT(m, nt.params[2] mod m), n, AVec, AVec),\n TTwiddle(m*n, n, nt.params[2])\n ])),\n TGrp(TTensorI(DFT(n, nt.params[2] mod n), m, APar, AVec))\n ]).withTags(nt.getTags())\n ]),\n\n apply := (nt, c, cnt) -> c[1],\n\n#D isApplicable := (self,P) >> P[1] > 2 and\n#D (self.maxSize=false or P[1] <= self.maxSize) and not IsPrime(P[1]) and PHasTags(self.nonTerminal, P),\n#D allChildren := P -> Map2(DivisorPairs(P[1]),\n#D (m,n) -> [ TCompose([TGrp(TCompose([TTensorI(DFT(m, P[2] mod m), n, AVec, AVec), TDiag(fPrecompute(Tw1(m*n, n, P[2])))])),\n#D TGrp(TTensorI(DFT(n, P[2] mod n), m, APar, AVec))], P[3]) ]),\n#D rule := (P,C,nt) -> C[1],\n switch := false\n )\n));\n\n\nNewRulesFor(DFT, rec(\n DFT_TTensorI_CT := rec(\n switch := false,\n maxSize := false,\n minSize := false,\n\n applicable := (self, t) >> let(\n n := Rows(t),\n n > 2\n #and nt.hasTags() --> fixed: dpickem 08/03/09\n and t.hasTags()\n and (self.maxSize=false or n <= self.maxSize)\n and (self.minSize=false or n >= self.minSize)\n and not IsPrime(n)\n ),\n\n children := t -> let(\n tags := t.params[3],\n Map2(DivisorPairs(Rows(t)), (m,n) -> [\n TTensorI_GT(GT(DFT(m, t.params[2] mod m), XChain([0, 1]), XChain([0, 1]), [n]).withTags(tags)),\n TTensorI_GT(GT(DFT(n, t.params[2] mod n), XChain([0, 1]), XChain([1, 0]), [m]).withTags(tags))\n ])\n ),\n\n apply := (t, C, Nonterms) ->\n Grp(C[1] * Diag(fPrecompute(Tw1(Rows(t), Rows(Nonterms[2].params[1]), t.params[2])))) * C[2]\n ),\n\n #F DFT_Rader: Rader's Algorithm for Prime size DFT\n #F\n #F DFT(p) -> P(g)' * (1 dirsum DFT(p-1)) * Tp * (1 dirsum DFT(p-1)) * P(g)\",\n #F P(g) = perm\n #F Tp = [[1,1],[1,-1/(p-1)]] dirsum diag\n #F\n DFT_tSPL_Rader := rec(\n minSize := 3,\n useSymmetricAlgorithm := true,\n avoidSizes := [],\n switch := false,\n\n applicable := (self, t) >> let(\n n := Rows(t),\n n >= self.minSize\n and IsPrime(n)\n and (not n in self.avoidSizes)\n and t.hasTags()\n ),\n\n children := (self, t) >> let(\n N := Rows(t),\n tags := t.getTags(),\n When(self.useSymmetricAlgorithm,\n [[\n TDirectSum(I(1), DFT(N-1, -1)).withTags(tags),\n TRaderMid(N, t.params[2], PrimitiveRootMod(N)).withTags(tags)\n ]],\n [[\n TCompose([\n TDirectSum(I(1), DFT(N-1, -1)),\n TRaderMid(N, t.params[2], PrimitiveRootMod(N)),\n TDirectSum(I(1), DFT(N-1, -1))\n ]).withTags(tags)\n ]]\n )\n ),\n\n apply := (self, t, C, Nonterms) >> let(\n N := Rows(t), k := t.params[2], root := PrimitiveRootMod(N),\n When(self.useSymmetricAlgorithm,\n RR(N, 1, root).transpose()\n * C[1].transpose() * C[2] * C[1]\n * RR(N, 1, root),\n RR(N, 1, root).transpose()\n * C[1]\n * RR(N, 1, root)\n ))\n ),\n\n #F DFT_Bluestein : Convert FFT to Toeplitz matrix, then embed in a larger Circulant\n #F\n #F DFT_n -> diag * Toeplitz * diag\n #F\n # DFT on inputs, some of which are 0:\n #\n DFT_tSPL_Bluestein := rec(\n minRoundup := 8,\n customFilter := True,\n goodFactors := [2,3,5],\n applicableSizes := IsPrime,\n circSizes := meth(self,N)\n local low, high, cands;\n low := 2 * N + 1;\n high := 4 * 2^Log2Int(N);\n cands := When(high < self.minRoundup, [self.minRoundup], [low..high]);\n cands := Filtered(cands, self.customFilter);\n cands := Filtered(cands, i->IsEvenInt(i) and IsSubset(Set(self.goodFactors), Set(Factors(i))));\n return cands;\n end,\n\n toeplitz := (N, k) ->\n List([1..2*N-1], x -> ComplexW(2*N, -(N-x)^2 * k)),\n\n diag := (N, k) ->\n List([0..N-1], x -> ComplexW(2*N, x^2 * k)),\n\n circulantToep := (toep,size) -> let(l:=Length(toep),\n Concatenation(\n List([1..(l+1)/2], x->toep[(l+1)/2+x-1]),\n List([1..size-l], x->0),\n List([1..(l-1)/2], x->toep[x]))),\n\n switch := false,\n applicable := (self, t) >> self.applicableSizes(Rows(t)) and t.hasTags(),\n\n children := meth(self, t)\n local P, N, k, circsize, dvar, diag, toep, circ, diagonalized_circ, tags, kids;\n\n tags := t.getTags();\n P := t.params;\n N := P[1];\n k := P[2];\n diag := FData(self.diag(N,k));\n toep := self.toeplitz(N,k);\n kids := [];\n for circsize in self.circSizes(N) do\n dvar := Dat(TArray(TComplex, circsize));\n circ := self.circulantToep(toep, circsize);\n diagonalized_circ := FData(1/circsize * ComplexFFT(circ));\n Add(kids, [\n TCompose([\n TRDiag(circsize/2, N, diag).transpose(),\n PrunedDFT(circsize, -1, circsize/2, [0]).transpose(),\n TDiag(diagonalized_circ),\n PrunedDFT(circsize, 1, circsize/2, [0]),\n TRDiag(circsize/2, N, diag)\n ]).withTags(tags)\n ]);\n od;\n\n return kids;\n end,\n\n apply := (t, C, Nonterms) -> C[1]\n ),\n\n\n #F DFT_GoodThomas : Prime Factor FFT\n #F\n #F DFT_n*k -> perm * (DFT_n_a tensor DFT_k_b) * perm\n #F when gcd(n,k) = 1\n #F\n DFT_tSPL_GoodThomas := rec(\n applicable := (t) ->\n t.params[1] > 2\n and DivisorPairsRP(t.params[1]) <> []\n and t.hasTags(),\n\n children := (self, t) >> let(\n tags := t.getTags(),\n mn := t.params[1],\n k := t.params[2],\n Map2(DivisorPairsRP(mn), (m,n) -> [\n TTensor(DFT(m, k*n mod m), DFT(n, k*m mod n)).withTags(tags)\n ])\n ),\n\n apply := (t, C, Nonterms) -> let(\n P := t.params,\n r := Rows(Nonterms[1].params[1]),\n s := Rows(Nonterms[1].params[2]),\n alpha := 1 / s mod r,\n beta := 1 / r mod s,\n # CRT should not be pulled into sums before DelayedDirectSums are terminated,\n # otherwise PFA inside Rader for n =vq breaks as VectRaderDiag rules can't match\n DelayedPrm(CRT(r,s,1,1)).transpose() * C[1] * DelayedPrm(CRT(r,s,1,1))\n )\n )\n));\n\n#--------------------------------------------------------------------------------------\n\nNewRulesFor(TTensorI, rec(\n\n # Vector recursion for the DFT\n DFT_vecrec := rec(\n forTransposition := false,\n applicable := nt ->\n ObjId(nt.params[1]) = DFT\n and IsParVec(nt.params)\n and let(p1 := nt.params[1].params[1],\n p1 > 2 and not IsPrime(p1)\n )\n and nt.hasTags(),\n\n children := nt -> let(\n f := nt.params[1],\n k := nt.params[2],\n Map2(DivisorPairs(f.params[1]), (m,n) -> let(\n r := When(\n nt.hasTags() and nt.firstTagIs(spiral.paradigms.vector.AVecReg),\n VWrapTRC(nt.firstTag().v),\n VWrapId\n ),\n [\n TGrp(TCompose([\n TTensorI(DFT(m, f.params[2] mod m), n, AVec, AVec),\n TDiag(fPrecompute(Tw1(m*n, n, f.params[2])))\n ])).withTags(nt.getTags()), <# strange #>\n TTensorI(\n TTensorI(DFT(n, f.params[2] mod n), m, APar, AVec),\n k, APar, AVec\n ).withTags(nt.getTags()) <# strange #>\n ]\n ))\n ),\n\n apply := (nt, c, cnt) -> Tensor(I(nt.params[2]), c[1]) * c[2],\n\n switch := false\n\n#D isApplicable := (self,P) >> ObjId(P[1])=DFT and P[3].isPar and P[4].isVec and\n#D let(P1:=P[1].params[1], P1 > 2 and not IsPrime(P1)) and PHasTags(self.nonTerminal, P),\n\n#D allChildren := P -> let(k:=P[2],\n#D Map2(DivisorPairs(P[1].params[1]),\n#D (m,n) -> let( r:=When(Length(P[5])>0 and P[5][1].isReg, VWrapTRC(P[5][1].v), VWrapId),\n#D [ TGrp(TCompose([TTensorI(DFT(m, P[1].params[2] mod m), n, AVec, AVec),\n#D TDiag(fPrecompute(Tw1(m*n, n, P[1].params[2])))]), P[5]).setWrap(r),\n\n#D TTensorI(TTensorI(DFT(n, P[1].params[2] mod n), m, APar, AVec),\n#D k, APar, AVec, P[5]).setWrap(r) ]))),\n\n#D rule := (P,C,nt) -> Tensor(I(P[2]), C[1]) * C[2],\n ),\n\n # Transposed vector recursion for the DFT\n DFT_vecrec_T := rec(\n forTransposition := false,\n\n applicable := nt ->\n ObjId(nt.params[1]) = DFT\n and IsVecPar(nt.params)\n and let(\n p1 := nt.params[1].params[1],\n p1 > 2\n and IsPrime(p1)\n )\n and nt.hasTags(),\n\n children := nt -> let(\n k := nt.params[2],\n Map2(DivisorPairs(nt.params[1].params[1], (m,n) -> let(\n r := When(nt.hasTags() and nt.isTag(1, spiral.paradigms.vector.AVecReg),\n VWrapTRC(nt.firstTag().v),\n VWrapId\n ),\n [\n TTensorI(\n TTensorI(DFT(n, P[1].params[2] mod n), m, AVec, APar),\n k, AVec, APar\n ).withTags(nt.getTags()).setWrap(r), <# strange #>\n TGrp(TCompose([\n TDiag(fPrecompute(Tw1(m*n, n, P[1].params[2]))),\n TTensorI(DFT(m, P[1].params[2] mod m), n, AVec, AVec)\n ])).withTags(nt.getTags()).setWrap(r) <# strange #>\n ]\n )))\n ),\n\n apply := (nt, c, cnt) -> c[1] * Tensor(I(nt.params[2]), c[2]),\n\n switch := false\n\n#D isApplicable := (self,P) >> ObjId(P[1])=DFT and P[3].isVec and P[4].isPar and\n#D let(P1:=P[1].params[1], P1 > 2 and not IsPrime(P1)) and PHasTags(self.nonTerminal, P),\n#D allChildren := P -> let(k:=P[2],\n#D Map2(DivisorPairs(P[1].params[1]),\n#D (m,n) -> let(r:=When(Length(P[5])>0 and P[5][1].isReg, VWrapTRC(P[5][1].v), VWrapId), [\n#D TTensorI(TTensorI(DFT(n, P[1].params[2] mod n), m, AVec, APar),\n#D k, AVec, APar, P[5]).setWrap(r),\n#D\n#D TGrp(TCompose([TDiag(fPrecompute(Tw1(m*n, n, P[1].params[2]))),\n#D TTensorI(DFT(m, P[1].params[2] mod m), n, AVec, AVec)\n#D ]), P[5]).setWrap(r)\n#D ]))),\n#D\n#D rule := (P,C) -> C[1] * Tensor(I(P[2]), C[2]),\n\n )\n));\n\n\n\n#######################################################################################################\n# tSPL rule\nNewRulesFor(MDDFT, rec(\n MDDFT_tSPL_RowCol := rec(\n info := \"tSPL MDDFT_n -> MDDFT_n/d, MDDFT_d\",\n\n applicable := (self, t) >> Length(t.params[1]) > 1,\n freedoms := t -> [ [1..Length(t.params[1])-1] ],\n\n child := (t, fr) -> let(\n newdims := SplitAt(t.params[1], fr[1]),\n rot := t.params[2],\n [ TTensor(\n MDDFT(newdims[1], rot),\n MDDFT(newdims[2], rot)\n ).withTags(t.getTags())]\n ),\n\n apply := (t, C, Nonterms) -> C[1],\n switch := false\n ),\n));\n\n\nAllRadices := function(n)\n local divisors, radices;\n divisors := DropLast(Drop(DivisorsInt(n), 1), 1);\n radices := Filtered(divisors, i -> n=(i^LogInt(n, i)));\n return radices;\nend;\n\n\n\n##########################################################################################\n# tSPL Pease DFT rule\nNewRulesFor(DFT, rec(\n DFT_tSPL_Pease := rec (\n info := \"Pease tSPL DFT_(k) -> (\\Prod(L(I tensor F)Tc))*DR(k,r)\",\n# forTransposition := false,\n forTransposition := true,\n maxRadix := 32,\n minRadix := 4,\n\n applicable := (self, nt) >>\n nt.hasTags()\n and nt.params[2] = 1\n and let(\n r := AllRadices(nt.params[1]),\n Length(r) > 0\n and ForAny(r, i ->\n i >= self.minRadix\n and i <= self.maxRadix\n #and nt.firstTag().legal_kernel(i)\n )\n ),\n\n children := (self, nt) >> let(\n N := nt.params[1],\n m := nt.params[2],\n radices := Filtered(AllRadices(N), i ->\n i >= self.minRadix and i <= self.maxRadix\n #and nt.firstTag().legal_kernel(i)\n ),\n j := var(\"j\"),\n\n List(radices, rdx -> [\n TCompose([\n TICompose(j, LogInt(N, rdx),\n TCompose([\n TTensorI(DFT(rdx, m), N/rdx, AVec, APar),\n TDiag(fPrecompute(TC(N, rdx, j, m)))\n ])\n ),\n TDR(N, rdx)\n ]).withTags(nt.getTags()),\n ])\n ),\n\n apply := (nt, c, cnt) -> c[1],\n\n switch := false\n\n#D isApplicable := (self, P) >> PHasTags(self.nonTerminal, P) and P[2] = 1 and\n#D let(r := AllRadices(P[1]),\n#D Length(r) > 0 and\n#D ForAny(r, i-> i >= self.minRadix and i <= self.maxRadix and PGetFirstTag(self.nonTerminal, P).legal_kernel(i))\n#D ),\n#D\n#D allChildren := (self, P) >> let(\n#D N := P[1],\n#D m := P[2],\n#D radices := Filtered(AllRadices(N), i-> i >= self.minRadix and i <= self.maxRadix and PGetFirstTag(self.nonTerminal, P).legal_kernel(i)),\n#D j := var(\"j\"),\n#D\n#D List(radices, rdx ->\n#D [\n#D AddTag(\n#D TCompose([\n#D TICompose(j, LogInt(N, rdx),\n#D TCompose([\n#D TTensorI(DFT(rdx, m), N/rdx, AVec, APar),\n#D TDiag(fPrecompute(TC(N, rdx, j, m)))\n#D ])),\n#D TDR(N, rdx)\n#D ]),\n#D PGetTags(self.nonTerminal, P))\n#D ]\n#D )),\n#D\n#D rule := (P, C) -> C[1],\n )\n));\n\n##########################################################################################\n# tSPL Stockham DFT rule\nNewRulesFor(DFT, rec(\n DFT_tSPL_Stockham := rec (\n info := \"Stockham tSPL DFT_(k) -> (\\Prod(DFT tensor I)*Diag*(L tensor I))\",\n forTransposition := false,\n maxRadix := 2,\n minRadix := 2,\n\n #one dimensional transform --> nt.params[2] = 1\n applicable := (self, nt) >>\n nt.hasTags()\n and nt.params[2] = 1\n and let(\n r := AllRadices(nt.params[1]),\n Length(r) > 0\n and ForAny(r, i ->\n i >= self.minRadix\n and i <= self.maxRadix\n #and nt.firstTag().legal_kernel(i)\n )\n ),\n\n children := (self, nt) >> let(\n N := nt.params[1],\n m := nt.params[2],\n radices := Filtered(AllRadices(N), i ->\n i >= self.minRadix and i <= self.maxRadix and (When(IsBound(nt.firstTag().legal_kernel), nt.firstTag().legal_kernel(i), true))\n ),\n#need the tag for TICompose to be parallelized, but then the DFT(r) in TTensorI will not be broken down\n#if i use no tag for TICompose, no parallelization will take place ...\n#solution: drop tags in GT_Par's children function --> rule GT_Par_drop implemented in paradigms/gpu/breakdown.gi\n List(radices, rdx -> let(j := var.fresh(\"j\", TInt, LogInt(N, rdx)), tags := Drop(t.getTags(), 1),\n [TICompose(j, LogInt(N, rdx),\n TCompose([\n TTensorI(DFT(rdx, m), N/rdx, AVec, AVec),\n #Diag(fPrecompute(diagTensor(Stockham_radix.gen(rdx, LogInt(N, rdx)-j-1), fConst(TComplex, rdx^j, 1)))),\n #Tensor(Diag(fPrecompute(Stockham_radix.gen(rdx, LogInt(N, rdx)-j-1))), I(rdx^j)),\n #TDiag(fPrecompute(diagTensor(TC5(rdx, LogInt(N, rdx)-j-1), fConst(TComplex, rdx^j, 1)))),\n TTwiddle_Stockham(N, N/rdx, rdx, j),\n Tensor(L(N/rdx^j, rdx), I( rdx^j))\n ])\n ).withTags(nt.getTags()),\n ])\n )\n ),\n\n apply := (nt, c, cnt) -> c[1],\n\n switch := false\n )\n));\n\nNewRulesFor(DFT, rec(\n DFT_tSPL_Stockham_split := rec (\n info \t:= \"Stockham tSPL DFT_(k) -> (\\Prod(DFT tensor I)*Diag*(L tensor I)), first n iterations split off\",\n forTransposition \t:= false,\n minRadix \t:= 4,\n maxRadix \t:= 4,\n\n # one dimensional transform --> nt.params[2] = 1\n # first parameter of AGenericTag indicates how many iterations to split off\n applicable := (self, nt) >>\n nt.hasTags()\n# and nt.firstTag().kind() = AGenericTag\n# and IsPosInt(nt.firstTag().params[1])\n and nt.params[2] = 1\n and let(\n r := AllRadices(nt.params[1]),\n Length(r) > 0\n and ForAny(r, i ->\n i >= self.minRadix\n and i <= self.maxRadix\n #and nt.firstTag() is GPU tag\n #and nt.firstTag().legal_kernel(i)\n )\n ),\n\n children := (self, nt) >> let(\n N := nt.params[1],\n m := nt.params[2],\n# number of iterations to peel off is n\n# n := nt.firstTag().params[1],\n n := 1,\n radices := Filtered(AllRadices(N), i ->\n i >= self.minRadix and i <= self.maxRadix and (When(IsBound(nt.firstTag().legal_kernel), nt.firstTag().legal_kernel(i), true))\n ),\n List(radices, rdx -> let(j := var.fresh(\"j\", TInt, LogInt(N, rdx)-n), i := var.fresh(\"i\", TInt, n),\n \t# first TICompose deals with the iterations [n..LogInt(N,rdx)-1], these are the critical write-out stages\n\n \t[TCompose([\n \tTICompose(j, LogInt(N, rdx)-n,\n \t TCompose([\n \t TTensorI(DFT(rdx, m), N/rdx, AVec, AVec),\n \t#TDiag(fPrecompute(diagTensor(Stockham_radix.gen(rdx, LogInt(N, rdx)-j-1), fConst(TComplex, rdx^j, 1)))),\n \t#Diag(fPrecompute(diagTensor(TTwiddle_Stockham(rdx^(LogInt(N, rdx)-j), rdx^(LogInt(N, rdx)-j-1), 1).terminate(), fConst(TComplex, rdx^j, 1)))),\n\t TTwiddle_Stockham(N, N/rdx, rdx, j),\n\t TL(N/rdx^j, rdx, 1, rdx^j)\n \t ])\n \t ).withTags(nt.getTags()),\n \t # second TICompose has to range from [0..n-1]\n \t TICompose(i, n,\n\t TCompose([\n \t TTensorI(DFT(rdx, m), N/rdx, AVec, AVec),\n \t #TDiag(fPrecompute(diagTensor(Stockham_radix.gen(rdx, n-i-1), fConst(TComplex, N/rdx^(n-i), 1)))),\n \t#Tensor(TTwiddle(rdx^(n-j), rdx^(n-j-1)), I(rdx^j)),\n\t #Diag(fPrecompute(diagTensor(TTwiddle_Stockham(rdx^(LogInt(N, rdx)-j), rdx^(LogInt(N, rdx)-j-1), 1).terminate(), fConst(TComplex, rdx^j, 1)))),\n\t\t\t\t\t\t\t\tTTwiddle_Stockham(N, N/rdx, rdx, j),\n \t TL(rdx^(n-i), rdx, 1, N/rdx^(n-i))\n \t ])\n\t ).withTags(nt.getTags()),\n\t\t\t\t\t])\n ])\n )\n ),\n\n apply := (nt, c, cnt) -> c[1],\n\n switch := false\n )\n));\n", "meta": {"hexsha": "bcbc14dece3219cde789e0adbcfc91d115b3573f", "size": 21949, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/common/dft.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/common/dft.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/common/dft.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 37.7130584192, "max_line_length": 172, "alphanum_fraction": 0.4309535742, "num_tokens": 6175, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127380808499, "lm_q2_score": 0.6654105587468141, "lm_q1q2_score": 0.5682025521674002}}
{"text": "################################################################################\n##\n#W Projective_Representations.gi GroupTheoretical Package\n##\n#W Paul Bruillard, Cesar Galindo, Siu-Hung Ng, Julia Plavnik, Eric Rowell, \n#W Zhenghan Wang\n##\n## Installation file for Projective_Reprsentations functions of the GroupTheoretical Package\n##\n#Y Copyright (C) 2016, Battelle Memorial Institute\n##\n################################################################################\n\n\n################################################################################\n##\n#F compute_simples(<group>,<int>,<function>) . . . . . compute simples in D^w(G)\n##\nInstallGlobalFunction( projective_reps, function(G,alpha,n) \n local chi, chi_i, rho_i, Mi, g, x, rho, component_bases, Degrees, algebra_basis_vectors, algebra_basis, twisted_group_alg, dd, lst, i, j, k, h, GSet, T, F;\n\n F:=CF(n);;\n\n # cosntruct the twisted group algebra according to the multiplication rule:\n # g*h=alpha(g,h)gh\n T:=EmptySCTable(Order(G),0);;\n GSet:=AsSet(G);;\n for i in [1..Order(G)] do\n g:=GSet[i];;\n for j in [1..Order(G)] do\n h:=GSet[j];;\n k:=Position(GSet,g*h);;\n # we need to convert alpha(g,h) from an abstract cyclic group element to a\n # complex, so we assign the generator of the cyclic group Z_s to E(s), a\n # primitive s-th root of unity\n #lst:=[E(s)^Position(OrderedA,alpha(g,h)),k];;\n lst:=[alpha(g,h),k];;\n SetEntrySCTable(T,i,j,lst);;\n od;;\n od;;\n twisted_group_alg:=AlgebraByStructureConstants(F,T);;\n\n # verify that the algebra is associative and then compute its decomposition\n if not(IsAssociative(twisted_group_alg)) then\n Error(\"algebra is not associative. There is likely an error or your 3-cocycle\\n\");\n fi;\n dd:=DirectSumDecomposition(twisted_group_alg);\n\n # compute a basis for the algebra and a basis for each of the decomposition\n # components\n algebra_basis:=Basis(twisted_group_alg);\n algebra_basis_vectors:=BasisVectors(algebra_basis);\n component_bases:=List(dd,Basis);\n Degrees:=List(List(component_bases, Size), Sqrt);# check whether the degrees are squares otherwise extends the field.\n\n # compute the represenations and characters\n rho:=[];\n chi:=[];\n for Mi in component_bases do\n # compute the representation corresponding to component Mi\n #\n # for each g (basis vector for the twisted group algebra) compute the matrix\n # rho_i(g)_{a,b} according to rho_i(g)(v_a) = Sum_{b}rho_i(g)_{a,b}v_b where\n # {v_{a}} is the basis Mi for the ith component.\n rho_i:=List(algebra_basis_vectors,g->List(Mi,x->Coefficients(Mi,g*x)));\n Append(rho,[rho_i]);\n # for each g, compute chi_i(g)=Tr(rho_i(g))/sqrt(dim of the ideal)\n chi_i:=List(rho_i,x->Trace(x))/Sqrt(Size(Mi));\n Append(chi,[chi_i]);\n od;\n return chi;\nend);\n\n#E Projective_Representations.gi . . . . . . . . . . . . . . . . . . . ends here\n", "meta": {"hexsha": "24c2bd1a29fdfaf15d0b4964ab072a9e48aa717c", "size": 2904, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/Projective_Representations.gi", "max_stars_repo_name": "pnnl/GroupTheoretical", "max_stars_repo_head_hexsha": "d60aaec27d2ca98ec55b12b78213538a346eef27", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/Projective_Representations.gi", "max_issues_repo_name": "pnnl/GroupTheoretical", "max_issues_repo_head_hexsha": "d60aaec27d2ca98ec55b12b78213538a346eef27", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2021-05-20T21:43:28.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-20T21:43:28.000Z", "max_forks_repo_path": "lib/Projective_Representations.gi", "max_forks_repo_name": "pnnl/GroupTheoretical", "max_forks_repo_head_hexsha": "d60aaec27d2ca98ec55b12b78213538a346eef27", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2017-12-07T13:46:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-12-12T22:39:35.000Z", "avg_line_length": 38.72, "max_line_length": 157, "alphanum_fraction": 0.6256887052, "num_tokens": 780, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744850834649, "lm_q2_score": 0.6926419767901475, "lm_q1q2_score": 0.566286407521398}}
{"text": "{\n \"geometry\":{\n \"num_positions\":16,\n \"vertices\":\n [0, 2, 3, 5, 7, 6, 4, 1, 8, 10, 11, 13, 15, 14, 12, 9],\n \"triangles\":\n [[7, 3, 4], [15, 11, 12], [8, 14, 15], [14, 11, 15], [8, 9, 14], [9, 13, 14], [9, 10, 13], [10, 12, 13], [10, 15, 12], [0, 6, 7], [6, 3, 7], [0, 1, 6], [1, 5, 6], [1, 2, 5], [2, 4, 5], [2, 7, 4]],\n \"edges\":\n [[0, 1], [1, 2], [2, 7], [3, 4], [4, 5], [5, 6], [6, 3], [7, 0], [8, 9], [9, 10], [10, 15], [11, 12], [12, 13], [13, 14], [14, 11], [15, 8]],\n \"wires\":\n [[7, 0, 1, 2], [3, 4, 5, 6], [15, 8, 9, 10], [11, 12, 13, 14]],\n \"faces\":\n [[[0, 1], [0, 9, 10, 11, 12, 13, 14, 15]], [[2, 3], [1, 2, 3, 4, 5, 6, 7, 8]]],\n \"points\":\n [],\n \"polylines\":\n [],\n \"polygons\":\n [0, 1],\n \"collections\":\n [[-1, [], [], [0, 1]]]\n },\n \"attributes\":{\n \"positions\":[\n {\n \"name\":\"xyz\", \"data_type\":\"Float\", \"data_size\":3,\n \"data\":\n [[[1], [5.0, -5.0, 0.0]], [[11], [5.692976474761963, 13.588506698608398, 4.288722991943359]], [[0], [-5.0, -5.0, 0.0]], [[13], [2.486837387084961, 6.556811809539795, 2.6226086616516113]], [[5], [2.5, -2.5, 0.0]], [[8], [-4.894385814666748, 4.212913513183594, 4.211219787597656]], [[9], [4.5743794441223145, 4.212913513183594, 0.995246171951294]], [[14], [-1.6882468461990356, 11.244607925415039, 5.877334117889404]], [[4], [-2.5, -2.5, 0.0]], [[12], [-2.2475452423095703, 6.556811809539795, 4.230595588684082]], [[6], [-2.5, 2.5, 0.0]], [[7], [2.5, 2.5, 0.0]], [[2], [-5.0, 5.0, 0.0]], [[10], [-3.7757887840270996, 13.588506698608398, 7.504696846008301]], [[15], [3.046135902404785, 11.244607925415039, 4.269347190856934]], [[3], [5.0, 5.0, 0.0]]]\n }\n ],\n \"vertices\":[\n\n ],\n \"edges\":[\n\n ],\n \"wires\":[\n\n ],\n \"faces\":[\n\n ],\n \"collections\":[\n {\n \"name\":\"name\", \"data_type\":\"String\", \"data_size\":1,\n \"data\":[[[0], \"all\"]]\n }\n ]\n }\n}\n", "meta": {"hexsha": "1b8b39e65008722f4092c77643273cd7553ea1c8", "size": 2151, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "assets/gi-json/two_polygons_with_holes.gi", "max_stars_repo_name": "design-automation/mobius-parametric-modeller-0-4-30", "max_stars_repo_head_hexsha": "e3d048f68dfc6b32978d95543d06a2b5122367b3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2018-11-19T02:30:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-15T03:38:39.000Z", "max_issues_repo_path": "assets/gi-json/two_polygons_with_holes.gi", "max_issues_repo_name": "design-automation/mobius-parametric-modeller-0-4-30", "max_issues_repo_head_hexsha": "e3d048f68dfc6b32978d95543d06a2b5122367b3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 654, "max_issues_repo_issues_event_min_datetime": "2018-12-10T04:06:51.000Z", "max_issues_repo_issues_event_max_datetime": "2020-10-07T14:47:20.000Z", "max_forks_repo_path": "assets/gi-json/two_polygons_with_holes.gi", "max_forks_repo_name": "design-automation/mobius-parametric-modeller-0-4-30", "max_forks_repo_head_hexsha": "e3d048f68dfc6b32978d95543d06a2b5122367b3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2018-12-20T02:12:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-25T23:15:11.000Z", "avg_line_length": 42.1764705882, "max_line_length": 767, "alphanum_fraction": 0.4030683403, "num_tokens": 981, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.82893881677331, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.5658118584116888}}
{"text": "#######################################################################\n# Description: A function to initialize a generator for random #\n# permutations, described in section 4.1. # \n# Input: - list of generators S #\n# Output: - list of permutations X including repetitions of generators#\n# from S #\n#######################################################################\n\nInitGenerator := function(S)\n local i, X, k;\n X := List(S); k := Length(X);\n for i in [k+1..Maximum(11, Length(S))] do\n Add(X, X[i-k]);\n od;\n if IsReadOnlyGlobal(\"X\") = true then \n MakeReadWriteGlobal(\"X\");\n fi;\n return X;\nend;\n\n#######################################################################\n#######################################################################\n\n#######################################################################\n# Description: A function to calculate a random permutation, #\n# described in section 4.1. # \n# Input: - list of generators S, generator X returned by InitGenerator#\n# Output: - random permutation a as cycle #\n#######################################################################\n\nRandomPerm := function(S, X)\n local Randomize, a, r, i;\n \n r := Maximum(11, Length(S)); \n Randomize := function()\n local s, t, e, range;\n \n # indices s and t specify which permutations X[s], X[t]\n # will be multiplied with each other\n # e specifies whether X[t] or its inverse will be used\n range := [1..r]; s := Random(range); e := Random([-1,1]);\n t := Random(range); Remove(range, s); \n \n # alternate the order of multiplication \n # of X[t] and X[s] randomly\n # update generator X\n \n if Random([1,2]) = 1 then\n X[s] := X[s]*X[t]^e;\n a := a*X[s];\n else\n X[s] := X[t]^e*X[s];\n a := X[s]*a;\n fi;\n return a;\n end; \n \n # calculate random permutation a as\n # product of random permutations from X\n a := ();\n for i in [1..50] do\n Randomize();\n od;\n return a;\nend;\n", "meta": {"hexsha": "41e85cccd8514db806fbbd0835360f2159580f17", "size": 2328, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "src/RandomPerm.gi", "max_stars_repo_name": "AlexanderKlemps/parallel-schreier-sims", "max_stars_repo_head_hexsha": "7a2fc1637f85067ba8162aefbde3f26b1b6da12e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/RandomPerm.gi", "max_issues_repo_name": "AlexanderKlemps/parallel-schreier-sims", "max_issues_repo_head_hexsha": "7a2fc1637f85067ba8162aefbde3f26b1b6da12e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/RandomPerm.gi", "max_forks_repo_name": "AlexanderKlemps/parallel-schreier-sims", "max_forks_repo_head_hexsha": "7a2fc1637f85067ba8162aefbde3f26b1b6da12e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2727272727, "max_line_length": 75, "alphanum_fraction": 0.3947594502, "num_tokens": 469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438951025545426, "lm_q2_score": 0.6688802537704064, "lm_q1q2_score": 0.5644647703522856}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n_RDFT_CONST := 2.5;\n\n#F TRDFT2D([<m>, <n>], <k>)\nClass(TRDFT2D, TaggedNonTerminal, rec(\n abbrevs := [\n P -> Checked(IsList(P), Length(P) = 2, ForAll(P,i->IsPosInt(i) and IsEvenInt(i)), Product(P) > 1,\n [ RemoveOnes(P), 1]),\n (P,k) -> Checked(IsList(P), Length(P) = 2, ForAll(P,IsPosInt), IsInt(k), Product(P) > 1,\n Gcd(Product(P), k)=1,\n [ RemoveOnes(P), k mod Product(P)])\n ],\n dims := self >> let(m := self.params[1][1], n := self.params[1][2], d := [n*(m+2), m*n], When(self.transposed, Reversed(d), d)),\n isReal := True,\n terminate := self >>\n Gath(fTensor(fAdd(self.params[1][1], (self.params[1][1]+2)/2, 0), fId(2*self.params[1][2]))) *\n RC(MDDFT(self.params[1], self.params[2]).terminate()) *\n Scat(fTensor(fId(Product(self.params[1])), fBase(2, 0))),\n normalizedArithCost := (self) >> let(n := Product(self.params[1]), IntDouble(_RDFT_CONST * n * d_log(n) / d_log(2))),\n compute := meth(self, data)\n local rows, cols, cxrows, m1, m2;\n\n rows := self.params[1][1];\n cols := self.params[1][2];\n cxrows := Rows(self)/cols;\n\n m1 := List(TransposedMat(List(TransposedMat(data), i->ComplexFFT(i){[1..cxrows/2]})), ComplexFFT);\n m2 := Flat(List(Flat(m1), i->[ReComplex(i), ImComplex(i)]));\n\n return List([0..cxrows-1], i->m2{[cols*i+1..cols*(i+1)]});\n end\n));\n\n\n#F TIRDFT2D([<m>, <n>], <k>)\nClass(TIRDFT2D, TaggedNonTerminal, rec(\n abbrevs := [\n P -> Checked(IsList(P), Length(P) = 2, ForAll(P,i->IsPosInt(i) and IsEvenInt(i)), Product(P) > 1,\n [ RemoveOnes(P), 1]),\n (P,k) -> Checked(IsList(P), Length(P) = 2, ForAll(P,IsPosInt), IsInt(k), Product(P) > 1,\n Gcd(Product(P), k)=1,\n [ RemoveOnes(P), k mod Product(P)])\n ],\n dims := self >> let(m := self.params[1][1], n := self.params[1][2], d := [m*n, n*(m+2)], When(self.transposed, Reversed(d), d)),\n isReal := True,\n terminate := self >> let(cxrows := (self.params[1][1]+2)/2, rows := self.params[1][1], cols := self.params[1][2], k := self.params[2],\n Tensor(PRDFT(rows,k).inverse().terminate(), I(cols)) * Tensor(I(cxrows), L(2*cols, 2)*RC(DFT(cols, -k)))),\n normalizedArithCost := (self) >> let(n := Product(self.params[1]), IntDouble(_RDFT_CONST * n * d_log(n) / d_log(2)))\n));\n\n\n#F 2D RDFT Rule\nNewRulesFor(TRDFT2D, rec(\n TRDFT2D_ColRow_tSPL := rec(\n switch := true,\n applicable := (self, t) >> true,\n children := (self, t) >> let(m := t.params[1][1], n:=t.params[1][2], k:= t.params[2], tags := t.getTags(),\n [[\n TCompose([\n TTensorI(TCompose([TRC(DFT(n, k)), TPrm(L(2*n, n))]), (m+2)/2, APar, APar),\n TTensorI(PRDFT1(m, k), n, AVec, AVec)\n ]).withTags(t.getTags())\n ]]),\n apply := (self, t, C, Nonterms) >> C[1]\n )\n));\n\n\n#F 2D IRDFT Rule\nNewRulesFor(TIRDFT2D, rec(\n TIRDFT2D_RowCol_tSPL := rec(\n switch := true,\n applicable := (self, t) >> true,\n children := (self, t) >> let(m := t.params[1][1], n:=t.params[1][2], k:= t.params[2], tags := t.getTags(),\n [[\n TCompose([\n TTensorI(PRDFT1(m, k).inverse(), n, AVec, AVec),\n TTensorI(TCompose([TPrm(L(2*n, 2)), TRC(DFT(n, -k))]), (m+2)/2, APar, APar)\n ]).withTags(t.getTags())\n ]]),\n apply := (self, t, C, Nonterms) >> C[1]\n )\n));\n", "meta": {"hexsha": "cca283bcd194a3654699a46bcececfe908fa5765", "size": 3640, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/common/mdrdft.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/common/mdrdft.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/common/mdrdft.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 41.3636363636, "max_line_length": 138, "alphanum_fraction": 0.5134615385, "num_tokens": 1205, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835289107309, "lm_q2_score": 0.672331705744791, "lm_q1q2_score": 0.561722066114229}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nClass(VectorizedBaseMat, BaseMat, SumsBase, rec(\n transpose := self >> Inherit(self, rec(transposed := not self.transposed)),\n #-----------------------------------------------------------------------\n print := (self,i,is) >> Print(self.name, \"(\", self.n, \", \", self.v,\")\", \n\tself.printA(), When(self.transposed, \".transpose()\", \"\")),\n));\n \n#F VS(<n>, <v>) -- vectorized version of doubly-diagonal matrix\n#F \n#F Represents the matrix that has 1s on the main diagonal and upper shifted by 1 diagonal\n#F\n#F <n> - matrix size\n#F <v> - vector length, does not affect matrix shape, only needed for Codegen \n#F\n#F Example:\n#F\n#F spiral> PrintMat(MatSPL(VS(8,4)));\n#F [ [ 1, 1, , , , , , ], \n#F [ , 1, 1, , , , , ], \n#F [ , , 1, 1, , , , ], \n#F [ , , , 1, 1, , , ], \n#F [ , , , , 1, 1, , ], \n#F [ , , , , , 1, 1, ], \n#F [ , , , , , , 1, 1 ], \n#F [ , , , , , , , 1 ] ]\n#F \nClass(VS, VectorizedBaseMat, rec(\n new := (self, n, v) >> SPL(WithBases(self, \n rec(n := n, v := v, transposed := false))).setDims(),\n #-----------------------------------------------------------------------\n dims := self >> [self.n, self.n], \n #-----------------------------------------------------------------------\n rChildren := self >> [self.n, self.v],\n rSetChild := rSetChildFields(\"n\", \"v\"),\n #-----------------------------------------------------------------------\n area := self >> self.n * self.n,\n #-----------------------------------------------------------------------\n toAMat := self >> let(s:=S(self.n), AMatMat(MatSPL(When(self.transposed, s.transpose(), s))))\n));\n\nDeclare(VLD);\n\n#F VUD(<n>, <v>) -- vectorized upper diagonal matrix\n#F\n#F VUD(n,v) is equivalent to UD(n,1)\n#F\n#F <n> -- matrix size\n#F <v> -- vector length, does not affect matrix shape, only needed for Codegen \n#F\n#F spiral> PrintMat(MatSPL(VUD(8,4)));\n#F [ [ , 1, , , , , , ], \n#F [ , , 1, , , , , ], \n#F [ , , , 1, , , , ], \n#F [ , , , , 1, , , ], \n#F [ , , , , , 1, , ], \n#F [ , , , , , , 1, ], \n#F [ , , , , , , , 1 ], \n#F [ , , , , , , , ] ]\n#F\nClass(VUD, VectorizedBaseMat, rec(\n new := (self, n, v) >> SPL(WithBases(self, rec(n := n, v := v))).setDims(),\n #-----------------------------------------------------------------------\n transpose := (self) >> VLD(self.n, self.v),\n #-----------------------------------------------------------------------\n dims := self >> [self.n, self.n], \n #-----------------------------------------------------------------------\n rChildren := self >> [self.n, self.v],\n rSetChild := rSetChildFields(\"n\", \"v\"),\n #-----------------------------------------------------------------------\n area := self >> self.n,\n #-----------------------------------------------------------------------\n toAMat := self >> UD(self.n).toAMat()\n));\n\n#F VLD(<n>, <v>) -- vectorized lower diagonal matrix\n#F\n#F VLD(n,v) is equivalent to LD(n,1)\n#F\n#F <n> -- matrix size\n#F <v> -- vector length, does not affect matrix shape, only needed for Codegen \n#F\n#F spiral> PrintMat(MatSPL(VLD(8,4)));\n#F [ [ , , , , , , , ], \n#F [ 1, , , , , , , ], \n#F [ , 1, , , , , , ], \n#F [ , , 1, , , , , ], \n#F [ , , , 1, , , , ], \n#F [ , , , , 1, , , ], \n#F [ , , , , , 1, , ], \n#F [ , , , , , , 1, ] ]\n#F\nClass(VLD, VectorizedBaseMat, rec(\n new := (self, n, v) >> SPL(WithBases(self, rec(n := n, v := v))).setDims(),\n #-----------------------------------------------------------------------\n transpose := (self) >> VUD(self.n, self.v),\n #-----------------------------------------------------------------------\n dims := self >> [self.n, self.n], \n #-----------------------------------------------------------------------\n rChildren := self >> [self.n, self.v],\n rSetChild := rSetChildFields(\"n\", \"v\"),\n #-----------------------------------------------------------------------\n area := self >> self.n,\n #-----------------------------------------------------------------------\n toAMat := self >> LD(self.n, 1).toAMat()\n));\n", "meta": {"hexsha": "e3e98a0c29ac94244aea7e22869f146ce6e86948", "size": 4306, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/paradigms/vector/sigmaspl/vs.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/paradigms/vector/sigmaspl/vs.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/paradigms/vector/sigmaspl/vs.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 38.7927927928, "max_line_length": 97, "alphanum_fraction": 0.3376683697, "num_tokens": 1370, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802264851919, "lm_q2_score": 0.7279754430043072, "lm_q1q2_score": 0.5598715185814105}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\n#\n# Frontier\n#\n\n#F _DFUnion(<list_frontiers>) merges frontiers.\n#F Multiple frontiers result from multiple outgoing paths.\n#F\n#F For example t3 = add(t1,t2) will have the frontier\n#F [ [t3], _DFUnion([DefFrontier(t1), DefFrontier(t2)]) ]\n#F\n#F The parameter is a list of frontiers, where each frontier\n#F is a list of sets of variables. \n#F\n_DFUnion := function(list_frontiers)\n local depths, maxdepth, curset, res, numfrontiers, d, j;\n numfrontiers := Length(list_frontiers); \n depths := List(list_frontiers, Length);\n maxdepth := Maximum0(depths);\n res := [];\n for d in [1..maxdepth] do \n curset := Set([]);\n\tfor j in [1..numfrontiers] do\n\t if d <= depths[j] then \n\t\tcurset := UnionSet(curset, list_frontiers[j][d]); \n\t else \n\t\t# if frontier is shorter than the longest, we carry over its last terms. \n\t\t# For instance, the frontier of t5 in { t3=add(t1,t2); t5=add(t3, t4) }\n\t\t# is [[t5], [t3, t4], [t1, t2, t3]].\n\t\tcurset := UnionSet(curset, list_frontiers[j][depths[j]]); \n\t fi;\n\tod;\n\tAdd(res, curset);\n od;\n return res;\nend;\n\n#F DefFrontier(<cmd>, <depth>) - computes the so-called def-frontier for a command.\n#F The function can be defined inductively as:\n#F DF(t, d) == DF(t.def, d), where t.def is the 'assign' defining t\n#F DF(assign(t, ... ), 0) == [ [t] ]\n#F DF(assign(t, f(a1,a2,...)), 1) == [ [t], [a1,a2,...] ]\n#F DF(assign(t, f(a1,a2,...)), n) == [ [t], [a1,a2,...] ] concat\n#F _DFUnion(DF(a1,n-1), DF(a2,n-1), ...)\n#F\n#F In plain words it returns the minimal set of variables that fully define a given\n#F location (or cmd.loc). \n#F\n#F For instance, the frontier of t5 in { t3=add(t1,t2); t5=add(t3, t4) }\n#F is [[t5], [t3, t4], [t1, t2, t4]].\n#F\n#F Note (!!!): MarkDefUse(code) must be called on the corresponding code object,\n#F so that locations can be connected with their definitions\n#F\n#F If <depth> is negative, then the maximally deep frontier is computed.\n#F\nDefFrontier := (cmd, depth) -> Cond(\n IsLoc(cmd), let(def := DefLoc(cmd), When(def=false, [[cmd]], DefFrontier(def, depth))),\n depth = 0, [Set([cmd.loc])],\n# IsLoc(cmd.exp), [Set([cmd.loc])],\n let(args := ArgsExp(cmd.exp),\n\tConcatenation([Set([cmd.loc])], \n\t _DFUnion(\n\t\t\t List(args, a -> DefFrontier(a, depth-1))))));\n\nDefCollect := (cmd, depth) -> Cond(\n depth = 0, cmd.loc,\n IsLoc(cmd.exp), cmd.loc,\n depth = 1, cmd.exp,\n SubstLeaves(Copy(cmd.exp), var, \n\tv -> let(def := DefLoc(v), When(def=false, v, DefCollect(def, depth-1)))));\n\nAddFrontier := x -> Cond(\n IsLoc(x), let(def := DefLoc(x),\n\tCond(def = false, x, AddFrontier(def.exp))),\n ObjId(x) in [add,sub],\n ApplyFunc(ObjId(x), List(x.args, AddFrontier)), \n x);\n\nAddFrontierD := (x,d) -> Cond(\n d = 0, x,\n IsLoc(x), let(def := DefLoc(x),\n\tCond(def = false, x, AddFrontierD(def.exp, d))),\n ObjId(x) in [add,sub],\n ApplyFunc(ObjId(x), List(x.args, a -> AddFrontierD(a, d-1))), \n x);\n\nAddFrontierDM := (x,d) -> Cond(\n d = 0, \n [x,false],\n IsLoc(x), let(def := DefLoc(x),\n\tCond(def = false, [x,false], AddFrontierDM(def.exp, d))),\n d = 1, \n [x,ObjId(x)=mul],\n ObjId(x) in [add,sub],\n let(args := List(x.args, a -> AddFrontierDM(a, d-1)),\n\t Cond(ForAll(args, a->a[2]=false), [x,false],\n\t\t [ApplyFunc(ObjId(x), List([1..Length(args)], i->Cond(args[i][2], args[i][1], x.args[i]))), true])),\n [x,ObjId(x)=mul]);\n\n# NOTE: memoization\n#\nClass(madd, add, rec(\n redundancy := self >> self.constantRedundancy(), # or self.termRedundancy(),\n\n terms := self >> Map(self.args, a->a.args[2]),\n constants := self >> Map(self.args, a->a.args[1].v),\n nonTrivialConstants := self >> Filtered(Map(self.args, a->AbsFloat(a.args[1].v)), c->c<>1),\n\n constantRedundancy := self >> let(\n\tconstants := self.nonTrivialConstants(),\n\tconstants <> [] and Length(constants)<>Length(Set(constants))),\n\n termRedundancy := self >> let(\n\tlocs := Filtered(self.terms(), IsLoc),\n\tlocs <> [] and Length(locs) <> Length(Set(locs))),\n\n factorConstants := meth(self)\n local constants, res, t, c, a, i, fac_indices, l1, l2;\n\tres := []; constants := []; l1:=[]; fac_indices := Set([]);\n\tfor a in self.args do\n\t a := Copy(a);\n\t c := a.args[1].v; t := a.args[2];\n\n\t if c in [1,-1] then \n\t\tAdd(constants, c); Add(res, a); \n\t elif c in constants then\n\t\ti := Position(constants, c);\n\t\tres[i].args[2] := add(res[i].args[2], t); AddSet(fac_indices,i);\n\t elif -c in constants then\n\t\ti := Position(constants, -c);\n\t\tres[i].args[2] := sub(res[i].args[2], t); AddSet(fac_indices,i);\n\t else \n\t\tAdd(constants, c); Add(res, a);\n\t fi;\n\tod;\n\n\tl1 := res{fac_indices};\n\tl2 := res{Difference([1..Length(res)], fac_indices)};\n\n\tif l1=[] then return FoldL1(l2,add); fi;\n\tl1 := FoldL1(l1,add);\n\n\tif l2=[] then return l1; fi;\n\tl2 := FoldL1(l2,add);\n\treturn add(l1, l2);\n end,\n\n factorTerms := meth(self)\n local terms, res, t, c, a, i, fac_indices, l1, l2;\n\tres := []; terms := []; fac_indices := Set([]);\n\tfor a in self.args do\n\t a := Copy(a);\n\t c := a.args[1].v; t := a.args[2];\n\n\t if IsLoc(t) and t in terms then \n\t\ti := Position(terms, t);\n\t\tres[i].args[1].v := res[i].args[1].v + c; AddSet(fac_indices,i);\n\t else \n\t\tAdd(terms, t); Add(res, a);\n\t fi;\n\tod;\n\n\tl1 := res{fac_indices};\n\tl2 := res{Difference([1..Length(res)], fac_indices)};\n\tl1 := Filtered(l1, a->a.args[1].v <> 0);\n\tl2 := Filtered(l2, a->a.args[1].v <> 0);\n\n\tif l1=[] and l2=[] then return V(0); fi;\n\n\tif l1=[] then return FoldL1(l2,add); fi;\n\tl1 := FoldL1(l1,add);\n\n\tif l2=[] then return l1; fi;\n\tl2 := FoldL1(l2,add);\n\treturn add(l1, l2);\n end\n));\n\n# \"MultiAdd\" is a normal form for linear expressions\n# MultiAdd = madd(mul(c1,e1), mul(c2,e2), ...)\n#\nClass(ToMultiAdd, RuleSet, rec(\n __call__ := (self, e) >> TDA(madd(mul(1,e)), self, SpiralDefaults)));\n\nRewriteRules(ToMultiAdd, rec(\n EliminateAdd := Rule(add, e->ApplyFunc(madd, List(e.args, a->mul(1,a)))),\n \n EliminateSub := Rule(sub, e->madd(mul(1,e.args[1]), mul(-1, e.args[2]))),\n\n MulMul := Rule([mul, @(1,Value), [mul, @(2,Value), @(3)]], \n\te -> mul(@(1).val.v * @(2).val.v, @(3).val)),\n\n MaddSinkMul := ARule(madd, [[mul, @(1,Value), @(2,madd)]], \n\te -> List(@(2).val.args, a->mul(@(1).val*a.args[1], a.args[2]))),\n\n FlattenMaddMadd := ARule(madd, [@(1,madd)], e->@(1).val.args)\n));\n\n\n\nNODE := x -> RCSE.node(TDouble, x);\nREMOVE_NODE := x -> RCSE.remove_node(x);\n\ndeepCheck := function(c, d)\n local frontier, linexp;\n frontier := AddFrontierD(c.exp, d);\n linexp := ToMultiAdd(frontier);\n if not ObjId(linexp)=madd then return [c.loc,c.loc,\"none\"]; fi;\n if linexp.constantRedundancy() then\treturn [c.loc, linexp, \"constant\"];\n elif linexp.termRedundancy() then\treturn [c.loc, linexp, \"term\"];\n else\t return [c.loc, c.loc, \"none\"];\n fi;\nend;\n\ndeepCheckM := function(c, d)\n local frontier, linexp;\n frontier := AddFrontierDM(c.exp, d)[1];\n linexp := ToMultiAdd(frontier);\n if not ObjId(linexp)=madd then return [c.loc,c.loc,\"none\"]; fi;\n if linexp.constantRedundancy() then\treturn [c.loc, linexp, \"constant\"];\n elif linexp.termRedundancy() then\treturn [c.loc, linexp, \"term\"];\n else\t return [c.loc, c.loc, \"none\"];\n fi;\nend;\n\n_DeepSimplifyCmd := function(c, d, frontier_func)\n local node, frontier, linexp;\n\n frontier := frontier_func(c.exp, d);\n linexp := ToMultiAdd(frontier);\n\n if not ObjId(linexp)=madd then return c; fi;\n\n if linexp.constantRedundancy() then\n\tlinexp := linexp.factorConstants();\n\tif IsValue(linexp) then node := linexp;\n\telse node := ApplyFunc(ObjId(linexp), List(linexp.args, NODE));\n\tfi;\n\tc.exp := node;\n elif linexp.termRedundancy() then\n\tlinexp := linexp.factorTerms();\n\tif IsValue(linexp) then node := linexp;\n\telse node := ApplyFunc(ObjId(linexp), List(linexp.args, NODE));\n\tfi;\n\tc.exp := node;\n fi;\n return c;\nend;\n\nDeepSimplifyCmd := function(c, d1, d2)\n if PatternMatch(c.exp, [mul, @(1,Value), @(2,var,v->DefLoc(v)<>false)], empty_cx()) and\n\tPatternMatch(DefLoc(@(2).val).exp, [mul, @(3,Value), @(4)], empty_cx()) then\n\tc.exp := mul(@(1).val.v * @(3).val.v, @(4).val);\n fi;\n c := _DeepSimplifyCmd(c, d1, AddFrontierD);\n c := _DeepSimplifyCmd(c, d2, (x,d)->AddFrontierDM(x,d)[1]);\n return c;\nend;\n\nDeclare(DeepSimplifyChain);\n\n\nDEPTH1 := 2; # AddFrontierD\nDEPTH2 := 3; # AddFrontierDM\n\nDefUnbound := function(e, bound)\n local unbound, defs;\n unbound := Difference(e.free(), bound);\n defs := Filtered(List(unbound, DefLoc), d->d<>false and not Same(d,e));\n return Concatenation(Concatenation(List(defs, d -> DefUnbound(d, bound))), defs);\nend;\n\n_DeepSimplifyChain := function(code, bound)\n local orig, c, res, cmds, args, supp, supplocs;\n res := chain();\n\n for c in code.cmds do\n if ObjId(c) <> assign then Error(\"Can't handle 'c' of type '\", ObjId(c), \"'\"); fi;\n orig := c.exp;\n\n DeepSimplifyCmd(c,DEPTH1,DEPTH2);\t \n if IsVar(c.loc) then AddSet(bound, c.loc); fi;\n\n supp := chain(DefUnbound(c.exp, bound));\n supplocs := List(supp.cmds, cmd->cmd.loc);\n DoForAll(supplocs, REMOVE_NODE);\n UniteSet(bound, supplocs);\n\n supp := FlattenCode(_DeepSimplifyChain(supp, bound)); \n Add(supp.cmds, c);\n supp := RCSE(supp);\n\n Append(res.cmds, supp.cmds);\n od;\n\n return res;\nend;\n\nDeepSimplifyChain := code -> _DeepSimplifyChain(code, code.free());\n\nDeepSimplify := function(code)\n local c, frontier, linexp, free, undefined;\n code := BinSplit(code); \n RCSE.flush();\n MarkDefUse(code);\n return SubstBottomUp(code, chain, DeepSimplifyChain);\nend;\n\n_CheckUninitializedChain := function(code, def, uninit)\n local def1, def2, c, use;\n for c in code.cmds do\n if ObjId(c)=assign then\n\t use := VarArgsExp(c.exp);\n\t UniteSet(uninit, Filtered(use, x->not x in def));\n\t AddSet(def, c.loc);\n\n elif ObjId(c)=chain then\n [def, uninit] := _CheckUninitializedChain(c, def, uninit);\n\n elif ObjId(c)=IF then\n [def1, uninit] := _CheckUninitializedChain(c.then_cmd, ShallowCopy(def), uninit);\n [def2, uninit] := _CheckUninitializedChain(c.else_cmd, ShallowCopy(def), uninit);\n def := Union(def1, def2);\n\tfi;\n od;\n return [def, uninit];\nend;\n\nCheckUninitializedChain := function(code)\n local def, uninit;\n Constraint(ObjId(code)=chain);\n def := Set([]);\n uninit := Set([]);\n [def, uninit] := _CheckUninitializedChain(code, def, uninit);\n return uninit;\nend;\n\nreds := chain -> Filtered(chain.cmds, c -> deepCheck(c,DEPTH1)[3] <>\"none\" or\n deepCheckM(c, DEPTH2)[3] <>\"none\");\n\nDoDeepSimplify := function(code, num_iterations)\n local c, frontier, linexp, free, undefined, i;\n Print(\"Orig cost : \", ArithCostCode(code), \"\\n\");\n for i in [1..num_iterations] do\n code := DeepSimplify(code); Print(\"DS : \", ArithCostCode(code), \"\\n\");\n code := CopyPropagate(code); Print(\"CP : \", ArithCostCode(code), \"\\n\");\n code := CopyPropagate(code); Print(\"CP : \", ArithCostCode(code), \"\\n\");\n code := CopyPropagate(code); Print(\"CP : \", ArithCostCode(code), \"\\n\");\n code := BinSplit(code); \n code := RCSE(code); Print(\"RCSE : \", ArithCostCode(code), \"\\n\");\n od;\n return code;\nend;\n\n\n# err := [];\n\n# LIMIT := 1; ww:=DeepSimplify(Copy(w));; cm := CMatrix(pp(ww));\n# if inf_norm(cm-dm) > 1e-10 then Print(\"ERROR\\n\"); Add(err, [Copy(ww), Copy(w), inf_norm(cm-dm)]); else Print(\"OK\\n\"); fi;\n\n# LIMIT := 1; w:=DeepSimplify(Copy(ww));; cm := CMatrix(pp(w));\n# if inf_norm(cm-dm) > 1e-10 then Print(\"ERROR\\n\"); err := Add(err, [Copy(w), Copy(ww), inf_norm(cm-dm)]); else Print(\"OK\\n\"); fi;\n", "meta": {"hexsha": "35b400bc6a7eb24f9a96ff90dc6d2d405be30ab0", "size": 11984, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/compiler/frontier.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/compiler/frontier.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/compiler/frontier.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 32.5652173913, "max_line_length": 130, "alphanum_fraction": 0.5933744993, "num_tokens": 3835, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.793105951184112, "lm_q2_score": 0.7057850216484838, "lm_q1q2_score": 0.5597623009260198}}
{"text": "RequirePackage(\"grape\");\n\nV := GF(3)^7;\nP := Filtered(List(Elements(Subspaces(V, 1)), v -> Elements(v)[2]), u -> u*u = Z(3));;\n\nG := Graph(Group(()), P, function(x,y) return x; end, function(x,y) return x*y = 0*Z(3); end, true);;\nGlobalParameters(G);\n", "meta": {"hexsha": "260c8a2be766cb595e16876d8e3dad9cfabff827", "size": 251, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "lib/o7.gap", "max_stars_repo_name": "jaanos/gap-graphs", "max_stars_repo_head_hexsha": "18dd56c9b90a12a717a0cc893fdd72c6343ee79b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2015-10-27T15:54:29.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-07T14:09:44.000Z", "max_issues_repo_path": "lib/o7.gap", "max_issues_repo_name": "jaanos/gap-graphs", "max_issues_repo_head_hexsha": "18dd56c9b90a12a717a0cc893fdd72c6343ee79b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2015-04-20T23:13:11.000Z", "max_issues_repo_issues_event_max_datetime": "2015-04-20T23:13:11.000Z", "max_forks_repo_path": "lib/o7.gap", "max_forks_repo_name": "jaanos/gap-graphs", "max_forks_repo_head_hexsha": "18dd56c9b90a12a717a0cc893fdd72c6343ee79b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.375, "max_line_length": 101, "alphanum_fraction": 0.593625498, "num_tokens": 85, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8577680904463334, "lm_q2_score": 0.6513548646660542, "lm_q1q2_score": 0.5587114184675313}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nDeclare(Tensor, I, L);\n\n# ==========================================================================\n# Tensor(<spl1>, <spl2>, ...) . . . . . . . . . . Kronecker product of SPLs\n# Arguments can be lists of spls of any depth. So that the following is\n# legal:\n# Tensor(I(2), [[F(2), [I(2)]]])\n# and is equivalent to\n# Tensor(I(2), F(2), I(2))\n# ==========================================================================\nClass(Tensor, BaseOperation, rec(\n abbrevs := [ arg -> [Flat(arg)] ],\n\n new := meth(self, L)\n local scl,mat;\n Constraint(IsList(L) and Length(L) >= 1);\n L:=Filtered(L,x->x<>I(1));\n if (Length(L)=0) then return I(1); fi;\n #DoForAll(L, x -> Constraint(IsSPL(x)));\n\tif Length(L)=1 then return L[1]; fi;\n\n\t#if Length(L)=2 then\n\t# scl := Cond(Dimensions(L[1])=[1,1], 1,\n\t#\t Dimensions(L[2])=[1,1], 2,\n\t#\t\tfalse);\n\t# if scl <> false then\n\t#\tmat := L [ When(scl=1, 2, 1) ];\n\t#\tscl := MatSPL(L[scl])[1][1];\n\t#\t\n\t#\treturn When(scl=1, mat, spiral.spl.operators.Scale(scl, mat));\n\t# fi;\n\t#fi;\n\n return SPL(WithBases( self, \n\t rec( _children := L,\n\t\tdimensions := [ Product(L, t -> t.dims()[1]),\n\t\t Product(L, t -> t.dims()[2]) ] )));\n end,\n #-----------------------------------------------------------------------\n dims := self >> [ Product(self._children, t -> t.dims()[1]),\n\t Product(self._children, t -> t.dims()[2]) ],\n #-----------------------------------------------------------------------\n isPermutation := self >> ForAll(self._children, IsPermutationSPL),\n #-----------------------------------------------------------------------\n isSymmetric := self >> ForAll(self._children, c -> c.isSymmetric()),\n #-----------------------------------------------------------------------\n toAMat := self >> TensorProductAMat(List(self._children, AMatSPL)),\n #-----------------------------------------------------------------------\n transpose := self >> \n CopyFields(self, rec(_children := List(self._children, x->x.transpose()),\n\t\t dimensions := Reversed(self.dimensions))),\n conjTranspose := self >> \n CopyFields(self, rec(_children := List(self._children, x->x.conjTranspose()),\n\t\t dimensions := Reversed(self.dimensions))),\n inverse := self >> \n CopyFields(self, rec(_children := List(self._children, x->x.inverse()),\n\t\t dimensions := Reversed(self.dimensions))),\n #-----------------------------------------------------------------------\n rightBinary := self >> FoldR1(self._children, (p,x) -> let(base:=self.__bases__[1], base(x, p))),\n\n leftBinary := self >> FoldL1(self._children, (p,x) -> let(base:=self.__bases__[1], base(p, x))),\n\n split := meth(self)\n local i, lft, rt, ch, res;\n ch := self.children();\n rt := Product(Drop(ch, 1), Rows);\n lft := 1;\n res := Tensor(ch[1], I(rt));\n for i in [2..self.numChildren()] do\n lft := lft * Cols(ch[i-1]);\n rt := rt / Rows(ch[i]);\n res := res * Tensor(I(lft), ch[i], I(rt));\n od;\n return res;\n end,\n\n vectorForm := self >> Checked(self.numChildren() = 2,\n\tlet(c1 := self.child(1), c2 := self.child(2), \n\n\t Cond(IsIdentitySPL(c1) and IsIdentitySPL(c2), self,\n\t\t IsIdentitySPL(c1), L(Rows(c2)*Rows(c1), Rows(c1)) * \n\t\t Tensor(c2, I(Rows(c1))) * \n\t\t\t\t L(Cols(c2)*Cols(c1), Cols(c2)),\n\t\t IsIdentitySPL(c2), self, \n\t # else\n\t\t Tensor(c1, I(Rows(c2)) * Tensor(I(Cols(c1)), c2).vectorForm()\n\t )))),\n\n parallelForm := self >> Checked(self.numChildren() = 2,\n\tlet(c1 := self.child(1), c2 := self.child(2), \n\n\t Cond(IsIdentitySPL(c1) and IsIdentitySPL(c2), self,\n\t\t IsIdentitySPL(c2), L(Rows(c2)*Rows(c1), Rows(c1)) * \n\t\t Tensor(I(Rows(c2)), c1) * \n\t\t\t\t L(Cols(c2)*Cols(c1), Cols(c2)),\n\t\t IsIdentitySPL(c1), self,\n\t # else rc1*rc2 X cc1*cc2\n\t\t Tensor(c1, I(Rows(c2))).parallelForm() * Tensor(I(Cols(c1)), c2)\n\t ))),\n\n \n #-----------------------------------------------------------------------\n arithmeticCost := meth(self, costMul, costAddMul)\n local t, left, right, cost;\n left := 1;\n\tright := self.dimensions[1];\n\tcost := costMul(0) - costMul(0); # will work even when costMul(0) <> 0\n\tfor t in self.children() do\n\t right := right / t.dimensions[1];\n\t cost := cost + left * right * t.arithmeticCost(costMul, costAddMul);\n\t left := left * t.dimensions[2];\n\tod;\n\treturn cost;\n end,\n #-----------------------------------------------------------------------\n latexSymbol := \"\\\\tensor\"\n));\n", "meta": {"hexsha": "de201f3b0afc672f51d060a50e487247122f4718", "size": 4746, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/spl/Tensor.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/spl/Tensor.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/spl/Tensor.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 38.5853658537, "max_line_length": 102, "alphanum_fraction": 0.4612305099, "num_tokens": 1274, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199714402812, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5573611676558173}}
{"text": "Balanced := function(L)\n local c, r;\n r := 0;\n for c in L do\n if c = ']' then\n r := r - 1;\n if r < 0 then\n return false;\n fi;\n elif c = '[' then\n r := r + 1;\n fi;\n od;\n return r = 0;\nend;\n\nBalanced(\"\");\n# true\n\nBalanced(\"[\");\n# false\n\nBalanced(\"]\");\n# false\n\nBalanced(\"[]\");\n# true\n\nBalanced(\"][\");\n# false\n\nBalanced(\"[[][]]\");\n# true\n\nBalanced(\"[[[]][]]]\");\n# false\n", "meta": {"hexsha": "4a4d7f5b178981bd0c919831668f7fe8b77c699b", "size": 462, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "Task/Balanced-brackets/GAP/balanced-brackets.gap", "max_stars_repo_name": "LaudateCorpus1/RosettaCodeData", "max_stars_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d", "max_stars_repo_licenses": ["Info-ZIP"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-11-09T22:08:38.000Z", "max_stars_repo_stars_event_max_datetime": "2018-11-09T22:08:38.000Z", "max_issues_repo_path": "Task/Balanced-brackets/GAP/balanced-brackets.gap", "max_issues_repo_name": "seanwallawalla-forks/RosettaCodeData", "max_issues_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d", "max_issues_repo_licenses": ["Info-ZIP"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Task/Balanced-brackets/GAP/balanced-brackets.gap", "max_forks_repo_name": "seanwallawalla-forks/RosettaCodeData", "max_forks_repo_head_hexsha": "9ad63ea473a958506c041077f1d810c0c7c8c18d", "max_forks_repo_licenses": ["Info-ZIP"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2018-11-09T22:08:40.000Z", "max_forks_repo_forks_event_max_datetime": "2018-11-09T22:08:40.000Z", "avg_line_length": 12.4864864865, "max_line_length": 29, "alphanum_fraction": 0.3917748918, "num_tokens": 141, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7217432182679957, "lm_q2_score": 0.7718434978390747, "lm_q1q2_score": 0.5570728101296005}}
{"text": "\n## Copyright (c) 2018-2021, Carnegie Mellon University\n## See LICENSE for details\n\n_computeNumDen := (value) -> let(\n list := Filtered([1..10000], e -> IntDouble(value * e) = value * e),\n\n When(value = 0.0, [0, 1],\n\t When(Length(list) = 0, [0, 1],\n\t [IntDouble(list[1] * value), list[1]]))\n);\n\n_shiftElements := (sizeIdx, size, shft) -> let(\n numDen := _computeNumDen(shft), # numDen[1]/numDen[2] = shft\n i := Ind([0..sizeIdx - 1]),\n onlyPositive := (sizeIdx < size),\n # Lambda(i, cond(lt(i, size / 2), E(numDen[2] * size) ^ (sign(2 * i) * numDen[1] * i), E(numDen[2] * size) ^ (sign(2 * i - size) * numDen[1] * (i - size))))\n # Lambda(i, cond(lt(i, size / 2), E(numDen[2] * size) ^ (numDen[1] * i), E(numDen[2] * size) ^ (numDen[1] * (i - size))))\n Lambda(i, cond(onlyPositive,\n E(numDen[2] * size) ^ (numDen[1] * i),\n cond(lt(i, size / 2),\n E(numDen[2] * size) ^ (numDen[1] * i),\n E(numDen[2] * size) ^ (numDen[1] * (i - size)))))\n);\n\n#_tabelize := f->let(vals := f.tolist(), i := Ind(f.domain()), When(\n# ForAll(vals, v->v=vals[1]), Lambda(i, vals[1]),\n# Lambda(i, FData(List(vals, j->Value(TComplex, _unwrap(j)))).at(i))\n#));\n\n_tabelize := f->let(vals := f.tolist(), i := Ind(f.domain()), When(\n ForAll(vals, v->v=vals[1]), Lambda(i, vals[1]),\n let( rtab := FData(Flat(List(vals, e->[re(e), im(e)]))),\n Lambda(i, cxpack(rtab.at(2*i), rtab.at(2*i+1))))\n));\n\n\n\nNewRulesFor(TResample, rec(\n\t\t TResample_TGath := rec(\n\t\t forTransposition := false,\n\t\t switch := true,\n\t\t applicable := nt -> ForAny(Zip2(nt.params[1], nt.params[2]), l-> l[1]<l[2]),\n\t\t children := nt -> [[TResample(nt.params[1], nt.params[1], nt.params[3]), TGath(_toBox(nt.params[2], nt.params[1]))]],\n\t\t apply := (nt, C, cnt) -> C[1] * C[2]\n\t\t ),\n\n\t\t TResample_TScat := rec(\n\t\t forTransposition := false,\n\t\t switch := true,\n\t\t applicable := nt -> ForAny(Zip2(nt.params[1], nt.params[2]), l-> l[1]>l[2]),\n\t\t children := nt -> [[TScat(_toBox(nt.params[1], nt.params[2])), TResample(nt.params[2], nt.params[2], nt.params[3])]],\n\t\t apply := (nt, C, cnt) -> C[1] * C[2]\n\n\t\t ),\n\n\t\t TResample_MD_nofrac := rec(\n\t\t forTransposition := false,\n\t\t switch := true,\n\t\t applicable := nt -> (nt.params[1] = nt.params[2]) and (Length(nt.params[1]) > 1) and ForAll(nt.params[3], e -> e = 0.0),\n\t\t children := nt -> [[I(Product(nt.params[1]))]],\n\t\t apply := (nt, C, cnt) -> C[1]\n\t\t ),\n\n\t\t # ASSUMPTION IS THAT FASTEST DIMENSION IS REAL DFT-ED\n\t\t TResample_MD_frac := rec(\n\t\t forTransposition := false,\n\t\t switch := true,\n\t\t applicable := nt -> (nt.params[1] = nt.params[2]) and (Length(nt.params[1]) > 1) and ForAny(nt.params[3], e -> (abs(e) > 0.0) and (abs(e) < 1.0)),\n\t\t children := nt -> [[IMDPRDFT(nt.params[1], 1), MDPRDFT(nt.params[2], -1)]],\n\n\t\t apply := (nt, C, cnt) -> let(\n \t\t\t sizeX := Last(nt.params[2]),\n \t\t\t sizeXf := sizeX / 2 + 1,\n \t\t\t shftX := Last(nt.params[3]),\n\n \t\t\t dXf := diagMul(fConst(sizeXf, 1/sizeX), _shiftElements(sizeXf, sizeX, shftX)),\n\n \t\t\t sizes := DropLast(nt.params[2], 1),\n \t\t\t shfts := DropLast(nt.params[3], 1),\n\n \t\t\t df := List([1..Length(sizes)], e -> diagMul(fConst(sizes[e], 1/sizes[e]), _shiftElements(sizes[e], sizes[e], shfts[e]))),\n dd := List(df::[dXf], _tabelize),\n\n \t\t\t C[1] *\n \t\t\t RCDiag(RCData(diagTensor(dd))) *\n \t\t\t C[2]\n\t\t )\n\t\t )\n\t )\n\t );\n", "meta": {"hexsha": "8fb8bfa8a710cc450a348d9aeada7cc6e9747b49", "size": 3677, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "breakdown/resample.gi", "max_stars_repo_name": "franzfranchetti/spiral-package-fftx", "max_stars_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-15T12:40:19.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-15T12:40:19.000Z", "max_issues_repo_path": "breakdown/resample.gi", "max_issues_repo_name": "franzfranchetti/spiral-package-fftx", "max_issues_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 8, "max_issues_repo_issues_event_min_datetime": "2021-01-05T20:58:29.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-18T20:10:45.000Z", "max_forks_repo_path": "breakdown/resample.gi", "max_forks_repo_name": "franzfranchetti/spiral-package-fftx", "max_forks_repo_head_hexsha": "3149606d3d60a9b50c225ec1e8450628d543698b", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 5, "max_forks_repo_forks_event_min_datetime": "2020-12-14T18:24:29.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-15T12:40:20.000Z", "avg_line_length": 39.9673913043, "max_line_length": 161, "alphanum_fraction": 0.5004079413, "num_tokens": 1230, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8840392817460333, "lm_q2_score": 0.6297745935070806, "lm_q1q2_score": 0.5567454793058997}}
{"text": "\n# Copyright (c) 2018-2021, Carnegie Mellon University\n# See LICENSE for details\n\n\nClass(Ext, Sym, rec(\n abbrevs := [ \n\t(n, ext) -> [n, ext, ext, 1, 1],\n\t(n, l, r) -> [n, l, r, 1, 1] ],\n\n def := function(n, l, r, lscale, rscale)\n local stack;\n Checked(IsPosInt(n), true);\n stack := [];\n\n if (IsInt(l) and l>0) then \n Add(stack,O(l,n));\n elif (IsRec(l) and not l.n=0 ) then \n l := When(IsSPL(l), l, l.left(n));\n Add(stack, When(lscale<>1, lscale*Gath(l), Gath(l)));\n fi;\n\n Add(stack, I(n));\n\n if (IsInt(r) and r>0) then \n Add(stack,O(r,n));\n elif (IsRec(r) and not r.n=0 ) then\n r := When(IsSPL(r), r, r.right(n));\n Add(stack, When(rscale<>1, rscale*Gath(r), Gath(r)));\n fi;\n\n\t return VStack(stack);\n end\n));\n\n\nClass(DownSample, Sym, rec(\n abbrevs := [ (n, fact, offset) -> \n Checked(IsPosInt(n), IsPosInt(fact), IsPosInt0(offset), [n, fact, offset]) ],\n\n def := (n, fact, offset) -> let(m := Int((n-offset-1) / fact + 1),\n Gath(H(n, m, offset, fact)))\n));\n\nClass(UpSample, Sym, rec(\n abbrevs := [ (n, fact, offset) -> \n Checked(IsPosInt(n), IsPosInt(fact), IsPosInt0(offset), [n, fact, offset]) ],\n\n def := (n, fact, offset) -> let(m := Int((n-offset-1) / fact + 1),\n Scat(H(n, m, offset, fact)))\n));\n\n", "meta": {"hexsha": "0c60ed8c340eca6c41f46df5b3ed49a6b89fa90e", "size": 1396, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "namespaces/spiral/transforms/filtering/extensions.gi", "max_stars_repo_name": "sr7cb/spiral-software", "max_stars_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 42, "max_stars_repo_stars_event_min_datetime": "2019-09-01T19:29:39.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-17T12:26:12.000Z", "max_issues_repo_path": "namespaces/spiral/transforms/filtering/extensions.gi", "max_issues_repo_name": "sr7cb/spiral-software", "max_issues_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 12, "max_issues_repo_issues_event_min_datetime": "2020-11-20T16:15:52.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T21:17:28.000Z", "max_forks_repo_path": "namespaces/spiral/transforms/filtering/extensions.gi", "max_forks_repo_name": "sr7cb/spiral-software", "max_forks_repo_head_hexsha": "349d9e0abe75bf4b9a4690f2dbee631700f8361a", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2019-08-20T19:27:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-01T22:11:18.000Z", "avg_line_length": 26.3396226415, "max_line_length": 85, "alphanum_fraction": 0.4971346705, "num_tokens": 459, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461390043208003, "lm_q2_score": 0.7461389873857264, "lm_q1q2_score": 0.5567234011329161}}
{"text": "\n\nlatexPoly:=function(poly,APR,var_name)\n local result,ext_rep,i,j,monom,coeff,\n avars,ext_avars,pos;\n\n if not IsPolynomialRing(APR) then return String(Int(poly)); fi;\n \n ext_rep:=ExtRepPolynomialRatFun(poly);\n avars:=IndeterminatesOfPolynomialRing(APR);\n ext_avars:=List(avars,i->ExtRepPolynomialRatFun(i));\n ext_avars:=List(ext_avars,i->i[1][1]);\n result:=\"\";\n for i in 2*[1..Length(ext_rep)/2]-1 do\n monom:=\"\";\n for j in 2*[1..Length(ext_rep[i])/2]-1 do\n pos:=Position(ext_avars,ext_rep[i][j]);\n monom:=Concatenation(monom,String(avars[pos]));\n if ext_rep[i][j+1]<>1 then\n monom:=Concatenation(monom,\"^{\",String(ext_rep[i][j+1]),\"}\");\n fi;\n od;\n coeff:=latexPoly(ext_rep[i+1],CoefficientsRing(APR),\"a\");#String(Int(ext_rep[i+1]));\n if i > 1 then result:=Concatenation(result,\"+\"); fi;\n if coeff=\"1\" and monom<>\"\" then\n result:=Concatenation(result,monom);\n else\n result:=Concatenation(result,coeff,monom);\n fi;\n od;\n result:=ReplacedString(result,String(avars[1]){[1]},var_name);\n return result;\nend;\n\nlatexUnipotent:=function(u)\n local result,\n coeffs,i,pr,root,poly,APR;\n \n coeffs:=coefficients(u);\n APR:=ring(chevalleyAdj(u));\n pr:=positiveRoots(chevalleyAdj(u));\n result:=\"\";\n for i in [1..Length(coeffs)] do\n #root:=Concatenation(List(pr[coeffs[i][1]],j->String(j)));\n #poly:=ReplacedString(String(coeffs[i][2]),\"*\",\"\");\n result:=Concatenation(result,\"u_{\",String(coeffs[i][1]),\"}(\",latexPoly(coeffs[i][2],APR,\"t\"),\")\");\n od;\n \n #result:=ReplacedString(result,\"a\",\"t\");\n return result;\nend;\n\nlatexUnipotentNice:=function(u)\n local result,\n coeffs,i,pr,root,poly,APR;\n \n coeffs:=coefficients(u);\n APR:=ring(chevalleyAdj(u));\n pr:=positiveRoots(chevalleyAdj(u));\n result:=\"\";\n for i in [1..Length(coeffs)] do\n if type(chevalleyAdj(u))=\"F\" then root:=Concatenation(List(pr[coeffs[i][1]],j->String(j))){[2,4,3,1]};\n else root:=Concatenation(List(pr[coeffs[i][1]],j->String(j))); fi;\n #poly:=ReplacedString(String(coeffs[i][2]),\"*\",\"\");\n result:=Concatenation(result,\"u_{\",root,\"}(\",latexPoly(coeffs[i][2],APR,\"t\"),\")\");\n od;\n \n #result:=ReplacedString(result,\"a\",\"t\");\n return result;\nend;\n\nlatexUnipotentTrimmed:=function(u,step)\n local result,\n coeffs,i,pr,root,poly,APR,index;\n \n coeffs:=coefficients(u);\n APR:=ring(chevalleyAdj(u));\n pr:=positiveRoots(chevalleyAdj(u));\n result:=\"\";\n index:=1;\n for i in [1..Length(coeffs)] do\n if index > step then\n index:=0;\n result:=Concatenation(result,\" \\\\\\\\ && \");\n fi;\n result:=Concatenation(result,\"u_{\",String(coeffs[i][1]),\"}(\",latexPoly(coeffs[i][2],APR,\"t\"),\")\\n\");\n index:=index+Length(ExtRepPolynomialRatFun(coeffs[i][2]))/2;\n od;\n \n #result:=ReplacedString(result,\"a\",\"t\");\n return result;\nend;\n\ntrimmedString:=function(str,chars,step)\n local result,i;\n result:=[\"\"];\n while Length(str)>0 do\n i:=step;\n while i<Length(str) and not str[i] in chars do\n i:=i+1;\n od;\n if i<Length(str) then \n Add(result,Concatenation(str{[1..i-1]},\"\\\\\\\\ \\n & & \"));\n str:=str{[i..Length(str)]};\n else\n Add(result,str);\n str:=\"\";\n fi;\n od;\n return Concatenation(result);\nend;\n\ntrimmedStringNice:=function(str,chars,step)\n local result,i;\n result:=[\"\"];\n while Length(str)>0 do\n i:=step;\n while i<Length(str) and not str[i] in chars do\n i:=i+1;\n od;\n if i<Length(str) then \n Add(result,Concatenation(str{[1..i-1]},\"$\\\\\\\\\\n&\\n$\"));\n str:=str{[i..Length(str)]};\n else\n Add(result,str);\n str:=\"\";\n fi;\n od;\n return Concatenation(result);\nend;\n\ntrimmedString2:=function(str,chars,start,step)\n local result,i,flag,nr_plusuri;\n result:=[\"\"];\n flag:=true;\n nr_plusuri:=0;\n while Length(str)>0 do\n if flag = true then\n i:=step-start;\n flag:=false;\n else i:=step; fi;\n\n #i:=i+2*Length(Positions(str{[1..Minimum(i,Length(str))]},'+'));\n \n while i<Length(str) and not str[i] in chars do\n i:=i+1;\n #Print(str[i]);\n #if str[i] in ['+'] then nr_plusuri:=nr_plusuri+1; fi;\n od;\n if i<Length(str) then \n Add(result,Concatenation(str{[1..i-1]},\"\\\\\\\\ \\n & & \"));\n str:=str{[i..Length(str)]};\n else\n Add(result,str);\n #Print(\"\\n\",nr_plusuri,\"\\n\");\n str:=\"\";\n nr_plusuri:=0;\n fi;\n od;\n return Concatenation(result);\nend;\n\ntrimmedString2Nice:=function(str,chars,start,step)\n local result,i,flag,nr_plusuri;\n result:=[\"\"];\n flag:=true;\n nr_plusuri:=0;\n while Length(str)>0 do\n if flag = true then\n i:=step-start;\n flag:=false;\n else i:=step; fi;\n\n #i:=i+2*Length(Positions(str{[1..Minimum(i,Length(str))]},'+'));\n \n while i<Length(str) and not str[i] in chars do\n i:=i+1;\n #Print(str[i]);\n #if str[i] in ['+'] then nr_plusuri:=nr_plusuri+1; fi;\n od;\n if i<Length(str) then \n Add(result,Concatenation(str{[1..i-1]},\"$\\\\\\\\\\n&\\n$\"));\n str:=str{[i..Length(str)]};\n else\n Add(result,str);\n #Print(\"\\n\",nr_plusuri,\"\\n\");\n str:=\"\";\n nr_plusuri:=0;\n fi;\n od;\n return Concatenation(result);\nend;\n\nlatexClass:=function(orb,info)\n local fisier,\n u,sys,str,#info,\n step,i;\n\n #u:=Representative(orb);\n u:=BorelRep(orb);\n sys:=chevalleyAdj(u);\n #info:=handleClass(orb);\n \n fisier:=Concatenation(\"tex/data/\",type(sys),String(rank(sys)),\n \"/char\",String(Characteristic(sys)),\n \"/\",Label(orb),\".tex\");\n fisier:=ReplacedString(fisier,\"\\\\tilde \",\"s\");\n fisier:=Filename(home_dir,fisier);\n\n step:=150;\n\n SizeScreen([2000,2000]);\n PrintTo(fisier,\"\\\\textbf{Class $\",Label(orb),\"$:}\");\n AppendTo(fisier,\"\\\\begin{eqnarray*}\\n\");\n AppendTo(fisier,\"&&\\\\mathbf{u}=\");\n AppendTo(fisier,trimmedString(latexUnipotent(u),\"u+\",step));\n# AppendTo(fisier,\"\\\\end{eqnarray*}\\n\");\n# AppendTo(fisier,\"\\\\begin{eqnarray*}\\n\");\n AppendTo(fisier,\"\\\\\\\\ && \\\\mathbf{C_U(u)^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2(latexUnipotent(info[1][1]),\"u+\",30,step));\n# AppendTo(fisier,\"\\\\end{eqnarray*}\\n\");\n# AppendTo(fisier,\"\\\\begin{eqnarray*}\\n\");\n AppendTo(fisier,\"\\\\\\\\ && \\\\mathbf{Z(C_U(u)^{\\\\circ})^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2(latexUnipotent(info[2]),\"u+\",40,step));\n AppendTo(fisier,\"\\\\\\\\ &&=\");\n\n #\n # short form of decomposition\n #\n str:=\"\";\n for i in info[4][1] do\n if i <> info[4][1][1] then str:=Concatenation(str,\" \\\\mid \"); fi;\n str:=Concatenation(str,\"W_{\",String(Dimension(info[3][i])),\"}\");\n od;\n AppendTo(fisier,trimmedString(str,\"u+\",step));\n AppendTo(fisier,\" \\\\\\|\");\n str:=\"\";\n for i in info[4][2] do\n if i <> info[4][2][1] then str:=Concatenation(str,\" \\\\mid \"); fi;\n str:=Concatenation(str,\"W_{\",String(Dimension(info[3][i])),\"}\");\n od;\n AppendTo(fisier,trimmedString(str,\"u+\",step));\n #\n # explicite form of decomposition\n #\n AppendTo(fisier,\"\\\\\\\\ && =\");\n str:=\"\";\n for i in info[4][1] do\n if i <> info[4][1][1] then str:=Concatenation(str,\" \\\\mid \"); fi;\n str:=Concatenation(str,latexUnipotent(info[3][i]));\n od;\n AppendTo(fisier,trimmedString(str,\"u+\",step));\n AppendTo(fisier,\" \\\\\\|\");\n str:=\"\";\n for i in info[4][2] do\n if i <> info[4][2][1] then str:=Concatenation(str,\" \\\\mid \"); fi;\n str:=Concatenation(str,latexUnipotent(info[3][i]));\n od;\n AppendTo(fisier,trimmedString(str,\"u+\",step));\n\n \n AppendTo(fisier,\"\\\\end{eqnarray*}\\n\");\n SizeScreen([156,39]);\nend;\n\nlatexClasses:=function(orbs,infos)\n local i;\n for i in [1..Length(Classes(orbs))] do\n latexClass(Classes(orbs)[i],infos[i]);\n od;\nend;\n\nlatexClassShort:=function(orb,info)\n local fisier,\n uu,u,sys,str,#info,\n step,i;\n\n uu:=Representative(orb);\n u:=BorelRep(orb);\n sys:=chevalleyAdj(u);\n #info:=handleClass(orb);\n \n fisier:=Concatenation(\"tex/data/\",type(sys),String(rank(sys)),\n \"/char\",String(Characteristic(sys)),\n \"/\",Label(orb),\".tex\");\n fisier:=ReplacedString(fisier,\"\\\\tilde \",\"s\");\n fisier:=Filename(home_dir,fisier);\n\n\n step:=150;\n\n SizeScreen([2000,2000]);\n PrintTo(fisier,\"\\\\textbf{Class $\",Label(orb),\"$:}\");\n AppendTo(fisier,\"\\\\begin{eqnarray*}\\n\");\n AppendTo(fisier,\"&&\\\\mathbf{\\\\tilde u}=\");\n AppendTo(fisier,trimmedString(latexUnipotent(uu),\"u+\",step));\n AppendTo(fisier,\"\\\\\\\\ &&\\\\mathbf{u}=\");\n AppendTo(fisier,trimmedString(latexUnipotent(u),\"u+\",step));\n# AppendTo(fisier,\"\\\\end{eqnarray*}\\n\");\n# AppendTo(fisier,\"\\\\begin{eqnarray*}\\n\");\n AppendTo(fisier,\"\\\\\\\\ && \\\\mathbf{C_U(u)^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2(latexUnipotent(info[1]),\"u+\",30,step));\n# AppendTo(fisier,\"\\\\end{eqnarray*}\\n\");\n# AppendTo(fisier,\"\\\\begin{eqnarray*}\\n\");\n AppendTo(fisier,\"\\\\\\\\ && \\\\mathbf{Z(C_U(u)^{\\\\circ})^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2(latexUnipotent(info[2]),\"u+\",40,step));\n AppendTo(fisier,\"\\\\end{eqnarray*}\\n\");\n SizeScreen([156,39]);\nend;\n\nlatexClassShortNice:=function(orb,info)\n local fisier,\n uu,u,sys,str,#info,\n step,i;\n\n uu:=Representative(orb);\n u:=BorelRep(orb);\n sys:=chevalleyAdj(u);\n #info:=handleClass(orb);\n \n fisier:=Concatenation(\"tex/data/\",type(sys),String(rank(sys)),\n \"/char\",String(Characteristic(sys)),\n \"/\",Label(orb),\".tex\");\n fisier:=ReplacedString(fisier,\"\\\\tilde \",\"s\");\n fisier:=Filename(home_dir,fisier);\n\n\n step:=150;\n\n SizeScreen([2000,2000]);\n# PrintTo(fisier,\"$$\\n\\\\begin{array}{p{3cm} p{20cm}}\\n\");\n# AppendTo(fisier,\"\\\\textbf{Class $\",Label(orb),\"$:} &\\\\\\\\\\n \");\n PrintTo(fisier,\"\\\\textbf{p=\",Characteristic(sys),\":}\");\n AppendTo(fisier,\"&$\\\\mathbf{u}=\");\n AppendTo(fisier,trimmedStringNice(latexUnipotentNice(uu),\"u+\",step));\n AppendTo(fisier,\"$\\\\\\\\\\n&\\n$\\\\mathbf{\\\\tilde u}=\");\n AppendTo(fisier,trimmedStringNice(latexUnipotentNice(u),\"u+\",step));\n AppendTo(fisier,\"$\\\\\\\\\\n&\\n$\\\\mathbf{C_U(\\\\tilde u)^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2Nice(latexUnipotentNice(Unipotent(chevalleyAdj(u),coefficients(info[1]),Ordering(u))),\"u+\",30,step));\n AppendTo(fisier,\"$\\\\\\\\\\n&\\n$\\\\mathbf{Z(C_G(u))^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2Nice(latexUnipotentNice(Unipotent(chevalleyAdj(uu),coefficients(FromPositiveBorel(orb,info[2])),Ordering(uu))),\"u+\",40,step));\n AppendTo(fisier,\"$\\\\\\\\\\n\");\n# AppendTo(fisier,\"$\\n\\\\end{array}\\n$$\");\n SizeScreen([156,39]);\nend;\n\nlatexClassVeryShortNice:=function(orb,info)\n local fisier,\n uu,u,sys,str,#info,\n step,i;\n\n uu:=Representative(orb);\n u:=BorelRep(orb);\n sys:=chevalleyAdj(u);\n #info:=handleClass(orb);\n \n fisier:=Concatenation(\"tex/data/\",type(sys),String(rank(sys)),\n \"/char\",String(Characteristic(sys)),\n \"/\",Label(orb),\".tex\");\n fisier:=ReplacedString(fisier,\"\\\\tilde \",\"s\");\n fisier:=Filename(home_dir,fisier);\n\n\n step:=150;\n\n SizeScreen([2000,2000]);\n# PrintTo(fisier,\"$$\\n\\\\begin{array}{p{3cm} p{20cm}}\\n\");\n# AppendTo(fisier,\"\\\\textbf{Class $\",Label(orb),\"$:} &\\\\\\\\\\n \");\n PrintTo(fisier,\"\\\\textbf{p=\",Characteristic(sys),\":}\");\n AppendTo(fisier,\"&$\\\\mathbf{u}=\");\n AppendTo(fisier,trimmedStringNice(latexUnipotentNice(uu),\"u+\",step));\n AppendTo(fisier,\"$\\\\\\\\\\n&\\n$\\\\mathbf{\\\\tilde u}=\");\n AppendTo(fisier,trimmedStringNice(latexUnipotentNice(u),\"u+\",step));\n# AppendTo(fisier,\"$\\\\\\\\\\n&\\n$\\\\mathbf{C_U(\\\\tilde u)^{\\\\circ}} =\");\n# AppendTo(fisier,trimmedString2Nice(latexUnipotentNice(Unipotent(chevalleyAdj(u),coefficients(info[1]),Ordering(u))),\"u+\",30,step));\n AppendTo(fisier,\"$\\\\\\\\\\n&\\n$\\\\mathbf{Z(C_G(u))^{\\\\circ}} =\");\n AppendTo(fisier,trimmedString2Nice(latexUnipotentNice(Unipotent(chevalleyAdj(uu),coefficients(FromPositiveBorel(orb,info[2])),Ordering(uu))),\"u+\",40,step));\n AppendTo(fisier,\"$\\\\\\\\\\n\");\n# AppendTo(fisier,\"$\\n\\\\end{array}\\n$$\");\n SizeScreen([156,39]);\nend;\n\nlatexClassesShort:=function(orbs,infos)\n local i;\n for i in [1..Length(Classes(orbs))] do\n latexClassShort(Classes(orbs)[i],infos[i]);\n od;\nend;\n\nlatexClassesShortNice:=function(orbs,infos)\n local i;\n for i in [1..Length(Classes(orbs))] do\n latexClassShortNice(Classes(orbs)[i],infos[i]);\n od;\nend;\n\nlatexClassesVeryShortNice:=function(orbs,infos)\n local i;\n for i in [1..Length(Classes(orbs))] do\n latexClassVeryShortNice(Classes(orbs)[i],infos[i]);\n od;\nend;\n\nlatexFisiere:=function(orbs)\n local result,\n sys,tip,rang,p,\n fisier,fisi,orb;\n\n sys:=algebraicU(orbs);\n tip:=type(sys);\n rang:=rank(sys);\n p:=Characteristic(sys);\n fisier:=Concatenation(\"tex/data/all\",tip,String(rang),\"char\",String(p),\".tex\");\n fisier:=Filename(home_dir,fisier);\n \n\n result:=\"\";\n for orb in Classes(orbs) do\n result:=Concatenation(result,\"\\\\input{data/\",tip,String(rang),\"/char\",String(p),\"/\",Label(orb),\".tex}\\n\");\n fisi:=Concatenation(\"tex/data/\",tip,String(rang),\"/char\",String(p),\"/\",Label(orb),\".tex\");\n fisi:=ReplacedString(fisi,\"\\\\tilde \",\"s\");\n fisi:=Filename(home_dir,fisi);\n PrintTo(fisi,\" \");\n od;\n\n result:=ReplacedString(result,\"\\\\tilde \",\"s\");\n PrintTo(fisier,result);\nend;\n\nlatexFisiereNice:=function(orbs)\n local result,inainte,dupa,\n sys,tip,rang,p,\n fisier,fisi,orb;\n\n sys:=algebraicU(orbs);\n tip:=type(sys);\n rang:=rank(sys);\n p:=Characteristic(sys);\n fisier:=Concatenation(\"tex/data/all\",tip,String(rang),\"char\",String(p),\".tex\");\n fisier:=Filename(home_dir,fisier);\n \n dupa:=\"\\\\end{array}$\";\n\n result:=\"\";\n for orb in Classes(orbs) do\n inainte:=Concatenation(\"\\\\\\\\\\n\\\\par\\\\noindent\\n$\\\\begin{array}{p{0.7cm} p{15cm}}\\n$\\\\mathbf{\",Label(orb),\"}$ &\\\\\\\\\");\n result:=Concatenation(result,inainte,\"\\n\\\\input{data/\",tip,String(rang),\"/char\",String(p),\"/\",Label(orb),\".tex}\\n\",dupa,\"\\n\");\n fisi:=Concatenation(\"tex/data/\",tip,String(rang),\"/char\",String(p),\"/\",Label(orb),\".tex\");\n fisi:=ReplacedString(fisi,\"\\\\tilde \",\"s\");\n fisi:=Filename(home_dir,fisi);\n# PrintTo(fisi,\" \");\n od;\n\n result:=ReplacedString(result,\"\\\\tilde \",\"s\");\n PrintTo(fisier,result);\nend;\n\n\n#\n# SAGE\n#\n\nsageAdu:=function(classes)\n local sys,orbs,orbs_len,o,fisier_out,dir,dir_labels,ad,result,i,j,dim;\n sys:=algebraicU(classes);\n orbs:=Classes(classes);\n dir_labels:=Directory(Concatenation(\"~/workspace/ChevalleyAdj/sage/data/\",type(sys),String(rank(sys))));\n dir:=Directory(Concatenation(\"~/workspace/ChevalleyAdj/sage/data/\",\n type(sys),String(rank(sys)),\"/char\",String(Characteristic(sys))));\n \n SizeScreen([2000,2000]);\n for o in orbs do\n fisier_out:=Concatenation(Label(o),\".sage\");\n fisier_out:=ReplacedString(fisier_out,\"\\\\tilde \",\"s\");\n fisier_out:=Filename(dir,fisier_out);\n ad:=Descend(Representative(o),chevalleyAdj(chevalleyAdj(Representative(o))));\n ad:=Adu(ad);\n ad:=List(ad,i->List(i,j->Int(j)));\n# result:=List(ad,i->ReplacedString(String(i),\", \",\",\"));\n# result:=ReplacedString(result,\", \",\",\");\n# result:=ReplacedString(result,\"],\",\"],\\n\");\n# PrintTo(fisier_out,Concatenation(\"rep=\",result));\n PrintTo(fisier_out,\"rep=\");\n AppendTo(fisier_out,\"[\");\n dim:=Length(ad);\n for i in [1..dim] do\n AppendTo(fisier_out,\"[\");\n for j in [1..dim] do\n AppendTo(fisier_out,String(ad[i][j]));\n if j<>dim then AppendTo(fisier_out,\",\"); fi;\n od;\n AppendTo(fisier_out,\"]\");\n if i<>dim then AppendTo(fisier_out,\",\\n\"); fi;\n od;\n AppendTo(fisier_out,\"]\");\n od;\n\n fisier_out:=Filename(dir_labels,Concatenation(\"char\",String(Characteristic(sys)),\"Labels.sage\"));\n PrintTo(fisier_out,\"labels=[\");\n orbs_len:=Length(orbs);\n for i in [1..orbs_len] do\n AppendTo(fisier_out,\"\\\"\",ReplacedString(Label(orbs[i]),\"\\\\tilde \",\"s\"),\"\\\"\");\n if i<>orbs_len then AppendTo(fisier_out,\",\"); fi;\n od;\n AppendTo(fisier_out,\"]\");\n \n SizeScreen([156,39]);\nend;\n\nlatexJordanBlocks:=function(classes)\n local sys,result,fisier_out,tex_blocks,o;\n sys:=algebraicU(classes);\n fisier_out:=Concatenation(\"~/workspace/ChevalleyAdj/tex/data/\",\n type(sys),String(rank(sys)),\"/char\",String(Characteristic(sys)),\"blocks.tex\");\n\n tex_blocks:=function(blocks)\n local result;\n result:=Concatenation(List(blocks,b->Concatenation(\",\",String(b[1]),\"^{\",String(b[2]),\"}\")));\n result:=result{[2..Length(result)]};\n return ReplacedString(result,\"^{1}\",\"\");\n end;\n \n result:=\"\";\n for o in Classes(classes) do\n result:=Concatenation(result,\"$\",Label(o),\"$ & $\",tex_blocks(AduJordanBlocks(Representative(o))),\"$\\\\\\\\ \\n\");\n od;\n\n \n PrintTo(fisier_out,\"\\\\begin{tabular}{|c|c|}\\n \\\\hline \\n\");\n AppendTo(fisier_out,\"Class & Blocks\\\\\\\\ \\\\hline\\n\");\n AppendTo(fisier_out,result,\"\\\\hline\\n\");\n AppendTo(fisier_out,\"\\\\end{tabular}\\n\");\nend;\n", "meta": {"hexsha": "c5ef698b510ca5afb93dd0bbbb8e7cc0df0546ed", "size": 17873, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "lib/io.gi", "max_stars_repo_name": "iuliansimion/Chevalley.gap", "max_stars_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/io.gi", "max_issues_repo_name": "iuliansimion/Chevalley.gap", "max_issues_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/io.gi", "max_forks_repo_name": "iuliansimion/Chevalley.gap", "max_forks_repo_head_hexsha": "dd237f36d69a42bcd6cb6a24c5e4bf7dfb3da186", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.4700374532, "max_line_length": 160, "alphanum_fraction": 0.5766239579, "num_tokens": 5502, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.5555047328995154}}
{"text": "# Copyright (c) 2018-2020, Carnegie Mellon University\n# See LICENSE for details\n#\n# Top-level qCirc object and associated helpers\n#\n\n##\n#F CircTerm( <ops>, <n>, <arch> )\n## \n#F given a list of operations to perform on target qubits, the number of qubits, and the hardware architecture,\n#F expand out the qCircuit object as a matrix product of qEmbed objects\n##\nCircTerm := function(ops, n, arch) \n local mat, h, oper;\n mat := I(2^(n));\n for oper in ops do\n # oper is [[1,2,3], qHT], for example\n h := qEmbed(oper[1], n, arch, oper[2]).terminate();\n mat := mat * h;\n od;\n return mat;\nend;\n\n\n##\n#F ArchUpdate( <oplist>, <arch> )\n## \n#F updates all operations in oplist to use the new architecture\n##\nArchUpdate := function(oplist, arch) \n local newlist, ops, qubits, T;\n newlist := [];\n for ops in oplist do\n # op is [[qubits], Transform]\n qubits := ops[1];\n T := ops[2].recursive_def(arch);\n Add(newlist, [qubits, T]);\n od;\n return newlist;\nend;\n\n##\n#F qCirc( <arch>, <n>, <ops>) Object\n##\n#F Given architecture arch and number of qubits n, embed each operation in ops\n#F an operation is a [[qubit list], <Non-Terminal>] list\n#F ops in an operation list\nClass(qCirc, TaggedNonTerminal, rec(\n abbrevs := [ (arch, n, ops) -> Checked(IsPosInt(n), [arch, n, ops]) ],\n dims := self >> let(size := 2^self.params[2], [size, size]),\n terminate := self >> CircTerm(self.params[3], self.params[2], self.params[1]),\n isReal := self >> false,\n recursive_def := (self, arch) >> self.__bases__[1](arch, self.params[2], ArchUpdate(self.params[3], arch) ),\n rChildren := self >> self.params,\n from_rChildren := (self, rch) >> self.__bases__[1](rch[1], rch[2], rch[3]),\n SmallRandom := () -> Random([2..5]),\n LargeRandom := () -> Random([6..15]),\n normalizedArithCost := self >> Error(\"ArithCost not implemented\"),\n TType := T_Complex(64)\n));\n\n##\n#F GenCircChildren( <arch>, <n>, <ops> )\n## \n#F given a list of operations to perform on target qubits, the number of qubits, and the hardware architecture,\n#F expand out the qCircuit object as a matrix product of qEmbed objects\n##\nGenCircChildren := function(arch, n, ops)\n local current_op, ops, h1, h, rest;\n current_op := ops[1];\n h1 := qEmbed(current_op[1], n, arch, current_op[2]);\n h := h1;\n if Length(ops) > 1 then \n rest := [2..Length(ops)];\n rest := Map(rest, i -> ops[i]);\n h := h * qCirc(arch, n, rest);\n fi;\n return [h];\nend;\n\n\n##\n#F qCirc Breakdown Rules\n## \nNewRulesFor(qCirc, rec(\n\n # qCirc_Expand rule\n # qCirc_Expand qCirc(arch, n, ops) -> qEmbed(qubits, n, arch, <Non-Terminal>) * ...\n qCirc_Expand := rec (\n forTransposition := false,\n minSize := 2, \n applicable := (self, nt) >> (nt.params[3] <> []),\n children := nt -> List([GenCircChildren(nt.params[1], nt.params[2], nt.params[3])]),\n apply := (nt, c, cnt) -> c[1],\n switch := true,\n ),\n\n # qCirc_Base rule\n # QCirc_Base qCirc(arch, n, []) -> I(2^n)\n qCirc_Base := rec(\n info := \"qCirc -> Identity\",\n forTransposition := false,\n applicable := (self, nt) >> (nt.params[3] = []),\n apply := (nt, c, cnt) -> I(2^(nt.params[2])),\n )\n\n));", "meta": {"hexsha": "3cc79af4f04bdb65f98bdbd3cccf28cd0c128ff4", "size": 3335, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "circ.gi", "max_stars_repo_name": "spiral-software/spiral-package-quantum", "max_stars_repo_head_hexsha": "dd2323983495adbbc6261c0cdf840320d19d099d", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "circ.gi", "max_issues_repo_name": "spiral-software/spiral-package-quantum", "max_issues_repo_head_hexsha": "dd2323983495adbbc6261c0cdf840320d19d099d", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "circ.gi", "max_forks_repo_name": "spiral-software/spiral-package-quantum", "max_forks_repo_head_hexsha": "dd2323983495adbbc6261c0cdf840320d19d099d", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1682242991, "max_line_length": 112, "alphanum_fraction": 0.5814092954, "num_tokens": 1024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972818382005, "lm_q2_score": 0.6370308013713525, "lm_q1q2_score": 0.5545972841211101}}
{"text": "\n\n# Define a pregroup by giving a list of generator names and\n# a (partial) multiplication table\nInstallGlobalFunction(PregroupByTableNC,\nfunction(enams, inv, table)\n local r,e;\n\n r := rec( PregroupElementNames := enams\n , inv := inv\n , table := table );\n r.fam := NewFamily( \"PregroupElementsFamily\", IsElementOfPregroup );\n r.elt_t := NewType( r!.fam, IsElementOfPregroupRep );\n r.wfam := NewFamily( \"PregroupWordFamily\", IsPregroupWord );\n r.word_t := NewType( r!.wfam, IsPregroupWordListRep );\n r.elts := List( [1..Length(table)], i -> Objectify(r.elt_t, rec(parent := r, elt := i)));\n r.invs := [];\n for e in [1..Length(r.elts)] do\n r.elts[e]!.inv := r.elts[inv(e)];\n od;\n Objectify(PregroupByTableType, r);\n SetPregroupElementNames(r, enams);\n return r;\nend);\n\nInstallGlobalFunction(PregroupInversesFromTable,\nfunction(table)\n local i,j,inv;\n\n inv := [];\n for i in [1..Length(table)] do\n for j in [1..Length(table[i])] do\n if table[i][j] = 1 then\n if IsBound(inv[i]) then\n if inv[i] <> j then\n Error(\"inverses not well-defined\");\n fi;\n else\n inv[i] := j;\n fi;\n fi;\n od;\n od;\n inv := PermList(inv);\n if inv = fail then\n Error(\"inverses not well-defined\");\n fi;\n return x -> x^inv;\nend);\n\nInstallGlobalFunction(PregroupByTable,\nfunction(enams, table)\n local nels, inv, row, e, f, g, h;\n\n # We assume that the length of the list of\n # element names is the number of elements\n nels := Length(enams);\n\n if Length(table) <> nels then\n Error(\"PregroupByTable: Length of enams does not match number of rows in table\");\n fi;\n for row in table do\n if Length(row) <> nels then\n Error(\"PregroupByTable: Multiplication table is not square\");\n fi;\n for e in row do\n if (not IsInt(e)) or (e < 0) or (e > nels) then\n Error(\"PregroupByTable: Table entry \", e, \" is invalid, needs to be an integer between 0 and \", nels);\n fi;\n od;\n od;\n\n inv := PregroupInversesFromTable(table);\n for e in [1..nels] do\n if inv(inv(e)) <> e then\n Error(\"PregroupByTable: inv needs to be an involution\");\n fi;\n od;\n for e in [1..nels] do\n if (table[1][e] <> e) or (table[e][1] <> e) then\n Error(\"PregroupByTable: \",e,\"*1 = \", e, \" or 1*\", e, \" = \", e, \" not satisfied\");\n fi;\n if (table[e][inv(e)] <> 1) or (table[inv(e)][e] <> 1) then\n Error(\"PregroupByTable: inverses\");\n fi;\n od;\n\n for e in [1..nels] do\n for f in [1..nels] do\n for g in [1..nels] do\n if table[e][f] > 0 and table[f][g] > 0 then\n if (table[table[e][f]][g] = 0 and table[e][table[f][g]] > 0) or\n (table[table[e][f]][g] > 0 and table[e][table[f][g]] = 0) then\n Error(\"PregroupByTable: associativity\");\n fi;\n fi;\n od;\n od;\n od;\n\n for e in [1..nels] do\n for f in [1..nels] do\n if table[e][f] > 0 then\n for g in [1..nels] do\n if table[f][g] > 0 then\n for h in [1..nels] do\n if table[g][h] > 0 then\n if table[table[e][f]][g] = 0 and table[table[f][g]][h] = 0 then\n Error(\"PregroupByTable: P5 violated\");\n fi;\n fi;\n od;\n fi;\n od;\n fi;\n od;\n od;\n return PregroupByTableNC(enams, inv, table);\nend);\n\nInstallMethod(\\[\\]\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep, IsInt],\nfunction(f,a)\n return f!.elts[a];\nend);\n\nInstallMethod(Iterator\n , \"for a pregroup\"\n , [IsPregroupTableRep],\nfunction(pgp)\n local r;\n\n r := rec( pgp := pgp\n , pos := 0\n , length := Size(pgp)\n , NextIterator := function(iter)\n if iter!.pos < iter!.length then\n iter!.pos := iter!.pos + 1;\n return iter!.pgp[iter!.pos];\n else\n return fail;\n fi;\n end\n , IsDoneIterator := iter -> iter!.pos = iter!.length\n , ShallowCopy := iter -> rec( pgp := iter!.pgp, pos := iter!.pos )\n );\n\n return IteratorByFunctions(r);\nend);\n\nInstallMethod(PregroupElementNames\n , \"for a pregroup\"\n , [IsPregroupTableRep]\n , p -> p!.elementnames );\n\nInstallMethod(SetPregroupElementNames\n , \"for a pregroup\"\n , [IsPregroupTableRep, IsList]\n , function(p, n)\n p!.elementnames := n;\n end );\n\nInstallMethod(ViewString\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep],\nfunction(pg)\n return STRINGIFY(\"<pregroup with \", Size(pg), \" elements in table rep>\");\nend);\n\nInstallMethod(Size\n , \"for a pregroup in table rep\"\n , [IsPregroup and IsPregroupTableRep],\nfunction(pg)\n return Length(pg!.elts);\nend);\n\n#XXX at the moment [1,x] and [x,1] intermult, but I don't think\n# this is really needed?\n#XXX Intermult is only defined for elements other than 1\nInstallMethod(IntermultPairs\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep],\nfunction(pg)\n local i, j, k, pairs;\n\n pairs := [];\n for i in [2..Size(pg)] do\n for j in [2..Size(pg)] do\n if (i <> pg!.inv(j)) then\n if (pg!.table[i][j] > 0) then\n Add(pairs, [pg[i],pg[j]]);\n else\n for k in [2..Size(pg)] do\n if (pg!.table[i][k] > 0) and\n (pg!.table[pg!.inv(k)][j] > 0) then\n Add(pairs, [pg[i],pg[j]]);\n break;\n fi;\n od;\n fi;\n fi;\n od;\n od;\n return pairs;\nend);\n\nInstallMethod(IntermultPairsIDs\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep],\nfunction(pg)\n local i, j, k, pairs;\n\n pairs := [];\n for i in [2..Size(pg)] do\n for j in [2..Size(pg)] do\n if (i <> pg!.inv(j)) then\n if (pg!.table[i][j] > 0) then\n Add(pairs, [i,j]);\n else\n for k in [2..Size(pg)] do\n if (pg!.table[i][k] > 0) and\n (pg!.table[pg!.inv(k)][j] > 0) then\n Add(pairs, [i,j]);\n break;\n fi;\n od;\n fi;\n fi;\n od;\n od;\n return pairs;\nend);\n\n\nInstallMethod(IntermultMapIDs\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep],\nfunction(pg)\n local i, j, k, map;\n\n map := [];\n for i in [1..Size(pg)] do\n map[i] := [];\n od;\n\n for i in [2..Size(pg)] do\n for j in [2..Size(pg)] do\n if (i <> pg!.inv(j)) then\n if (pg!.table[i][j] > 0) then\n Add(map[i], j);\n else\n for k in [2..Size(pg)] do\n if (pg!.table[i][k] > 0) and\n (pg!.table[pg!.inv(k)][j] > 0) then\n Add(map[i],j);\n break;\n fi;\n od;\n fi;\n fi;\n od;\n od;\n return map;\nend);\n\nInstallMethod(IntermultMap\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep],\nfunction(pg)\n return List(IntermultMapIDs(pg), x -> List(x, i -> pg[i]));\nend);\n\nInstallMethod(IntermultTable\n , \"for a pregroup in table rep\"\n , [IsPregroupTableRep],\nfunction(pg)\n local i, j, k, map;\n\n map := [];\n for i in [1..Size(pg)] do\n map[i] := [false];\n od;\n\n for i in [2..Size(pg)] do\n for j in [2..Size(pg)] do\n map[i][j] := false;\n if (i <> pg!.inv(j)) then\n if (pg!.table[i][j] > 0) then\n map[i][j] := true;\n else\n for k in [2..Size(pg)] do\n if (pg!.table[i][k] > 0) and\n (pg!.table[pg!.inv(k)][j] > 0) then\n map[i][j] := true;\n break;\n fi;\n od;\n fi;\n fi;\n od;\n od;\n return map;\nend);\n\nInstallMethod(One, \"for a pregroup\",\n [IsPregroup],\n pg -> pg!.elts[1]);\n\n# This is very inefficient, but I don't care at the moment\nInstallMethod(MultiplicationTableIDs,\n \"for a pregroup\",\n [IsPregroup],\nfunction(pg)\n local i, j, table;\n\n table := [];\n for i in [1..Size(pg)] do\n table[i] := [];\n for j in [1..Size(pg)] do\n table[i][j] := pg[i] * pg[j];\n if table[i][j] = fail then\n table[i][j] := 0;\n else\n table[i][j] := __ID(table[i][j]);\n fi;\n od;\n od;\n return table;\nend);\n\nInstallMethod(MultiplicationTable,\n \"for a pregroup\",\n [IsPregroup],\nfunction(pg)\n local i, j, table;\n\n table := [];\n for i in [1..Size(pg)] do\n table[i] := [];\n for j in [1..Size(pg)] do\n table[i][j] := pg[i] * pg[j];\n od;\n od;\n return table;\nend);\n\n#\n# Pregroup elements\n#\nInstallMethod(IntermultMap\n , \"for a pregroup element\"\n , [IsElementOfPregroupRep],\nfunction(pge)\n return IntermultMap(pge!.parent)[__ID(pge)];\nend);\n\nInstallMethod(ViewString\n , \"for a pregroup element\"\n , [IsElementOfPregroupRep],\nfunction(pge)\n if pge!.elt > 0 then\n return PregroupElementNames(pge!.parent)[pge!.elt];\n else\n return \"undefined\";\n fi;\nend);\n\nInstallMethod(String\n , \"for a pregroup element\"\n , [IsElementOfPregroupRep],\nfunction(pge)\n if pge!.elt > 0 then\n return PregroupElementNames(pge!.parent)[pge!.elt];\n else\n return \"undefined\";\n fi;\nend);\n\nInstallMethod(InverseOp\n , \"for a pregroup element\"\n , [IsElementOfPregroupRep]\n , 0,\nfunction(x)\n return PregroupInverse(x);\nend);\n\n#XXX Is fail as a result for multiplication acceptable?\nInstallMethod(\\*\n , \"for pregroup elements\"\n , IsIdenticalObj\n , [IsElementOfPregroupRep, IsElementOfPregroupRep]\n , 0,\nfunction(x,y)\n local pg, r;\n\n pg := x!.parent;\n\n r := pg!.table[x!.elt][y!.elt];\n\n if r > 0 then\n return pg!.elts[r];\n else\n return fail;\n fi;\nend);\n\nInstallMethod(\\=\n , \"for pregroup elements\"\n , IsIdenticalObj\n , [IsElementOfPregroupRep, IsElementOfPregroupRep]\n , 0,\nfunction(x,y)\n return x!.elt = y!.elt;\nend);\n\n# Artificial ordering on pregroup to make sets work\nInstallMethod(\\<\n , \"for pregroup elements\"\n , IsIdenticalObj\n , [ IsElementOfPregroupRep, IsElementOfPregroupRep]\n , 0,\nfunction(x,y)\n return x!.elt < y!.elt;\nend);\n\nInstallMethod(PregroupOf\n , \"for pregroup elements\"\n , [ IsElementOfPregroupRep ]\n , 0,\nfunction(a)\n return a!.parent;\nend);\n\nInstallMethod(PregroupInverse\n , \"for pregroup elements\"\n , [ IsElementOfPregroupRep ]\n , 0,\n a -> a!.inv);\n\nInstallMethod(PregroupElementId\n , \"for pregroup elements\"\n , [ IsElementOfPregroupRep]\n , 0,\n a -> a!.elt);\n\nInstallMethod(__ID\n , \"for pregroup elements\"\n , [IsElementOfPregroup]\n , 0,\n x -> x!.elt);\n\nInstallMethod(IsDefinedMultiplication\n , \"for pregroup elements\"\n , IsIdenticalObj\n , [IsElementOfPregroup, IsElementOfPregroup]\n , 0,\nfunction(a,b)\n local pg;\n\n pg := PregroupOf(a);\n\n return pg!.table[a!.elt][b!.elt] > 0;\nend);\n\n# We could cache intermult pairs,\n# or predetermine them, depending\n# on the number of intermult lookups\n# that could benefit runtime\nInstallMethod(IsIntermultPair\n , \"for pregroup elements\"\n , IsIdenticalObj\n , [IsElementOfPregroup, IsElementOfPregroup]\n , 0,\nfunction(a,b)\n local x, nontriv;\n\n return IntermultTable(a!.parent)[__ID(a)][__ID(b)];\n\n if a = PregroupInverse(b) then\n return false;\n elif IsDefinedMultiplication(a, b) then\n return true;\n else\n nontriv := List(PregroupOf(a), x -> x);\n Remove(nontriv, 1);\n for x in nontriv do\n if IsDefinedMultiplication(a,x)\n and IsDefinedMultiplication(PregroupInverse(x), b) then\n return true;\n fi;\n od;\n return false;\n fi;\n # Should not be reached\n Error(\"This shouldn't happen.\");\nend);\n\n", "meta": {"hexsha": "3657ef639b53d67bd2bc71ea9a3a036dec4cfaa3", "size": 13483, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "gap/pregroup.gi", "max_stars_repo_name": "RussWoodroofe/walrus", "max_stars_repo_head_hexsha": "f7a4e3597f288c6d9518aaa39091826dadc864b8", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-10-02T14:55:52.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-02T14:55:52.000Z", "max_issues_repo_path": "gap/pregroup.gi", "max_issues_repo_name": "RussWoodroofe/walrus", "max_issues_repo_head_hexsha": "f7a4e3597f288c6d9518aaa39091826dadc864b8", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 26, "max_issues_repo_issues_event_min_datetime": "2018-11-22T11:15:07.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-21T13:31:01.000Z", "max_forks_repo_path": "gap/pregroup.gi", "max_forks_repo_name": "RussWoodroofe/walrus", "max_forks_repo_head_hexsha": "f7a4e3597f288c6d9518aaa39091826dadc864b8", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2019-02-11T14:47:47.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-20T10:22:09.000Z", "avg_line_length": 27.0200400802, "max_line_length": 118, "alphanum_fraction": 0.478306015, "num_tokens": 3611, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389930307512, "lm_q2_score": 0.7431680143008301, "lm_q1q2_score": 0.5545066338430843}}
{"text": "# Copyright (c) 2018-2020, Carnegie Mellon University\n# See LICENSE for details\n#\n# n-qubit Y transforms\n#\n\n\n#F qYT( n ) - Y Gate non-terminal\n#F Definition: (2^n x 2^n)-matrix that applies an n-point Y Transform to the target qubits\n#F Note: qYT(1) denotes the matrix[[0, -i], [i, 0]],\n#F qYT(_) is not symmetric.\n#F\n#F qYT( n ) -> an n-qubit Y transform\nClass(qYT, TaggedNonTerminal, rec(\n abbrevs := [ n -> Checked(IsPosInt(n), [n]) ],\n dims := self >> let(size := 2^self.params[1], [size, size]),\n terminate := self >> Tensor(Replicate(self.params[1], qX())),\n isReal := self >> true,\n groups := self >> [Replicate(self.params[1], 1)],\n rChildren := self >> self.params,\n from_rChildren := (self, rch) >> self.__bases__[1](rch[1]),\n recursive_def := (self, arch) >> self.__bases__[1](self.params[1]),\n connected := self >> true,\n SmallRandom := () -> Random([2..5]),\n LargeRandom := () -> Random([6..15]),\n normalizedArithCost := self >> Error(\"ArithCost not implemented\"),\n TType := T_Complex(64),\n));\n\n\nNewRulesFor(qYT, rec(\n\n # qYT_BinSplit rule\n # qYT_BinSplit qYT_(k) -> (qYT_(k1) tensor I) (I tensor qYT_(k2))\n # k1 + k2 = k\n qYT_BinSplit := rec (\n forTransposition := false,\n minSize := 2, \n applicable := (self, nt) >> nt.params[1] > 1,\n children := nt -> List( [1..nt.params[1] - 1], i -> [ Tensor(qYT(i), qYT(nt.params[1]-i)).withTags(nt.getTags()) ] ), \n apply := (nt, c, cnt) -> c[1],\n switch := true,\n ),\n\n #F qYT_Base: qYT(1) = qY() SPL object\n #F Directly represent as an implementable gate\n qYT_Base := rec(\n info := \"qYT_(1) -> qY()\",\n forTransposition := false,\n applicable := (self, nt) >> nt.params[1]=1,\n apply := (nt, c, cnt) -> qY(),\n )\n\n));", "meta": {"hexsha": "35a395d89d10d7667d3f9b34fc8ec7a1e0c98969", "size": 1875, "ext": "gi", "lang": "GAP", "max_stars_repo_path": "qyt.gi", "max_stars_repo_name": "spiral-software/spiral-package-quantum", "max_stars_repo_head_hexsha": "dd2323983495adbbc6261c0cdf840320d19d099d", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "qyt.gi", "max_issues_repo_name": "spiral-software/spiral-package-quantum", "max_issues_repo_head_hexsha": "dd2323983495adbbc6261c0cdf840320d19d099d", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "qyt.gi", "max_forks_repo_name": "spiral-software/spiral-package-quantum", "max_forks_repo_head_hexsha": "dd2323983495adbbc6261c0cdf840320d19d099d", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.7222222222, "max_line_length": 136, "alphanum_fraction": 0.5493333333, "num_tokens": 598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619177503205, "lm_q2_score": 0.672331705744791, "lm_q1q2_score": 0.5543118874826946}}
{"text": "#!/usr/bin/gap\n\n# https://cp4space.wordpress.com/2020/05/10/minimalistic-quantum-computation/\n\nPrint(\"running universal.gap\\n\");;\n\n\nr2 := Sqrt(2);;\nir2 := 1/r2;;\n\ni := [[1, 0], [0, 1]];;\nw := [[E(4), 0], [0, E(4)]];;\nx := [[0, 1], [1, 0]];;\nz := [[1, 0], [0, -1]];;\ns := [[1, 0], [0, E(4)]];;\nh := [[ir2, ir2], [ir2, -ir2]];;\n\nCliff1 := Group(w, s, h);; # Order 192\nPauli1 := Group(w, x, z);; # Order 32\n\nxi := KroneckerProduct(x, i);;\nix := KroneckerProduct(i, x);;\nzi := KroneckerProduct(z, i);;\niz := KroneckerProduct(i, z);;\nsi := KroneckerProduct(s, i);;\nis := KroneckerProduct(i, s);;\nhi := KroneckerProduct(h, i);;\nih := KroneckerProduct(i, h);;\nwi := KroneckerProduct(w, i);;\n\n\ncz := [\n [1, 0, 0, 0],\n [0, 1, 0, 0],\n [0, 0, 1, 0],\n [0, 0, 0, -1]];;\n\nCliff2 := Group(si, is, hi, ih, wi, cz);; # Order 92160\n#for g in Cliff2 do Print(g, \"\\n\"); od;\nPauli2 := Group(wi, xi, ix, zi, iz);;\n\n\nxii := KroneckerProduct(xi, i);;\nixi := KroneckerProduct(i, xi);;\niix := KroneckerProduct(i, ix);;\n\nzii := KroneckerProduct(zi, i);;\nizi := KroneckerProduct(i, zi);;\niiz := KroneckerProduct(i, iz);;\n\nsii := KroneckerProduct(si, i);;\nisi := KroneckerProduct(i, si);;\niis := KroneckerProduct(i, is);;\n\nhii := KroneckerProduct(hi, i);;\nihi := KroneckerProduct(i, hi);;\niih := KroneckerProduct(i, ih);;\n\nwii := KroneckerProduct(wi, i);;\n\nicz := KroneckerProduct(i, cz);;\nczi := KroneckerProduct(cz, i);;\n\n\nTofolli := [\n [1, 0, 0, 0, 0, 0, 0, 0],\n [0, 1, 0, 0, 0, 0, 0, 0],\n [0, 0, 1, 0, 0, 0, 0, 0],\n [0, 0, 0, 1, 0, 0, 0, 0],\n [0, 0, 0, 0, 1, 0, 0, 0],\n [0, 0, 0, 0, 0, 1, 0, 0],\n [0, 0, 0, 0, 0, 0, 0, 1],\n [0, 0, 0, 0, 0, 0, 1, 0]];;\n\n\nzhh := zii*ihi*iih;\nhzh := izi*hii*iih;\nhhz := iiz*hii*ihi;\n\nxhh := xii*ihi*iih;\nhxh := ixi*hii*iih;\nhhx := iix*hii*ihi;\n\nGx := Group(Tofolli, xhh, hxh, hhx);\nGz := Group(Tofolli, zhh, hzh, hhz);\n\nPrint(\"Order(Gz) = \", Order(Gz), \"\\n\");\nPrint(\"Order(Gx) = \", Order(Gx), \"\\n\");\n\nL7:= SimpleLieAlgebra(\"E\", 7, Rationals);;\nR7:= RootSystem(L7);;\nW7:= WeylGroup(R7);\nPrint(\"Order(W7) = \", Order(W7), \"\\n\");\n\nf := IsomorphismGroups(Gz, W7);\nPrint(\"IsomorphismGroups(Gz, E7) = \", f, \"\\n\");\n\nL8:= SimpleLieAlgebra(\"E\", 8, Rationals);;\nR8:= RootSystem(L8);;\nW8:= WeylGroup(R8);\nPrint(\"Order(W8) = \", Order(W8), \"\\n\");\n\nf := IsomorphismGroups(Gx, W8);\nPrint(\"IsomorphismGroups(Gx, E8) = \", f, \"\\n\");\n\n\n\n\n\n", "meta": {"hexsha": "dd5eafda4fe7504e725744ae6a53a07a0a7d0e29", "size": 2361, "ext": "gap", "lang": "GAP", "max_stars_repo_path": "bruhat/dev/universal.gap", "max_stars_repo_name": "punkdit/bruhat", "max_stars_repo_head_hexsha": "3231eacc49fd3464542f7eb72684751371d9876c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2020-04-07T13:21:30.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-15T02:07:20.000Z", "max_issues_repo_path": "bruhat/dev/universal.gap", "max_issues_repo_name": "punkdit/bruhat", "max_issues_repo_head_hexsha": "3231eacc49fd3464542f7eb72684751371d9876c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "bruhat/dev/universal.gap", "max_forks_repo_name": "punkdit/bruhat", "max_forks_repo_head_hexsha": "3231eacc49fd3464542f7eb72684751371d9876c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.4636363636, "max_line_length": 77, "alphanum_fraction": 0.5421431597, "num_tokens": 1062, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711718571775, "lm_q2_score": 0.6513548646660542, "lm_q1q2_score": 0.5536328576150793}}
|