From 8a5a3837a8413707d0f35b58120a5b39b1a714f7 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Tue, 26 Oct 2021 10:23:56 +0200 Subject: [PATCH 1/8] Apply PackageJanitor to ActionsForCAP and AttributeCategoryForCAP and enable tests --- ActionsForCAP/.gitignore | 34 ++ ActionsForCAP/LICENSE | 339 ++++++++++++++++++ ActionsForCAP/PackageInfo.g | 2 +- .../doc/{Intros.autodoc => Doc.autodoc} | 0 ActionsForCAP/doc/clean | 6 +- ActionsForCAP/examples/ActionsTest.g | 24 +- .../examples/CategoryWithAttributesTest.g | 121 +++---- ActionsForCAP/examples/IndirectionTest.g | 204 +++++------ ActionsForCAP/examples/IndirectionTest2.g | 93 +++-- ActionsForCAP/gap/ActionMorphisms.gd | 16 +- ActionsForCAP/gap/ActionMorphisms.gi | 14 +- ActionsForCAP/gap/ActionObjects.gd | 16 +- ActionsForCAP/gap/ActionObjects.gi | 14 +- ActionsForCAP/gap/ActionsCategory.gd | 16 +- ActionsForCAP/gap/ActionsCategory.gi | 14 +- ActionsForCAP/gap/CoactionMorphisms.gd | 16 +- ActionsForCAP/gap/CoactionMorphisms.gi | 14 +- ActionsForCAP/gap/CoactionObjects.gd | 16 +- ActionsForCAP/gap/CoactionObjects.gi | 14 +- ActionsForCAP/gap/CoactionsCategory.gd | 16 +- ActionsForCAP/gap/CoactionsCategory.gi | 14 +- ActionsForCAP/gap/SemisimpleCategory.gd | 14 +- ActionsForCAP/gap/SemisimpleCategory.gi | 14 +- ActionsForCAP/init.g | 2 +- ActionsForCAP/makedoc.g | 45 ++- .../makedoc_with_overfull_hbox_warnings.g | 42 +++ ActionsForCAP/makefile | 74 ++-- ActionsForCAP/read.g | 2 +- ActionsForCAP/tst/100_LoadPackage.tst | 13 + ActionsForCAP/tst/testall.g | 35 +- AttributeCategoryForCAP/.gitignore | 34 ++ AttributeCategoryForCAP/LICENSE | 339 ++++++++++++++++++ AttributeCategoryForCAP/PackageInfo.g | 2 +- .../doc/{Intros.autodoc => Doc.autodoc} | 0 AttributeCategoryForCAP/doc/clean | 6 +- AttributeCategoryForCAP/examples/example.g | 106 +++--- .../gap/AttributeCategory.gd | 14 +- .../gap/AttributeCategory.gi | 14 +- AttributeCategoryForCAP/init.g | 2 +- AttributeCategoryForCAP/makedoc.g | 42 ++- .../makedoc_with_overfull_hbox_warnings.g | 42 +++ AttributeCategoryForCAP/makefile | 74 ++-- AttributeCategoryForCAP/read.g | 2 +- .../tst/100_LoadPackage.tst | 13 + AttributeCategoryForCAP/tst/testall.g | 16 + makefile | 8 +- 46 files changed, 1394 insertions(+), 564 deletions(-) create mode 100644 ActionsForCAP/.gitignore create mode 100644 ActionsForCAP/LICENSE rename ActionsForCAP/doc/{Intros.autodoc => Doc.autodoc} (100%) create mode 100644 ActionsForCAP/makedoc_with_overfull_hbox_warnings.g create mode 100644 ActionsForCAP/tst/100_LoadPackage.tst create mode 100644 AttributeCategoryForCAP/.gitignore create mode 100644 AttributeCategoryForCAP/LICENSE rename AttributeCategoryForCAP/doc/{Intros.autodoc => Doc.autodoc} (100%) create mode 100644 AttributeCategoryForCAP/makedoc_with_overfull_hbox_warnings.g create mode 100644 AttributeCategoryForCAP/tst/100_LoadPackage.tst create mode 100644 AttributeCategoryForCAP/tst/testall.g diff --git a/ActionsForCAP/.gitignore b/ActionsForCAP/.gitignore new file mode 100644 index 0000000000..217d7e1777 --- /dev/null +++ b/ActionsForCAP/.gitignore @@ -0,0 +1,34 @@ +/doc/chap*.html +/doc/chap*.txt +/doc/*.css +/doc/*.js +/doc/chooser.html +/doc/*.aux +/doc/*.bbl +/doc/*.blg +/doc/*.brf +/doc/*.idx +/doc/*.ilg +/doc/*.ind +/doc/*.lab +/doc/*.log +/doc/*.out +/doc/*.pnr +/doc/*.six +/doc/*.tex +/doc/*.toc +/doc/manual.pdf +/doc/_*.xml + +/bin/ +/gen/ +/Makefile + +/tmp/ +/gh-pages/ + +/coverage.json +/doc/*.xml +/doc_tmp/ +/stats +/tst/actionsforcap*.tst diff --git a/ActionsForCAP/LICENSE b/ActionsForCAP/LICENSE new file mode 100644 index 0000000000..d159169d10 --- /dev/null +++ b/ActionsForCAP/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/ActionsForCAP/PackageInfo.g b/ActionsForCAP/PackageInfo.g index b36750aae2..f8e2391c9a 100644 --- a/ActionsForCAP/PackageInfo.g +++ b/ActionsForCAP/PackageInfo.g @@ -1,4 +1,4 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # ActionsForCAP: Actions and Coactions for CAP # # This file contains package meta data. For additional information on diff --git a/ActionsForCAP/doc/Intros.autodoc b/ActionsForCAP/doc/Doc.autodoc similarity index 100% rename from ActionsForCAP/doc/Intros.autodoc rename to ActionsForCAP/doc/Doc.autodoc diff --git a/ActionsForCAP/doc/clean b/ActionsForCAP/doc/clean index 6b5ae94601..ffe1f90868 100755 --- a/ActionsForCAP/doc/clean +++ b/ActionsForCAP/doc/clean @@ -1,4 +1,2 @@ -#!/bin/bash -rm -f *.{six,aux,lab,log,dvi,ps,pdf,bbl,ilg,ind,idx,out,html,tex,pnr,txt,blg,toc,six,brf,xml,xml.bib,css,js} -rm -f ../maketest.g ../VERSION ../public_html.version - +#!/bin/sh +rm -f *.{aux,bbl,blg,brf,css,html,idx,ilg,ind,js,lab,log,out,pdf,pnr,six,tex,toc,txt,xml,xml.bib} diff --git a/ActionsForCAP/examples/ActionsTest.g b/ActionsForCAP/examples/ActionsTest.g index 5eb67fa939..b472b05029 100644 --- a/ActionsForCAP/examples/ActionsTest.g +++ b/ActionsForCAP/examples/ActionsTest.g @@ -1,8 +1,22 @@ -LoadPackage( "ActionsForCAP" ); -LoadPackage( "LinearAlgebraForCAP" ); -Q := HomalgFieldOfRationals(); -vec := MatrixCategory( Q ); -u := TensorUnit( vec ); +#! @Chapter Examples and tests + +#! @Section Tests + +#! @Example + +LoadPackage( "ActionsForCAP", false ); +#! true +LoadPackage( "LinearAlgebraForCAP", false ); +#! true + +Q := HomalgFieldOfRationals();; +vec := MatrixCategory( Q );; +u := TensorUnit( vec );; cat := LeftActionsCategory( u ); +#! Category of left actions of V := VectorSpaceObject( 2, Q ); +#! alpha := VectorSpaceMorphism( TensorProductOnObjects( u, V ), HomalgMatrix( [ [ 0, 1 ], [ -1, 0 ] ], 2, 2, Q ), V ); +#! + +#! @EndExample diff --git a/ActionsForCAP/examples/CategoryWithAttributesTest.g b/ActionsForCAP/examples/CategoryWithAttributesTest.g index 7e29769b74..f23d3895fb 100644 --- a/ActionsForCAP/examples/CategoryWithAttributesTest.g +++ b/ActionsForCAP/examples/CategoryWithAttributesTest.g @@ -1,116 +1,105 @@ -LoadPackage( "ActionsForCAP" ); -LoadPackage( "LinearAlgebraForCAP" ); +#! @Chapter Examples and tests + +#! @Section Tests + +#! @Example + +LoadPackage( "ActionsForCAP", false ); +#! true +LoadPackage( "LinearAlgebraForCAP", false ); +#! true ## Category and Type of Objects ## DeclareCategory( "IsObjectWithEndo", - IsCategoryWithAttributesObject ); + IsCategoryWithAttributesObject );; DeclareRepresentation( "IsObjectWithEndoRep", IsObjectWithEndo and IsAttributeStoringRep, - [ ] ); + [ ] );; BindGlobal( "TheFamilyOfObjectsWithEndo", - NewFamily( "TheFamilyOfObjectsWithEndo" ) ); + NewFamily( "TheFamilyOfObjectsWithEndo" ) );; BindGlobal( "TheTypeOfObjectsWithEndo", NewType( TheFamilyOfObjectsWithEndo, - IsObjectWithEndoRep ) ); + IsObjectWithEndoRep ) );; ## Category and Type of Morphisms ## DeclareCategory( "IsMorphismWithEndo", - IsCategoryWithAttributesMorphism ); + IsCategoryWithAttributesMorphism );; DeclareRepresentation( "IsMorphismWithEndoRep", IsMorphismWithEndo and IsAttributeStoringRep, - [ ] ); + [ ] );; BindGlobal( "TheFamilyOfMorphismsWithEndo", - NewFamily( "TheFamilyOfMorphismsWithEndo" ) ); + NewFamily( "TheFamilyOfMorphismsWithEndo" ) );; BindGlobal( "TheTypeOfMorphismsWithEndo", NewType( TheFamilyOfMorphismsWithEndo, - IsMorphismWithEndoRep ) ); + IsMorphismWithEndoRep ) );; ## -Q := HomalgFieldOfRationals(); -vec := MatrixCategory( Q ); - -category_with_endo_record := rec( - underlying_category := vec, - object_type := TheTypeOfObjectsWithEndo, - morphism_type := TheTypeOfMorphismsWithEndo, - - ZeroObject := +Q := HomalgFieldOfRationals();; +vec := MatrixCategory( Q );; + +category_with_endo_record := rec( );; + +category_with_endo_record.underlying_category := vec;; +category_with_endo_record.object_type := TheTypeOfObjectsWithEndo;; +category_with_endo_record.morphism_type := TheTypeOfMorphismsWithEndo;; + +category_with_endo_record.ZeroObject := function( zero_object ) - return [ IdentityMorphism( zero_object ) ]; - - end, - - DirectSum := + return [ IdentityMorphism( zero_object ) ]; end;; + +category_with_endo_record.DirectSum := function( obj_list, underlying_direct_sum ) - local attr_list; - - attr_list := List( obj_list, obj -> ObjectAttributesAsList( obj )[1] ); - return [ DirectSumFunctorial( attr_list ) ]; - end, - - Lift := + return [ DirectSumFunctorial( List( obj_list, obj -> ObjectAttributesAsList( obj )[1] ) ) ]; end;; + +category_with_endo_record.Lift := function( mono, range ) - local range_endo, composition; - - range_endo := ObjectAttributesAsList( range )[1]; - - composition := PreCompose( mono, range_endo ); - return [ LiftAlongMonomorphism( mono, composition ) ]; - - end, - - Colift := + return [ LiftAlongMonomorphism( mono, PreCompose( mono, ObjectAttributesAsList( range )[1] ) ) ]; end;; + +category_with_endo_record.Colift := function( epi, source ) - local source_endo, composition; - - source_endo := ObjectAttributesAsList( source )[1]; - composition := PreCompose( source_endo, epi ); - - return [ ColiftAlongEpimorphism( epi, composition ) ]; - end, - - TensorProductOnObjects := + return [ ColiftAlongEpimorphism( epi, PreCompose( ObjectAttributesAsList( source )[1], epi ) ) ]; end;; + +category_with_endo_record.TensorProductOnObjects := function( obj1, obj2, underlying_tensor_product ) - local endo1, endo2; - - endo1 := ObjectAttributesAsList( obj1 )[1]; - endo2 := ObjectAttributesAsList( obj2 )[1]; - - return [ TensorProductOnMorphisms( endo1, endo2 ) ]; - - end, - - TensorUnit := + return [ TensorProductOnMorphisms( ObjectAttributesAsList( obj1 )[1], ObjectAttributesAsList( obj2 )[1] ) ]; end;; + +category_with_endo_record.TensorUnit := function( unit ) - - return [ IdentityMorphism( unit ) ]; - - end -); + + return [ IdentityMorphism( unit ) ]; end;; -triple := EnhancementWithAttributes( category_with_endo_record ); +triple := EnhancementWithAttributes( category_with_endo_record );; endo_cat := triple[1]; +#! Category with attributes of Category of matrices over Q ## not finalized yet ObjConstr := triple[2]; +#! function( object, attributes ) ... end V := VectorSpaceObject( 3, Q ); +#! endV := IdentityMorphism( V ); +#! VwithEndo := ObjConstr( V, [ endV ] ); +#! MorConstr := triple[3]; +#! function( source, morphism, range ) ... end alpha := MorConstr( VwithEndo, VectorSpaceMorphism( V, HomalgMatrix( [ [ 1, -1, 1 ], [ 1, 1, 1 ], [ 0, 0 , 0 ] ], 3, 3, Q ), V ), VwithEndo ); +#! + +#! @EndExample diff --git a/ActionsForCAP/examples/IndirectionTest.g b/ActionsForCAP/examples/IndirectionTest.g index bb2e6beded..7ecc1eee5a 100644 --- a/ActionsForCAP/examples/IndirectionTest.g +++ b/ActionsForCAP/examples/IndirectionTest.g @@ -1,40 +1,54 @@ -LoadPackage( "ModulePresentationsForCAP" ); -LoadPackage( "HomologicalAlgebraForCAP" ); -LoadPackage( "RingsForHomalg" ); -LoadPackage( "ActionsForCAP" ); +#! @Chapter Examples and tests + +#! @Section Tests + +#! @Example + +LoadPackage( "ModulePresentationsForCAP", false ); +#! true +LoadPackage( "HomologicalAlgebraForCAP", false ); +#! true +LoadPackage( "RingsForHomalg", false ); +#! true +LoadPackage( "IO_ForHomalg", false ); +#! true +LoadPackage( "ActionsForCAP", false ); +#! true + +HOMALG_IO.show_banners := false;; ## ## Category and Type of Objects ## DeclareCategory( "IsModuleWithAttribute", - IsCategoryWithAttributesObject ); + IsCategoryWithAttributesObject );; DeclareRepresentation( "IsModuleWithAttributeRep", IsModuleWithAttribute and IsAttributeStoringRep, - [ ] ); + [ ] );; BindGlobal( "TheFamilyOfModulesWithAttribute", - NewFamily( "TheFamilyOfModulesWithAttribute" ) ); + NewFamily( "TheFamilyOfModulesWithAttribute" ) );; BindGlobal( "TheTypeOfModulesWithAttribute", NewType( TheFamilyOfModulesWithAttribute, - IsModuleWithAttributeRep ) ); + IsModuleWithAttributeRep ) );; ## Category and Type of Morphisms ## DeclareCategory( "IsModuleMorphismWithAttribute", - IsCategoryWithAttributesMorphism ); + IsCategoryWithAttributesMorphism );; DeclareRepresentation( "IsModuleMorphismWithAttributeRep", IsModuleMorphismWithAttribute and IsAttributeStoringRep, - [ ] ); + [ ] );; BindGlobal( "TheFamilyOfModuleMorphismsWithAttribute", - NewFamily( "TheFamilyOfModuleMorphismsWithAttribute" ) ); + NewFamily( "TheFamilyOfModuleMorphismsWithAttribute" ) );; BindGlobal( "TheTypeOfModuleMorphismsWithAttribute", NewType( TheFamilyOfModuleMorphismsWithAttribute, - IsModuleMorphismWithAttributeRep ) ); + IsModuleMorphismWithAttributeRep ) );; ## @@ -42,8 +56,8 @@ BindGlobal( "TheTypeOfModuleMorphismsWithAttribute", QQ := HomalgFieldOfRationalsInSingular( );; R := QQ * "x,y"; #! Q[x,y] -SetRecursionTrapInterval( 10000 ); -category := LeftPresentations( R ); +SetRecursionTrapInterval( 10000 );; +category := LeftPresentations( R );; category_with_attributes_record := rec( underlying_category := category, @@ -51,123 +65,93 @@ category_with_attributes_record := rec( morphism_type := TheTypeOfModuleMorphismsWithAttribute, ZeroObject := - function( zero_object ) - - return [ "a string for indirection" ]; - - end, + { zero_object } -> [ "a string for indirection" ], DirectSum := - function( obj_list, underlying_direct_sum ) - - return [ "a string for indirection" ]; - - end, + { obj_list, underlying_direct_sum } -> [ "a string for indirection" ], KernelObject := - function( diagram, underlying_kernel_object ) - - return [ "a string for indirection" ]; - - end, + { diagram, underlying_kernel_object } -> [ "a string for indirection" ], ImageObject := - function( diagram, underlying_image_object ) - - return [ "a string for indirection" ]; - - end, + { diagram, underlying_image_object } -> [ "a string for indirection" ], FiberProduct := - function( diagram, underlying_fiber_product ) - - return [ "a string for indirection" ]; - - end, + { diagram, underlying_fiber_product } -> [ "a string for indirection" ], CokernelObject := - function( diagram, underlying_cokernel_object ) - - return [ "a string for indirection" ]; - - end, + { diagram, underlying_cokernel_object } -> [ "a string for indirection" ], CoimageObject := - function( diagram, underlying_coimage_object ) - - return [ "a string for indirection" ]; - - end, + { diagram, underlying_coimage_object } -> [ "a string for indirection" ], Pushout := - function( diagram, underlying_pushout_object ) - - return [ "a string for indirection" ]; - - end, -); -triple := EnhancementWithAttributes( category_with_attributes_record ); -indirection_category := triple[1]; -SetIsAbelianCategory( indirection_category, true ); -AddIsEqualForCacheForObjects( indirection_category, IsIdenticalObj ); -AddIsEqualForObjects( indirection_category, function( obj1, obj2 ) return UnderlyingCell( obj1 ) = UnderlyingCell( obj2 ); end ); -AddIsEqualForCacheForMorphisms( indirection_category, IsIdenticalObj ); -AddIsEqualForMorphisms( indirection_category, IsIdenticalObj ); -AddIsCongruentForMorphisms( indirection_category, function( mor1, mor2 ) return UnderlyingCell( mor1 ) = UnderlyingCell( mor2 ); end ); -Finalize( indirection_category ); -Object_Constructor := triple[2]; -Morphism_Constructor := triple[3]; - - -#! Category of left presentations of Q[x,y] -S := Object_Constructor( FreeLeftPresentation( 1, R ), [ "a string for indirection" ] ); + { diagram, underlying_pushout_object } -> [ "a string for indirection" ], +);; +triple := EnhancementWithAttributes( category_with_attributes_record );; +indirection_category := triple[1];; +SetIsAbelianCategory( indirection_category, true );; +AddIsEqualForCacheForObjects( indirection_category, IsIdenticalObj );; +AddIsEqualForObjects( indirection_category, function( obj1, obj2 ) return UnderlyingCell( obj1 ) = UnderlyingCell( obj2 ); end );; +AddIsEqualForCacheForMorphisms( indirection_category, IsIdenticalObj );; +AddIsEqualForMorphisms( indirection_category, IsIdenticalObj );; +AddIsCongruentForMorphisms( indirection_category, function( mor1, mor2 ) return UnderlyingCell( mor1 ) = UnderlyingCell( mor2 ); end );; +Finalize( indirection_category );; +Object_Constructor := triple[2];; +Morphism_Constructor := triple[3];; + -#! +S := Object_Constructor( FreeLeftPresentation( 1, R ), [ "a string for indirection" ] ); +#! object_func := function( i ) return S; end; #! function( i ) ... end morphism_func := function( i ) return IdentityMorphism( S ); end; #! function( i ) ... end C0 := ZFunctorObjectExtendedByInitialAndIdentity( object_func, morphism_func, indirection_category, 0, 4 ); -#! +#! S2 := Object_Constructor( FreeLeftPresentation( 2, R ), [ "a string for indirection" ] ); -#! +#! C1 := ZFunctorObjectFromMorphismList( [ InjectionOfCofactorOfDirectSum( [ S2, S ], 1 ) ], 2 ); -#! +#! C1 := ZFunctorObjectExtendedByInitialAndIdentity( C1, 2, 3 ); -#! +#! C2 := ZFunctorObjectFromMorphismList( [ InjectionOfCofactorOfDirectSum( [ S, S ], 1 ) ], 3 ); -#! +#! C2 := ZFunctorObjectExtendedByInitialAndIdentity( C2, 3, 4 ); -#! +#! delta_1_3 := PresentationMorphism( UnderlyingCell( C1[3] ), HomalgMatrix( [ [ "x^2" ], [ "xy" ], [ "y^3"] ], 3, 1, R ), UnderlyingCell( C0[3] ) ); -delta_1_3 := Morphism_Constructor( C1[3], delta_1_3, C0[3] ); #! +delta_1_3 := Morphism_Constructor( C1[3], delta_1_3, C0[3] ); +#! delta_1_2 := PresentationMorphism( UnderlyingCell( C1[2] ), HomalgMatrix( [ [ "x^2" ], [ "xy" ] ], 2, 1, R ), UnderlyingCell( C0[2] ) ); -delta_1_2 := Morphism_Constructor( C1[2], delta_1_2, C0[2] ); #! +delta_1_2 := Morphism_Constructor( C1[2], delta_1_2, C0[2] ); +#! delta1 := ZFunctorMorphism( C1, [ UniversalMorphismFromInitialObject( C0[1] ), UniversalMorphismFromInitialObject( C0[1] ), delta_1_2, delta_1_3 ], 0, C0 ); -#! +#! delta1 := ZFunctorMorphismExtendedByInitialAndIdentity( delta1, 0, 3 ); -#! +#! delta1 := AsAscendingFilteredMorphism( delta1 ); -#! +#! delta_2_3 := PresentationMorphism( UnderlyingCell( C2[3] ), HomalgMatrix( [ [ "y", "-x", "0" ] ], 1, 3, R ), UnderlyingCell( C1[3] ) ); -delta_2_3 := Morphism_Constructor( C2[3], delta_2_3, C1[3] ); #! +delta_2_3 := Morphism_Constructor( C2[3], delta_2_3, C1[3] ); +#! delta_2_4 := PresentationMorphism( UnderlyingCell( C2[4] ), HomalgMatrix( [ [ "y", "-x", "0" ], [ "0", "y^2", "-x" ] ], 2, 3, R ), UnderlyingCell( C1[4] ) ); -delta_2_4 := Morphism_Constructor( C2[4], delta_2_4, C1[4] ); #! +delta_2_4 := Morphism_Constructor( C2[4], delta_2_4, C1[4] ); +#! delta2 := ZFunctorMorphism( C2, [ UniversalMorphismFromInitialObject( C1[2] ), delta_2_3, delta_2_4 ], 2, C1 ); -#! +#! delta2 := ZFunctorMorphismExtendedByInitialAndIdentity( delta2, 2, 4 ); -#! +#! delta2 := AsAscendingFilteredMorphism( delta2 ); -#! +#! SetIsAdditiveCategory( CategoryOfAscendingFilteredObjects( indirection_category ), true ); complex := ZFunctorObjectFromMorphismList( [ delta2, delta1 ], -2 ); -#! +#! complex := AsComplex( complex ); -#! +#! LessGenFunctor := FunctorLessGeneratorsLeft( R ); #! Less generators for Category of left presentations of Q[x,y] @@ -180,7 +164,7 @@ ProfileFunctionsInGlobalVariables( false ); ProfileOperationsAndMethods( false ); ProfileGlobalFunctions( false ); # -DisplayProfile(); +#DisplayProfile(); # # # ProfileFunctionsInGlobalVariables( true ); @@ -193,41 +177,43 @@ DisplayProfile(); # # DisplayProfile(); # time; -# #! +# # # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, UnderlyingHonestObject( Source( s ) ) ) ) ); -# # #! (an empty 0 x 1 matrix) +# # # (an empty 0 x 1 matrix) # s := SpectralSequenceEntryOfAscendingFilteredComplex( complex, 1, 0, 0 ); # time; -# # #! +# # # # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, UnderlyingHonestObject( Source( s ) ) ) ) ); -# # #! (an empty 0 x 1 matrix) +# # # (an empty 0 x 1 matrix) # s := SpectralSequenceEntryOfAscendingFilteredComplex( complex, 2, 0, 0 ); # time; -# # #! +# # # # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, UnderlyingHonestObject( Source( s ) ) ) ) ); -# # #! (an empty 0 x 1 matrix) +# # # (an empty 0 x 1 matrix) # s := SpectralSequenceEntryOfAscendingFilteredComplex( complex, 3, 0, 0 ); # time; -# # #! +# # # # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, UnderlyingHonestObject( Source( s ) ) ) ) ); -# # #! x*y, -# # #! x^2 +# # # x*y, +# # # x^2 # s := SpectralSequenceEntryOfAscendingFilteredComplex( complex, 4, 0, 0 ); # time; -# # #! +# # # # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, UnderlyingHonestObject( Source( s ) ) ) ) ); -# # #! x*y, -# # #! x^2, -# # #! y^3 +# # # x*y, +# # # x^2, +# # # y^3 # s := SpectralSequenceEntryOfAscendingFilteredComplex( complex, 5, 0, 0 ); # time; -# # #! +# # # # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, UnderlyingHonestObject( Source( s ) ) ) ) ); -# # #! x*y, -# # #! x^2, -# # #! y^3 +# # # x*y, +# # # x^2, +# # # y^3 # s := SpectralSequenceDifferentialOfAscendingFilteredComplex( complex, 3, 3, -2 ); # time; -# #! +# # # Display( UnderlyingMatrix( ApplyFunctor( LessGenFunctor, s ) ) ); -# #! y^3 +# # y^3 + +#! @EndExample diff --git a/ActionsForCAP/examples/IndirectionTest2.g b/ActionsForCAP/examples/IndirectionTest2.g index e417f11f30..3b7fd14d8a 100644 --- a/ActionsForCAP/examples/IndirectionTest2.g +++ b/ActionsForCAP/examples/IndirectionTest2.g @@ -1,32 +1,31 @@ -LoadPackage( "LinearAlgebraForCAP" ); +#! @Chapter Examples and tests + +#! @Section Tests + +#! @Example + +LoadPackage( "LinearAlgebraForCAP", false ); +#! true DeclareRepresentation( "IsWrappedObjectRep", IsCapCategoryObjectRep, - [ ] ); - -BindGlobal( "TheTypeOfWrappedObjects", - NewType( TheFamilyOfCapCategoryObjects, - IsWrappedObjectRep ) ); + [ ] );; DeclareRepresentation( "IsWrappedMorphismRep", IsCapCategoryMorphismRep, - [ ] ); - -BindGlobal( "TheTypeOfWrappedMorphisms", - NewType( TheFamilyOfCapCategoryMorphisms, - IsWrappedMorphismRep ) ); + [ ] );; DeclareOperation( "WrappedObject", - [ IsCapCategoryObject ] ); + [ IsCapCategoryObject ] );; DeclareAttribute( "UnderlyingCell", - IsWrappedObjectRep ); + IsWrappedObjectRep );; DeclareOperation( "WrappedMorphism", - [ IsWrappedObjectRep, IsCapCategoryMorphism, IsWrappedObjectRep ] ); + [ IsWrappedObjectRep, IsCapCategoryMorphism, IsWrappedObjectRep ] );; DeclareAttribute( "UnderlyingCell", - IsWrappedMorphismRep ); + IsWrappedMorphismRep );; ################################# @@ -35,11 +34,15 @@ DeclareAttribute( "UnderlyingCell", ## ################################# -Q := HomalgFieldOfRationals(); +Q := HomalgFieldOfRationals();; -vec := MatrixCategory( Q ); +vec := MatrixCategory( Q );; wrapped_cat := CreateCapCategory( "Wrapped Category" ); +#! Wrapped Category + +AddObjectRepresentation( wrapped_cat, IsWrappedObjectRep ); +AddMorphismRepresentation( wrapped_cat, IsWrappedMorphismRep ); ################################# ## @@ -51,52 +54,44 @@ InstallMethod( WrappedObject, [ IsCapCategoryObject ], function( obj ) - local wrapped_obj; - - wrapped_obj := ObjectifyWithAttributes( rec( ), TheTypeOfWrappedObjects, - UnderlyingCell, obj - ); - - Add( wrapped_cat, wrapped_obj ); - return wrapped_obj; - -end ); + return ObjectifyObjectForCAPWithAttributes( + rec( ), wrapped_cat, + UnderlyingCell, obj + ); end ); InstallMethod( WrappedMorphism, - [ IsWrappedObjectRep, IsCapCategoryMorphism, IsWrappedObjectRep ], + [ IsWrappedObjectRep, IsCapCategoryMorphism, IsWrappedObjectRep ], function( source, morphism, range ) - local wrapped_morphism; - - wrapped_morphism := ObjectifyWithAttributes( rec( ), TheTypeOfWrappedMorphisms, - Source, source, - Range, range, - UnderlyingCell, morphism - ); - - Add( wrapped_cat, wrapped_morphism ); - - return wrapped_morphism; -end ); + return ObjectifyMorphismWithSourceAndRangeForCAPWithAttributes( + rec( ), wrapped_cat, + Source, source, + Range, range, + UnderlyingCell, morphism + ); end ); AddKernelEmbedding( wrapped_cat, function( diagram ) - local underlying_kernel_embedding; - underlying_kernel_embedding := KernelEmbedding( UnderlyingCell( diagram ) ); - - return WrappedMorphism( WrappedObject( Source( underlying_kernel_embedding ) ), - underlying_kernel_embedding, - Source( diagram ) ); - -end ); + # avoid semicolons so AutoDoc does not start a new statement + return ({ underlying_kernel_embedding } -> + WrappedMorphism( WrappedObject( Source( underlying_kernel_embedding ) ), + underlying_kernel_embedding, + Source( diagram ) ) + )(KernelEmbedding( UnderlyingCell( diagram ) )); end ); -Finalize( wrapped_cat ); +Finalize( wrapped_cat );; V := VectorSpaceObject( 3, Q ); +#! alpha := VectorSpaceMorphism( V, HomalgMatrix( [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 7, 8, 9 ] ], 3, 3, Q ), V ); +#! V_wrapped := WrappedObject( V ); +#! alpha_wrapped := WrappedMorphism( V_wrapped, alpha, V_wrapped ); +#! + +#! @EndExample diff --git a/ActionsForCAP/gap/ActionMorphisms.gd b/ActionsForCAP/gap/ActionMorphisms.gd index 56872960dd..03fbc09c11 100644 --- a/ActionsForCAP/gap/ActionMorphisms.gd +++ b/ActionsForCAP/gap/ActionMorphisms.gd @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #################################### ## @@ -49,4 +45,4 @@ DeclareAttribute( "UnderlyingActingObject", IsLeftOrRightActionMorphism ); DeclareAttribute( "UnderlyingMorphism", - IsLeftOrRightActionMorphism ); \ No newline at end of file + IsLeftOrRightActionMorphism ); diff --git a/ActionsForCAP/gap/ActionMorphisms.gi b/ActionsForCAP/gap/ActionMorphisms.gi index d08b94b841..5e4cbdf661 100644 --- a/ActionsForCAP/gap/ActionMorphisms.gi +++ b/ActionsForCAP/gap/ActionMorphisms.gi @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# DeclareRepresentation( "IsLeftActionMorphismRep", IsLeftActionMorphism and IsAttributeStoringRep, diff --git a/ActionsForCAP/gap/ActionObjects.gd b/ActionsForCAP/gap/ActionObjects.gd index a06ea56872..28dcd05e8c 100644 --- a/ActionsForCAP/gap/ActionObjects.gd +++ b/ActionsForCAP/gap/ActionObjects.gd @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #################################### ## @@ -59,4 +55,4 @@ DeclareAttribute( "ActionDomain", IsLeftOrRightActionObject ); DeclareAttribute( "UnderlyingCategory", - IsLeftOrRightActionObject ); \ No newline at end of file + IsLeftOrRightActionObject ); diff --git a/ActionsForCAP/gap/ActionObjects.gi b/ActionsForCAP/gap/ActionObjects.gi index b5b1f2a81b..0a0bf19555 100644 --- a/ActionsForCAP/gap/ActionObjects.gi +++ b/ActionsForCAP/gap/ActionObjects.gi @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# DeclareRepresentation( "IsLeftActionObjectRep", IsLeftActionObject and IsAttributeStoringRep, diff --git a/ActionsForCAP/gap/ActionsCategory.gd b/ActionsForCAP/gap/ActionsCategory.gd index 0e293cc709..5ebd70a00f 100644 --- a/ActionsForCAP/gap/ActionsCategory.gd +++ b/ActionsForCAP/gap/ActionsCategory.gd @@ -1,13 +1,9 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #! @Chapter Actions -## -############################################################################# #################################### ## @@ -45,4 +41,4 @@ DeclareGlobalFunction( "ADD_FUNCTIONS_FOR_ONLY_RIGHT_ACTIONS_CATEGORY" ); #################################### ## -DeclareAttribute( "UnderlyingActingObject", IsCapCategory ); \ No newline at end of file +DeclareAttribute( "UnderlyingActingObject", IsCapCategory ); diff --git a/ActionsForCAP/gap/ActionsCategory.gi b/ActionsForCAP/gap/ActionsCategory.gi index 6b420e40e8..9829b98561 100644 --- a/ActionsForCAP/gap/ActionsCategory.gi +++ b/ActionsForCAP/gap/ActionsCategory.gi @@ -1,13 +1,9 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# #! @Chapter Actions -## -############################################################################# #################################### ## diff --git a/ActionsForCAP/gap/CoactionMorphisms.gd b/ActionsForCAP/gap/CoactionMorphisms.gd index d6daeb78d5..50d416bff1 100644 --- a/ActionsForCAP/gap/CoactionMorphisms.gd +++ b/ActionsForCAP/gap/CoactionMorphisms.gd @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #################################### ## @@ -49,4 +45,4 @@ DeclareAttribute( "UnderlyingCoactingObject", IsLeftOrRightCoactionMorphism ); DeclareAttribute( "UnderlyingMorphism", - IsLeftOrRightCoactionMorphism ); \ No newline at end of file + IsLeftOrRightCoactionMorphism ); diff --git a/ActionsForCAP/gap/CoactionMorphisms.gi b/ActionsForCAP/gap/CoactionMorphisms.gi index d27a53678e..10e6c02a6b 100644 --- a/ActionsForCAP/gap/CoactionMorphisms.gi +++ b/ActionsForCAP/gap/CoactionMorphisms.gi @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# DeclareRepresentation( "IsLeftCoactionMorphismRep", IsLeftCoactionMorphism and IsAttributeStoringRep, diff --git a/ActionsForCAP/gap/CoactionObjects.gd b/ActionsForCAP/gap/CoactionObjects.gd index 31c164e4cc..d20d321efd 100644 --- a/ActionsForCAP/gap/CoactionObjects.gd +++ b/ActionsForCAP/gap/CoactionObjects.gd @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #################################### ## @@ -59,4 +55,4 @@ DeclareAttribute( "CoactionDomain", IsLeftOrRightCoactionObject ); DeclareAttribute( "UnderlyingCategory", - IsLeftOrRightCoactionObject ); \ No newline at end of file + IsLeftOrRightCoactionObject ); diff --git a/ActionsForCAP/gap/CoactionObjects.gi b/ActionsForCAP/gap/CoactionObjects.gi index fd56063862..e72ba69a04 100644 --- a/ActionsForCAP/gap/CoactionObjects.gi +++ b/ActionsForCAP/gap/CoactionObjects.gi @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# DeclareRepresentation( "IsLeftCoactionObjectRep", IsLeftCoactionObject and IsAttributeStoringRep, diff --git a/ActionsForCAP/gap/CoactionsCategory.gd b/ActionsForCAP/gap/CoactionsCategory.gd index 188aaedaf2..7e7b0f2e13 100644 --- a/ActionsForCAP/gap/CoactionsCategory.gd +++ b/ActionsForCAP/gap/CoactionsCategory.gd @@ -1,13 +1,9 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #! @Chapter Coactions -## -############################################################################# #################################### ## @@ -45,4 +41,4 @@ DeclareGlobalFunction( "ADD_FUNCTIONS_FOR_ONLY_RIGHT_COACTIONS_CATEGORY" ); #################################### ## -DeclareAttribute( "UnderlyingCoactingObject", IsCapCategory ); \ No newline at end of file +DeclareAttribute( "UnderlyingCoactingObject", IsCapCategory ); diff --git a/ActionsForCAP/gap/CoactionsCategory.gi b/ActionsForCAP/gap/CoactionsCategory.gi index adad48fe29..c271508416 100644 --- a/ActionsForCAP/gap/CoactionsCategory.gi +++ b/ActionsForCAP/gap/CoactionsCategory.gi @@ -1,12 +1,8 @@ -############################################################################# -## -## ActionsForCAP package -## -## Copyright 2015, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# #################################### ## diff --git a/ActionsForCAP/gap/SemisimpleCategory.gd b/ActionsForCAP/gap/SemisimpleCategory.gd index 8c601029c9..1ec23b4fdf 100644 --- a/ActionsForCAP/gap/SemisimpleCategory.gd +++ b/ActionsForCAP/gap/SemisimpleCategory.gd @@ -1,13 +1,9 @@ -############################################################################ -## -## ActionsForCAP package -## -## Copyright 2016, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Declarations +# #! @Chapter Semisimple Categories -## -############################################################################# #################################### ## diff --git a/ActionsForCAP/gap/SemisimpleCategory.gi b/ActionsForCAP/gap/SemisimpleCategory.gi index f36f39b3bb..4e907bab41 100644 --- a/ActionsForCAP/gap/SemisimpleCategory.gi +++ b/ActionsForCAP/gap/SemisimpleCategory.gi @@ -1,13 +1,9 @@ -############################################################################ -## -## ActionsForCAP package -## -## Copyright 2016, Sebastian Gutsche, TU Kaiserslautern -## Sebastian Posur, RWTH Aachen -## +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# Implementations +# #! @Chapter Semisimple Categories -## -############################################################################# #################################### ## diff --git a/ActionsForCAP/init.g b/ActionsForCAP/init.g index bdce86a973..5807dd3247 100644 --- a/ActionsForCAP/init.g +++ b/ActionsForCAP/init.g @@ -1,4 +1,4 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # ActionsForCAP: Actions and Coactions for CAP # # Reading the declaration part of the package. diff --git a/ActionsForCAP/makedoc.g b/ActionsForCAP/makedoc.g index 00c10244d6..e8bb0d482f 100644 --- a/ActionsForCAP/makedoc.g +++ b/ActionsForCAP/makedoc.g @@ -1,24 +1,31 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # ActionsForCAP: Actions and Coactions for CAP # -LoadPackage( "AutoDoc" ); - -AutoDoc( "ActionsForCAP" : scaffold := true, autodoc := - rec( files := [ "doc/Intros.autodoc" ], - scan_dirs := [ "gap", "examples", "doc" ] ), - maketest := rec( folder := ".", - commands := - [ "LoadPackage( \"CAP\" );", - "LoadPackage( \"IO_ForHomalg\" );", - "LoadPackage( \"GaussForHomalg\" );", - "LoadPackage( \"LinearAlgebraForCAP\" );", - "LoadPackage( \"ActionsForCAP\" );", - "HOMALG_IO.show_banners := false;", - "HOMALG_IO.suppress_PID := true;", - "HOMALG_IO.use_common_stream := true;", - ] - ) -); +# This file is a script which compiles the package manual. +# +if fail = LoadPackage( "AutoDoc", "2019.05.20" ) then + + Error( "AutoDoc version 2019.05.20 or newer is required." ); + +fi; +AutoDoc( rec( + autodoc := rec( + files := [ "doc/Doc.autodoc" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc" ], + ), + extract_examples := rec( + units := "Single", + ), + gapdoc := rec( + LaTeXOptions := rec( + LateExtraPreamble := """ + """, + ), + ), + scaffold := rec( + entities := [ "homalg", "CAP" ], + ), +) ); QUIT; diff --git a/ActionsForCAP/makedoc_with_overfull_hbox_warnings.g b/ActionsForCAP/makedoc_with_overfull_hbox_warnings.g new file mode 100644 index 0000000000..b6cef58527 --- /dev/null +++ b/ActionsForCAP/makedoc_with_overfull_hbox_warnings.g @@ -0,0 +1,42 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# This file is a script which compiles the package manual and prints overfull hbox warnings. +# +if fail = LoadPackage( "AutoDoc", "2019.05.20" ) then + + Error( "AutoDoc version 2019.05.20 or newer is required." ); + +fi; + +AutoDoc( rec( + dir := "doc_tmp/", + autodoc := rec( + files := [ "doc/Doc.autodoc" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc" ], + ), + gapdoc := rec( + LaTeXOptions := rec( + LateExtraPreamble := """ + % Many thanks to https://tex.stackexchange.com/questions/22466/how-to-convince-fancyvrb-to-give-overfull-warnings/534486#534486 + \makeatletter + \def\FV@ListProcessLine#1{% + \hbox to \hsize{% + \kern\leftmargin + \hbox to \linewidth{% + \FV@LeftListNumber + \FV@LeftListFrame + \FancyVerbFormatLine{#1}\hfil % change \hss to \hfil + \FV@RightListFrame + \FV@RightListNumber}% + \hss}} + \makeatother + """, + ), + ), + scaffold := rec( + entities := [ "homalg", "CAP" ], + ), +) ); + +QUIT; diff --git a/ActionsForCAP/makefile b/ActionsForCAP/makefile index d36dc753ae..756b13d41e 100644 --- a/ActionsForCAP/makefile +++ b/ActionsForCAP/makefile @@ -1,37 +1,57 @@ +# make sure gap --quitonbreak fails even if it is part of a pipe +SHELL=/bin/bash -o pipefail + all: doc test doc: doc/manual.six doc/manual.six: makedoc.g \ PackageInfo.g \ - doc/Intros.autodoc \ - gap/*.gd gap/*.gi examples/*.g* - gap makedoc.g + $(wildcard doc/*.autodoc gap/*.gd gap/*.gi examples/*.g examples/*/*.g) + gap makedoc.g clean: (cd doc ; ./clean) -test: doc - gap maketest.g - -archive: test - (mkdir -p ../tar; cd ..; tar czvf tar/CAP.tar.gz --exclude ".DS_Store" --exclude "*~" CAP/doc/*.* CAP/doc/clean CAP/gap/*.{gi,gd} CAP/{PackageInfo.g,README,COPYING,VERSION,init.g,read.g,makedoc.g,makefile,maketest.g} CAP/examples/*.g CAP/examples/doc/*.g) - -#WEBPOS=public_html -#WEBPOS_FINAL=~/Sites/homalg-project/CAP - -towww: archive - echo '' >${WEBPOS}.version - echo '' >>${WEBPOS}.version - cat VERSION >>${WEBPOS}.version - echo '' >>${WEBPOS}.version - cp PackageInfo.g ${WEBPOS} - cp README ${WEBPOS}/README.CAP - cp doc/manual.pdf ${WEBPOS}/CAP.pdf - cp doc/*.{css,html} ${WEBPOS} - rm -f ${WEBPOS}/*.tar.gz - mv ../tar/CAP.tar.gz ${WEBPOS}/CAP-`cat VERSION`.tar.gz - rm -f ${WEBPOS_FINAL}/*.tar.gz - cp ${WEBPOS}/* ${WEBPOS_FINAL} - ln -s CAP-`cat VERSION`.tar.gz ${WEBPOS_FINAL}/CAP.tar.gz - +test: doc + gap tst/testall.g + +test-basic-spacing: + grep -RPl "\t" examples/ gap/ && echo "Tabs found" && exit 1 || exit 0 + grep -RPl "\r" examples/ gap/ && echo "Windows line-endings found" && exit 1 || exit 0 + # the second grep is a hack to fix the exit code with -L for grep <= 3.1 + grep -RPzL "\n\z" examples/ gap/ | grep "" && echo "File with no newline at end of file found" && exit 1 || exit 0 + +test-doc: doc + cp -aT doc/ doc_tmp/ + cd doc_tmp && ./clean + gap --quitonbreak makedoc_with_overfull_hbox_warnings.g | perl -pe 'END { exit $$status } $$status=1 if /#W/;' + +test-with-coverage: doc + gap --quitonbreak --cover stats tst/testall.g + echo 'LoadPackage("profiling"); OutputJsonCoverage("stats", "coverage.json");' | gap --quitonbreak + +test-spacing: + grep -R "[^ [\"] " gap/*.gi && echo "Duplicate spaces found" && exit 1 || exit 0 + grep -RE '[^ ] +$$' gap/* && echo "Trailing whitespace found" && exit 1 || exit 0 + for filename in gap/*; do \ + echo $$filename; \ + echo "LoadPackage(\"ActionsForCAP\"); SizeScreen([4096]); func := ReadAsFunction(\"$$filename\"); FileString(\"gap_spacing\", DisplayString(func));" | gap --quitonbreak --banner; \ + echo -e "\033[0m"; \ + # In a perfect world, the DisplayString of a function would exactly match our code. However, our line breaks and indentation might differ from the GAP ones, \ + # so we remove all indentation, line breaks, and empty lines, and afterwards insert line breaks at semicolons again for better readability. \ + cat "gap_spacing" | tail -n +2 | head -n -2 | sed 's/\[ \]/[ ]/g' | sed 's/( )/( )/g' | sed 's/( :/( :/g' | sed 's/ *$$//' | sed 's/^ *//' | grep -v "^$$" | tr "\n" " " | sed 's/;/;\n/g' > modified_gap_spacing; \ + cat "$$filename" | grep -v "^ *[#]" | sed 's/^ *//' | grep -v "^$$" | tr "\n" " " | sed "s/;/;\n/g" > modified_custom_spacing; \ + # Our code might still differ from the GAP code, for example because of additional brackets. \ + # Thus, we diff the code once as expected and once ignoring all space. Diffing the two diffs then shows lines which only differ by spacing. \ + diff modified_gap_spacing modified_custom_spacing > spacing_diff; \ + diff modified_gap_spacing modified_custom_spacing --ignore-all-space --ignore-space-change --ignore-trailing-space --ignore-blank-lines > spacing_diff_no_blanks; \ + diff spacing_diff_no_blanks spacing_diff || exit; \ + done + rm gap_spacing + rm modified_gap_spacing + rm modified_custom_spacing + rm spacing_diff + rm spacing_diff_no_blanks + +ci-test: test-basic-spacing test-with-coverage diff --git a/ActionsForCAP/read.g b/ActionsForCAP/read.g index 4e84db550c..6b3a3c2eb9 100644 --- a/ActionsForCAP/read.g +++ b/ActionsForCAP/read.g @@ -1,4 +1,4 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # ActionsForCAP: Actions and Coactions for CAP # # Reading the implementation part of the package. diff --git a/ActionsForCAP/tst/100_LoadPackage.tst b/ActionsForCAP/tst/100_LoadPackage.tst new file mode 100644 index 0000000000..6a9edeb2e2 --- /dev/null +++ b/ActionsForCAP/tst/100_LoadPackage.tst @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# ActionsForCAP: Actions and Coactions for CAP +# +# This file tests if the package can be loaded without errors or warnings. +# +gap> package_loading_info_level := InfoLevel( InfoPackageLoading );; +gap> SetInfoLevel( InfoPackageLoading, PACKAGE_ERROR );; +gap> LoadPackage( "ActionsForCAP", false ); +true +gap> SetInfoLevel( InfoPackageLoading, PACKAGE_INFO );; +gap> LoadPackage( "ActionsForCAP" ); +true +gap> SetInfoLevel( InfoPackageLoading, package_loading_info_level );; diff --git a/ActionsForCAP/tst/testall.g b/ActionsForCAP/tst/testall.g index 8a838eb71a..17b4bd37cc 100644 --- a/ActionsForCAP/tst/testall.g +++ b/ActionsForCAP/tst/testall.g @@ -1,33 +1,16 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # ActionsForCAP: Actions and Coactions for CAP # # This file runs package tests. It is also referenced in the package # metadata in PackageInfo.g. # -LoadPackage( "ActionsForCAP" ); -dirs := DirectoriesPackageLibrary( "ActionsForCAP", "tst" ); - -HasSuffix := function(list, suffix) - local len; - len := Length(list); - if Length(list) < Length(suffix) then return false; fi; - return list{[len-Length(suffix)+1..len]} = suffix; -end; - -# Load all tests in that directory -tests := DirectoryContents(dirs[1]); -tests := Filtered(tests, name -> HasSuffix(name, ".tst")); -Sort(tests); +options := rec( + exitGAP := true, + testOptions := rec( + compareFunction := "uptowhitespace", + ), +); -# Convert tests to filenames -tests := List(tests, test -> Filename(dirs,test)); +TestDirectory( DirectoriesPackageLibrary( "ActionsForCAP", "tst" ), options ); -# Run the tests -for test in tests do - Print("Running test '",test,"'\n"); - if Test(test, rec(compareFunction := "uptowhitespace")) then - Print("Test '",test,"' succeeded\n"); - else - Print("Test '",test,"' failed\n"); - fi; -od; +FORCE_QUIT_GAP( 1 ); # if we ever get here, there was an error diff --git a/AttributeCategoryForCAP/.gitignore b/AttributeCategoryForCAP/.gitignore new file mode 100644 index 0000000000..04f7a14665 --- /dev/null +++ b/AttributeCategoryForCAP/.gitignore @@ -0,0 +1,34 @@ +/doc/chap*.html +/doc/chap*.txt +/doc/*.css +/doc/*.js +/doc/chooser.html +/doc/*.aux +/doc/*.bbl +/doc/*.blg +/doc/*.brf +/doc/*.idx +/doc/*.ilg +/doc/*.ind +/doc/*.lab +/doc/*.log +/doc/*.out +/doc/*.pnr +/doc/*.six +/doc/*.tex +/doc/*.toc +/doc/manual.pdf +/doc/_*.xml + +/bin/ +/gen/ +/Makefile + +/tmp/ +/gh-pages/ + +/coverage.json +/doc/*.xml +/doc_tmp/ +/stats +/tst/attributecategoryforcap*.tst diff --git a/AttributeCategoryForCAP/LICENSE b/AttributeCategoryForCAP/LICENSE new file mode 100644 index 0000000000..d159169d10 --- /dev/null +++ b/AttributeCategoryForCAP/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/AttributeCategoryForCAP/PackageInfo.g b/AttributeCategoryForCAP/PackageInfo.g index 0d32946147..9a43c85f37 100644 --- a/AttributeCategoryForCAP/PackageInfo.g +++ b/AttributeCategoryForCAP/PackageInfo.g @@ -1,4 +1,4 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category # # This file contains package meta data. For additional information on diff --git a/AttributeCategoryForCAP/doc/Intros.autodoc b/AttributeCategoryForCAP/doc/Doc.autodoc similarity index 100% rename from AttributeCategoryForCAP/doc/Intros.autodoc rename to AttributeCategoryForCAP/doc/Doc.autodoc diff --git a/AttributeCategoryForCAP/doc/clean b/AttributeCategoryForCAP/doc/clean index 6b5ae94601..ffe1f90868 100755 --- a/AttributeCategoryForCAP/doc/clean +++ b/AttributeCategoryForCAP/doc/clean @@ -1,4 +1,2 @@ -#!/bin/bash -rm -f *.{six,aux,lab,log,dvi,ps,pdf,bbl,ilg,ind,idx,out,html,tex,pnr,txt,blg,toc,six,brf,xml,xml.bib,css,js} -rm -f ../maketest.g ../VERSION ../public_html.version - +#!/bin/sh +rm -f *.{aux,bbl,blg,brf,css,html,idx,ilg,ind,js,lab,log,out,pdf,pnr,six,tex,toc,txt,xml,xml.bib} diff --git a/AttributeCategoryForCAP/examples/example.g b/AttributeCategoryForCAP/examples/example.g index 71b3b545a3..31bc075183 100644 --- a/AttributeCategoryForCAP/examples/example.g +++ b/AttributeCategoryForCAP/examples/example.g @@ -1,62 +1,70 @@ +#! @Chapter Examples and tests + +#! @Section Tests + +#! @Example + ## As an example for the usage of the attribute category, ## we install the category of pairs ( A, alpha: A -> A ) ## consisting of an object equipped with an endomorphism. -LoadPackage( "AttributeCategoryForCAP" ); -LoadPackage( "LinearAlgebraForCAP" ); +LoadPackage( "AttributeCategoryForCAP", false ); +#! true +LoadPackage( "LinearAlgebraForCAP", false ); +#! true ################################# ## Note: This filter implies IsCategoryWithAttributesObject DeclareCategory( "IsObjectWithEndomorphism", - IsCategoryWithAttributesObject ); + IsCategoryWithAttributesObject );; DeclareRepresentation( "IsObjectWithEndomorphismRep", IsObjectWithEndomorphism and IsAttributeStoringRep, - [ ] ); + [ ] );; BindGlobal( "TheFamilyOfObjectsWithEndomorphism", - NewFamily( "TheFamilyOfObjectsWithEndomorphism" ) ); + NewFamily( "TheFamilyOfObjectsWithEndomorphism" ) );; BindGlobal( "TheTypeOfObjectsWithEndomorphism", NewType( TheFamilyOfObjectsWithEndomorphism, - IsObjectWithEndomorphismRep ) ); + IsObjectWithEndomorphismRep ) );; ## Note: This filter implies IsCategoryWithAttributesMorphism DeclareCategory( "IsMorphismOfObjectsWithEndomorphism", - IsCategoryWithAttributesMorphism ); + IsCategoryWithAttributesMorphism );; DeclareRepresentation( "IsMorphismOfObjectsWithEndomorphismRep", IsMorphismOfObjectsWithEndomorphism and IsAttributeStoringRep, - [ ] ); + [ ] );; BindGlobal( "TheFamilyOfMorphismsOfObjectsWithEndomorphism", - NewFamily( "TheFamilyOfMorphismsOfObjectsWithEndomorphism" ) ); + NewFamily( "TheFamilyOfMorphismsOfObjectsWithEndomorphism" ) );; BindGlobal( "TheTypeOfMorphismsOfObjectsWithEndomorphism", NewType( TheFamilyOfMorphismsOfObjectsWithEndomorphism, - IsMorphismOfObjectsWithEndomorphismRep ) ); + IsMorphismOfObjectsWithEndomorphismRep ) );; ################################# -Q := HomalgFieldOfRationals(); +Q := HomalgFieldOfRationals();; -underlying_category := MatrixCategory( Q ); +underlying_category := MatrixCategory( Q );; ## We create a "void" CapCategory here and set its properties (abelian, monoidal) in the beginning -category_of_objects_with_endomorphism := CreateCapCategory( "Category of objects with endomorphisms" ); +category_of_objects_with_endomorphism := CreateCapCategory( "Category of objects with endomorphisms" );; -SetIsAbelianCategory( category_of_objects_with_endomorphism, true ); +SetIsAbelianCategory( category_of_objects_with_endomorphism, true );; -SetIsRigidSymmetricClosedMonoidalCategory( category_of_objects_with_endomorphism, true ); +SetIsRigidSymmetricClosedMonoidalCategory( category_of_objects_with_endomorphism, true );; -SetIsStrictMonoidalCategory( category_of_objects_with_endomorphism, true ); +SetIsStrictMonoidalCategory( category_of_objects_with_endomorphism, true );; ## This record will be the input of the function that enhances underlying_category with attributes structure_record := rec( underlying_category := underlying_category, category_with_attributes := category_of_objects_with_endomorphism - ); + );; ## We can give the types of objects and morphisms to the structure_record. ## In this case, object and morphism constructors will automatically be generated. @@ -66,59 +74,45 @@ structure_record := rec( ## you have to set the attributes UnderlyingCell, ObjectAttributesAsList, and UnderlyingCategory. ## If you write your own morphism constructor, ## you have to set the attributes UnderlyingCell, and UnderlyingCategory -structure_record.object_type := TheTypeOfObjectsWithEndomorphism; +structure_record.object_type := TheTypeOfObjectsWithEndomorphism;; -structure_record.morphism_type := TheTypeOfMorphismsOfObjectsWithEndomorphism; +structure_record.morphism_type := TheTypeOfMorphismsOfObjectsWithEndomorphism;; ## This is the mathematical core: provide the functions that enhance objects with attributes structure_record.ZeroObject := function( underlying_zero_object ) - return [ ZeroMorphism( underlying_zero_object, underlying_zero_object ) ]; - - end; + return [ ZeroMorphism( underlying_zero_object, underlying_zero_object ) ]; end;; structure_record.DirectSum := function( obj_list, underlying_direct_sum ) - return [ DirectSumFunctorial( List( obj_list, obj -> ObjectAttributesAsList( obj )[1] ) ) ]; - - end; + return [ DirectSumFunctorial( List( obj_list, obj -> ObjectAttributesAsList( obj )[1] ) ) ]; end;; structure_record.Lift := function( mono, range ) - return [ LiftAlongMonomorphism( mono, PreCompose( mono, ObjectAttributesAsList( range )[1] ) ) ]; - - end; + return [ LiftAlongMonomorphism( mono, PreCompose( mono, ObjectAttributesAsList( range )[1] ) ) ]; end;; structure_record.Colift := function( epi, source ) - return [ ColiftAlongEpimorphism( epi, PreCompose( ObjectAttributesAsList( source )[1], epi ) ) ]; - - end; + return [ ColiftAlongEpimorphism( epi, PreCompose( ObjectAttributesAsList( source )[1], epi ) ) ]; end;; structure_record.TensorUnit := function( underlying_tensor_unit ) - return [ IdentityMorphism( underlying_tensor_unit ) ]; - - end; + return [ IdentityMorphism( underlying_tensor_unit ) ]; end;; structure_record.TensorProductOnObjects := function( object1, object2, underlying_tensor_product ) - return [ TensorProductOnMorphisms( ObjectAttributesAsList( object1 )[1], ObjectAttributesAsList( object2 )[1] ) ]; - - end; + return [ TensorProductOnMorphisms( ObjectAttributesAsList( object1 )[1], ObjectAttributesAsList( object2 )[1] ) ]; end;; structure_record.DualOnObjects := function( object, dual_object ) - return [ DualOnMorphisms( ObjectAttributesAsList( object )[1] ) ]; - - end; + return [ DualOnMorphisms( ObjectAttributesAsList( object )[1] ) ]; end;; ## In this particular example, this function would be not necessary since it can be ## derived from the rigidity of the category @@ -126,56 +120,58 @@ structure_record.InternalHomOnObjects := function( object1, object2, underlying_internal_hom ) return [ TensorProductOnMorphisms( DualOnMorphisms( ObjectAttributesAsList( object1 )[1] ), - ObjectAttributesAsList( object2 )[1] ) ]; - - end; + ObjectAttributesAsList( object2 )[1] ) ]; end;; -structure_record.NoInstallList := [ "Lift", "Colift" ]; +structure_record.NoInstallList := [ "Lift", "Colift" ];; -structure_record.InstallList := [ "LiftAlongMonomorphism", "ColiftAlongEpimorphism" ]; +structure_record.InstallList := [ "LiftAlongMonomorphism", "ColiftAlongEpimorphism" ];; ## This function installs all the primitive functions for the category_of_objects_with_endomorphism. -triple := EnhancementWithAttributes( structure_record ); +triple := EnhancementWithAttributes( structure_record );; ## EnhancementWithAttributes alters category_of_objects_with_endomorphism as a side effect: IsIdenticalObj( category_of_objects_with_endomorphism, triple[1] ); #! true -object_constructor := triple[2]; +object_constructor := triple[2];; -morphism_constructor := triple[3]; +morphism_constructor := triple[3];; ## Install equality/ congruence functions manually since they cannot be deduced automatically AddIsEqualForObjects( category_of_objects_with_endomorphism, function( object1, object2 ) return IsEqualForObjects( UnderlyingCell( object1 ), UnderlyingCell( object2 ) ) - and IsCongruentForMorphisms( ObjectAttributesAsList( object1 )[1], ObjectAttributesAsList( object2 )[1] ); - -end ); + and IsCongruentForMorphisms( ObjectAttributesAsList( object1 )[1], ObjectAttributesAsList( object2 )[1] ); end );; AddIsEqualForMorphisms( category_of_objects_with_endomorphism, function( morphism1, morphism2 ) - return IsCongruentForMorphisms( UnderlyingCell( morphism1 ), UnderlyingCell( morphism2 ) ); - -end ); + return IsCongruentForMorphisms( UnderlyingCell( morphism1 ), UnderlyingCell( morphism2 ) ); end );; ## Finalize the category -Finalize( category_of_objects_with_endomorphism ); +Finalize( category_of_objects_with_endomorphism );; ############################## ## Example computations V := VectorSpaceObject( 2, Q ); +#! endo := VectorSpaceMorphism( V, HomalgMatrix( [ [ 0, 1 ], [ 1, 0 ] ], 2, 2, Q ), V ); +#! Vendo := object_constructor( V, [ endo ] ); +#! IsCongruentForMorphisms( endo, ObjectAttributesAsList( Vendo )[1] ); +#! true beta := Braiding( Vendo, Vendo ); +#! Fendo := FiberProduct( [ beta, IdentityMorphism( TensorProductOnObjects( Vendo, Vendo ) ) ] ); +#! + +#! @EndExample diff --git a/AttributeCategoryForCAP/gap/AttributeCategory.gd b/AttributeCategoryForCAP/gap/AttributeCategory.gd index 7cacecda64..d6c7837a86 100644 --- a/AttributeCategoryForCAP/gap/AttributeCategory.gd +++ b/AttributeCategoryForCAP/gap/AttributeCategory.gd @@ -1,13 +1,9 @@ -############################################################################# -## -## AttributeCategoryForCAP package -## -## Copyright 2016, Sebastian Gutsche, University of Siegen -## Sebastian Posur, University of Siegen -## +# SPDX-License-Identifier: GPL-2.0-or-later +# AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category +# +# Declarations +# #! @Chapter Attribute Category -## -############################################################################# #################################### ## diff --git a/AttributeCategoryForCAP/gap/AttributeCategory.gi b/AttributeCategoryForCAP/gap/AttributeCategory.gi index 1150499b45..cc272e1663 100644 --- a/AttributeCategoryForCAP/gap/AttributeCategory.gi +++ b/AttributeCategoryForCAP/gap/AttributeCategory.gi @@ -1,12 +1,8 @@ -############################################################################# -## -## AttributeCategoryForCAP package -## -## Copyright 2016, Sebastian Gutsche, University of Siegen -## Sebastian Posur, University of Siegen -## -## -############################################################################# +# SPDX-License-Identifier: GPL-2.0-or-later +# AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category +# +# Implementations +# ## InstallValue( CAP_INTERNAL_STRUCTURE_FUNCTION_RECORD_FOR_CATEGORY_WITH_ATTRIBUTES, rec( diff --git a/AttributeCategoryForCAP/init.g b/AttributeCategoryForCAP/init.g index bbf4560146..70bb7a80bf 100644 --- a/AttributeCategoryForCAP/init.g +++ b/AttributeCategoryForCAP/init.g @@ -1,4 +1,4 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category # # Reading the declaration part of the package. diff --git a/AttributeCategoryForCAP/makedoc.g b/AttributeCategoryForCAP/makedoc.g index bdaeeecf07..58987bfdd1 100644 --- a/AttributeCategoryForCAP/makedoc.g +++ b/AttributeCategoryForCAP/makedoc.g @@ -1,21 +1,31 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category # -LoadPackage( "AutoDoc" ); - -AutoDoc( "AttributeCategoryForCAP" : scaffold := true, autodoc := - rec( files := [ "doc/Intros.autodoc" ], - scan_dirs := [ "gap", "examples", "doc" ] ), - maketest := rec( folder := ".", - commands := - [ "LoadPackage( \"CAP\" );", - "LoadPackage( \"IO_ForHomalg\" );", - "HOMALG_IO.show_banners := false;", - "HOMALG_IO.suppress_PID := true;", - "HOMALG_IO.use_common_stream := true;", - ] - ) -); +# This file is a script which compiles the package manual. +# +if fail = LoadPackage( "AutoDoc", "2019.05.20" ) then + + Error( "AutoDoc version 2019.05.20 or newer is required." ); + +fi; +AutoDoc( rec( + autodoc := rec( + files := [ "doc/Doc.autodoc" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc" ], + ), + extract_examples := rec( + units := "Single", + ), + gapdoc := rec( + LaTeXOptions := rec( + LateExtraPreamble := """ + """, + ), + ), + scaffold := rec( + entities := [ "homalg", "CAP" ], + ), +) ); QUIT; diff --git a/AttributeCategoryForCAP/makedoc_with_overfull_hbox_warnings.g b/AttributeCategoryForCAP/makedoc_with_overfull_hbox_warnings.g new file mode 100644 index 0000000000..267bdc6656 --- /dev/null +++ b/AttributeCategoryForCAP/makedoc_with_overfull_hbox_warnings.g @@ -0,0 +1,42 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category +# +# This file is a script which compiles the package manual and prints overfull hbox warnings. +# +if fail = LoadPackage( "AutoDoc", "2019.05.20" ) then + + Error( "AutoDoc version 2019.05.20 or newer is required." ); + +fi; + +AutoDoc( rec( + dir := "doc_tmp/", + autodoc := rec( + files := [ "doc/Doc.autodoc" ], + scan_dirs := [ "doc", "gap", "examples", "examples/doc" ], + ), + gapdoc := rec( + LaTeXOptions := rec( + LateExtraPreamble := """ + % Many thanks to https://tex.stackexchange.com/questions/22466/how-to-convince-fancyvrb-to-give-overfull-warnings/534486#534486 + \makeatletter + \def\FV@ListProcessLine#1{% + \hbox to \hsize{% + \kern\leftmargin + \hbox to \linewidth{% + \FV@LeftListNumber + \FV@LeftListFrame + \FancyVerbFormatLine{#1}\hfil % change \hss to \hfil + \FV@RightListFrame + \FV@RightListNumber}% + \hss}} + \makeatother + """, + ), + ), + scaffold := rec( + entities := [ "homalg", "CAP" ], + ), +) ); + +QUIT; diff --git a/AttributeCategoryForCAP/makefile b/AttributeCategoryForCAP/makefile index d36dc753ae..e195ea9d81 100644 --- a/AttributeCategoryForCAP/makefile +++ b/AttributeCategoryForCAP/makefile @@ -1,37 +1,57 @@ +# make sure gap --quitonbreak fails even if it is part of a pipe +SHELL=/bin/bash -o pipefail + all: doc test doc: doc/manual.six doc/manual.six: makedoc.g \ PackageInfo.g \ - doc/Intros.autodoc \ - gap/*.gd gap/*.gi examples/*.g* - gap makedoc.g + $(wildcard doc/*.autodoc gap/*.gd gap/*.gi examples/*.g examples/*/*.g) + gap makedoc.g clean: (cd doc ; ./clean) -test: doc - gap maketest.g - -archive: test - (mkdir -p ../tar; cd ..; tar czvf tar/CAP.tar.gz --exclude ".DS_Store" --exclude "*~" CAP/doc/*.* CAP/doc/clean CAP/gap/*.{gi,gd} CAP/{PackageInfo.g,README,COPYING,VERSION,init.g,read.g,makedoc.g,makefile,maketest.g} CAP/examples/*.g CAP/examples/doc/*.g) - -#WEBPOS=public_html -#WEBPOS_FINAL=~/Sites/homalg-project/CAP - -towww: archive - echo '' >${WEBPOS}.version - echo '' >>${WEBPOS}.version - cat VERSION >>${WEBPOS}.version - echo '' >>${WEBPOS}.version - cp PackageInfo.g ${WEBPOS} - cp README ${WEBPOS}/README.CAP - cp doc/manual.pdf ${WEBPOS}/CAP.pdf - cp doc/*.{css,html} ${WEBPOS} - rm -f ${WEBPOS}/*.tar.gz - mv ../tar/CAP.tar.gz ${WEBPOS}/CAP-`cat VERSION`.tar.gz - rm -f ${WEBPOS_FINAL}/*.tar.gz - cp ${WEBPOS}/* ${WEBPOS_FINAL} - ln -s CAP-`cat VERSION`.tar.gz ${WEBPOS_FINAL}/CAP.tar.gz - +test: doc + gap tst/testall.g + +test-basic-spacing: + grep -RPl "\t" examples/ gap/ && echo "Tabs found" && exit 1 || exit 0 + grep -RPl "\r" examples/ gap/ && echo "Windows line-endings found" && exit 1 || exit 0 + # the second grep is a hack to fix the exit code with -L for grep <= 3.1 + grep -RPzL "\n\z" examples/ gap/ | grep "" && echo "File with no newline at end of file found" && exit 1 || exit 0 + +test-doc: doc + cp -aT doc/ doc_tmp/ + cd doc_tmp && ./clean + gap --quitonbreak makedoc_with_overfull_hbox_warnings.g | perl -pe 'END { exit $$status } $$status=1 if /#W/;' + +test-with-coverage: doc + gap --quitonbreak --cover stats tst/testall.g + echo 'LoadPackage("profiling"); OutputJsonCoverage("stats", "coverage.json");' | gap --quitonbreak + +test-spacing: + grep -R "[^ [\"] " gap/*.gi && echo "Duplicate spaces found" && exit 1 || exit 0 + grep -RE '[^ ] +$$' gap/* && echo "Trailing whitespace found" && exit 1 || exit 0 + for filename in gap/*; do \ + echo $$filename; \ + echo "LoadPackage(\"AttributeCategoryForCAP\"); SizeScreen([4096]); func := ReadAsFunction(\"$$filename\"); FileString(\"gap_spacing\", DisplayString(func));" | gap --quitonbreak --banner; \ + echo -e "\033[0m"; \ + # In a perfect world, the DisplayString of a function would exactly match our code. However, our line breaks and indentation might differ from the GAP ones, \ + # so we remove all indentation, line breaks, and empty lines, and afterwards insert line breaks at semicolons again for better readability. \ + cat "gap_spacing" | tail -n +2 | head -n -2 | sed 's/\[ \]/[ ]/g' | sed 's/( )/( )/g' | sed 's/( :/( :/g' | sed 's/ *$$//' | sed 's/^ *//' | grep -v "^$$" | tr "\n" " " | sed 's/;/;\n/g' > modified_gap_spacing; \ + cat "$$filename" | grep -v "^ *[#]" | sed 's/^ *//' | grep -v "^$$" | tr "\n" " " | sed "s/;/;\n/g" > modified_custom_spacing; \ + # Our code might still differ from the GAP code, for example because of additional brackets. \ + # Thus, we diff the code once as expected and once ignoring all space. Diffing the two diffs then shows lines which only differ by spacing. \ + diff modified_gap_spacing modified_custom_spacing > spacing_diff; \ + diff modified_gap_spacing modified_custom_spacing --ignore-all-space --ignore-space-change --ignore-trailing-space --ignore-blank-lines > spacing_diff_no_blanks; \ + diff spacing_diff_no_blanks spacing_diff || exit; \ + done + rm gap_spacing + rm modified_gap_spacing + rm modified_custom_spacing + rm spacing_diff + rm spacing_diff_no_blanks + +ci-test: test-basic-spacing test-with-coverage diff --git a/AttributeCategoryForCAP/read.g b/AttributeCategoryForCAP/read.g index 8349b05f70..5aad867410 100644 --- a/AttributeCategoryForCAP/read.g +++ b/AttributeCategoryForCAP/read.g @@ -1,4 +1,4 @@ -# +# SPDX-License-Identifier: GPL-2.0-or-later # AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category # # Reading the implementation part of the package. diff --git a/AttributeCategoryForCAP/tst/100_LoadPackage.tst b/AttributeCategoryForCAP/tst/100_LoadPackage.tst new file mode 100644 index 0000000000..e4dd152e8c --- /dev/null +++ b/AttributeCategoryForCAP/tst/100_LoadPackage.tst @@ -0,0 +1,13 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category +# +# This file tests if the package can be loaded without errors or warnings. +# +gap> package_loading_info_level := InfoLevel( InfoPackageLoading );; +gap> SetInfoLevel( InfoPackageLoading, PACKAGE_ERROR );; +gap> LoadPackage( "AttributeCategoryForCAP", false ); +true +gap> SetInfoLevel( InfoPackageLoading, PACKAGE_INFO );; +gap> LoadPackage( "AttributeCategoryForCAP" ); +true +gap> SetInfoLevel( InfoPackageLoading, package_loading_info_level );; diff --git a/AttributeCategoryForCAP/tst/testall.g b/AttributeCategoryForCAP/tst/testall.g new file mode 100644 index 0000000000..4e3d2b1cf5 --- /dev/null +++ b/AttributeCategoryForCAP/tst/testall.g @@ -0,0 +1,16 @@ +# SPDX-License-Identifier: GPL-2.0-or-later +# AttributeCategoryForCAP: Automatic enhancement with attributes of a CAP category +# +# This file runs package tests. It is also referenced in the package +# metadata in PackageInfo.g. +# +options := rec( + exitGAP := true, + testOptions := rec( + compareFunction := "uptowhitespace", + ), +); + +TestDirectory( DirectoriesPackageLibrary( "AttributeCategoryForCAP", "tst" ), options ); + +FORCE_QUIT_GAP( 1 ); # if we ever get here, there was an error diff --git a/makefile b/makefile index 3f08093421..181982a6a8 100644 --- a/makefile +++ b/makefile @@ -88,6 +88,12 @@ doc_ToricSheaves: # END PACKAGE JANITOR +ci-test_ActionsForCAP: + $(MAKE) -C ActionsForCAP ci-test + +ci-test_AttributeCategoryForCAP: + $(MAKE) -C AttributeCategoryForCAP ci-test + ci-test_CAP: $(MAKE) -C CAP ci-test @@ -115,4 +121,4 @@ ci-test_LinearAlgebraForCAP: ci-test_ModulePresentationsForCAP: $(MAKE) -C ModulePresentationsForCAP ci-test -ci-test: homalg_compatibility doc ci-test_CAP ci-test_CompilerForCAP ci-test_FreydCategoriesForCAP ci-test_GeneralizedMorphismsForCAP ci-test_GradedModulePresentationsForCAP ci-test_GroupRepresentationsForCAP ci-test_InternalExteriorAlgebraForCAP ci-test_LinearAlgebraForCAP ci-test_ModulePresentationsForCAP +ci-test: homalg_compatibility doc ci-test_ActionsForCAP ci-test_AttributeCategoryForCAP ci-test_CAP ci-test_CompilerForCAP ci-test_FreydCategoriesForCAP ci-test_GeneralizedMorphismsForCAP ci-test_GradedModulePresentationsForCAP ci-test_GroupRepresentationsForCAP ci-test_InternalExteriorAlgebraForCAP ci-test_LinearAlgebraForCAP ci-test_ModulePresentationsForCAP From 8b2e3432ca473b8666a1ab95e8b63cae8b26c908 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Fri, 22 Oct 2021 17:05:10 +0200 Subject: [PATCH 2/8] Fix adding of functions in AttributeCategory --- .../gap/AttributeCategory.gi | 61 ++++++++++--------- 1 file changed, 32 insertions(+), 29 deletions(-) diff --git a/AttributeCategoryForCAP/gap/AttributeCategory.gi b/AttributeCategoryForCAP/gap/AttributeCategory.gi index cc272e1663..b5cee526f5 100644 --- a/AttributeCategoryForCAP/gap/AttributeCategory.gi +++ b/AttributeCategoryForCAP/gap/AttributeCategory.gi @@ -397,40 +397,43 @@ InstallGlobalFunction( CAP_INTERNAL_INSTALL_ADDS_FOR_CATEGORY_WITH_ATTRIBUTES, elif entry.return_type = "morphism" then - ## functions marked with no_with_given cannot automatically be equipped with attributes - if not( IsBound( entry.no_with_given ) and entry.no_with_given = true ) then + if not IsBound( entry.io_type ) then - if not IsBound( entry.universal_type ) - or ( IsBound( entry.universal_type ) and entry.is_with_given ) then - - function_to_add := create_function_morphism_no_new_object( name ); - - add_function( category_with_attributes, function_to_add ); - - elif IsBound( entry.universal_type ) then - - ## TODO: this should be directly accessible in the method record - with_given_object_name := CAP_INTERNAL_METHOD_NAME_RECORD.(entry.with_given_without_given_name_pair[2]).with_given_object_name; + ## if there is no io_type we cannot do anything + continue; + + fi; + + if IsBound( entry.output_source_getter_string ) and entry.can_always_compute_output_source_getter and + IsBound( entry.output_range_getter_string ) and entry.can_always_compute_output_range_getter then + + function_to_add := create_function_morphism_no_new_object( name ); + + add_function( category_with_attributes, function_to_add ); + + elif IsBound( entry.with_given_object_position ) and entry.with_given_object_position in [ "Source", "Range" ] and + IsBound( CAP_INTERNAL_METHOD_NAME_RECORD.(entry.with_given_without_given_name_pair[2]).with_given_object_name ) then + + with_given_object_name := CAP_INTERNAL_METHOD_NAME_RECORD.(entry.with_given_without_given_name_pair[2]).with_given_object_name; + + if IsBound( structure_record.(with_given_object_name) ) then - if IsBound( structure_record.(with_given_object_name) ) then + if entry.with_given_object_position = "Source" then + + function_to_add := create_function_morphism_new_source( name, structure_record.(with_given_object_name) ); + + add_function( category_with_attributes, function_to_add ); + + elif entry.with_given_object_position = "Range" then + + function_to_add := create_function_morphism_new_range( name, structure_record.(with_given_object_name) ); + + add_function( category_with_attributes, function_to_add ); - if entry.with_given_object_position = "Source" then - - function_to_add := create_function_morphism_new_source( name, structure_record.(with_given_object_name) ); - - add_function( category_with_attributes, function_to_add ); - - elif entry.with_given_object_position = "Range" then - - function_to_add := create_function_morphism_new_range( name, structure_record.(with_given_object_name) ); - - add_function( category_with_attributes, function_to_add ); - - fi; - fi; + fi; - + fi; elif entry.return_type = "morphism_or_fail" then From f6e0ecc71e6b9ad909f6c924f4f675ace8516337 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Wed, 20 Oct 2021 10:51:25 +0200 Subject: [PATCH 3/8] Do not apply detection of rapid reassignments to RETURN_VALUE Multiple return statements (except in if/else bodies) are not supported. --- CompilerForCAP/gap/EnhancedSyntaxTree.gi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CompilerForCAP/gap/EnhancedSyntaxTree.gi b/CompilerForCAP/gap/EnhancedSyntaxTree.gi index 150c7aac46..e8efcd110c 100644 --- a/CompilerForCAP/gap/EnhancedSyntaxTree.gi +++ b/CompilerForCAP/gap/EnhancedSyntaxTree.gi @@ -524,7 +524,7 @@ InstallGlobalFunction( ENHANCED_SYNTAX_TREE, function ( func ) fi; # detect rapid reassignments - if i < statements.length and statements.(i + 1).type = "STAT_ASS_FVAR" and statements.(i + 1).func_id = tree.id and statements.(i + 1).name = statement.name then + if i < statements.length and statements.(i + 1).type = "STAT_ASS_FVAR" and statements.(i + 1).func_id = tree.id and statements.(i + 1).name = statement.name and statement.name <> "RETURN_VALUE" then statements.(i + 1) := CapJitReplacedEXPR_REF_FVARByValue( statements.(i + 1), statement.func_id, statement.name, statement.rhs ); continue; From 547dde5de1496e49f93a6f2ec0a70af9ef0f558b Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Fri, 22 Oct 2021 17:03:41 +0200 Subject: [PATCH 4/8] Improve error message --- CompilerForCAP/gap/PrecompileCategory.gi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CompilerForCAP/gap/PrecompileCategory.gi b/CompilerForCAP/gap/PrecompileCategory.gi index 65ca24ecb2..1980e33723 100644 --- a/CompilerForCAP/gap/PrecompileCategory.gi +++ b/CompilerForCAP/gap/PrecompileCategory.gi @@ -511,7 +511,7 @@ InstallGlobalFunction( "CapJitPrecompileCategory", function ( category_construct if PositionSublist( function_string, "CAP_JIT_INTERNAL_GLOBAL_VARIABLE_" ) <> fail then # COVERAGE_IGNORE_NEXT_LINE - Error( "Could not get rid of all global variables. You should use category_hints.category_attribute_names." ); + Error( "Could not get rid of all global variables, see . You should use category_hints.category_attribute_names." ); fi; From 41efb17853ea8a95daf16208e8050d2bfca2254d Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Fri, 22 Oct 2021 17:03:29 +0200 Subject: [PATCH 5/8] Enforce finalization before creating functors Otherwise the ProductCategory throws an error. --- .../GeneralizedMorphismCategoryByCospans.gi | 4 +-- .../GeneralizedMorphismCategoryFunctors.gi | 26 +++++++++---------- 2 files changed, 15 insertions(+), 15 deletions(-) diff --git a/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryByCospans.gi b/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryByCospans.gi index fa93569f50..78b1f82539 100644 --- a/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryByCospans.gi +++ b/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryByCospans.gi @@ -363,8 +363,8 @@ InstallMethod( AsGeneralizedMorphismByCospan, function( F, name ) local A, B, gmcF; - A := GeneralizedMorphismCategoryByCospans( AsCapCategory( Source( F ) ) ); - B := GeneralizedMorphismCategoryByCospans( AsCapCategory( Range( F ) ) ); + A := GeneralizedMorphismCategoryByCospans( AsCapCategory( Source( F ) ) : FinalizeCategory := true ); + B := GeneralizedMorphismCategoryByCospans( AsCapCategory( Range( F ) ) : FinalizeCategory := true ); gmcF := CapFunctor( name, A, B ); diff --git a/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryFunctors.gi b/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryFunctors.gi index 44bf959a89..010243d2c5 100644 --- a/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryFunctors.gi +++ b/GeneralizedMorphismsForCAP/gap/GeneralizedMorphismCategoryFunctors.gi @@ -15,9 +15,9 @@ InstallMethod( FunctorFromCospansToThreeArrows, function( category ) local source_cat, range_cat, functor; - source_cat := GeneralizedMorphismCategoryByCospans( category ); + source_cat := GeneralizedMorphismCategoryByCospans( category : FinalizeCategory := true ); - range_cat := GeneralizedMorphismCategoryByThreeArrows( category ); + range_cat := GeneralizedMorphismCategoryByThreeArrows( category : FinalizeCategory := true ); functor := CapFunctor( Concatenation( "Functor from cospans to three arrows on ", Name( category ) ), source_cat, range_cat ); @@ -40,9 +40,9 @@ InstallMethod( FunctorFromCospansToSpans, function( category ) local source_cat, range_cat, functor; - source_cat := GeneralizedMorphismCategoryByCospans( category ); + source_cat := GeneralizedMorphismCategoryByCospans( category : FinalizeCategory := true ); - range_cat := GeneralizedMorphismCategoryBySpans( category ); + range_cat := GeneralizedMorphismCategoryBySpans( category : FinalizeCategory := true ); functor := CapFunctor( Concatenation( "Functor from cospans to spans on ", Name( category ) ), source_cat, range_cat ); @@ -65,9 +65,9 @@ InstallMethod( FunctorFromSpansToThreeArrows, function( category ) local source_cat, range_cat, functor; - source_cat := GeneralizedMorphismCategoryBySpans( category ); + source_cat := GeneralizedMorphismCategoryBySpans( category : FinalizeCategory := true ); - range_cat := GeneralizedMorphismCategoryByThreeArrows( category ); + range_cat := GeneralizedMorphismCategoryByThreeArrows( category : FinalizeCategory := true ); functor := CapFunctor( Concatenation( "Functor from spans to three arrows on ", Name( category ) ), source_cat, range_cat ); @@ -90,9 +90,9 @@ InstallMethod( FunctorFromSpansToCospans, function( category ) local source_cat, range_cat, functor; - source_cat := GeneralizedMorphismCategoryBySpans( category ); + source_cat := GeneralizedMorphismCategoryBySpans( category : FinalizeCategory := true ); - range_cat := GeneralizedMorphismCategoryByCospans( category ); + range_cat := GeneralizedMorphismCategoryByCospans( category : FinalizeCategory := true ); functor := CapFunctor( Concatenation( "Functor from spans to cospans on ", Name( category ) ), source_cat, range_cat ); @@ -115,9 +115,9 @@ InstallMethod( FunctorFromThreeArrowsToCospans, function( category ) local source_cat, range_cat, functor; - source_cat := GeneralizedMorphismCategoryByThreeArrows( category ); + source_cat := GeneralizedMorphismCategoryByThreeArrows( category : FinalizeCategory := true ); - range_cat := GeneralizedMorphismCategoryByCospans( category ); + range_cat := GeneralizedMorphismCategoryByCospans( category : FinalizeCategory := true ); functor := CapFunctor( Concatenation( "Functor from three arrows to cospans on ", Name( category ) ), source_cat, range_cat ); @@ -140,9 +140,9 @@ InstallMethod( FunctorFromThreeArrowsToSpans, function( category ) local source_cat, range_cat, functor; - source_cat := GeneralizedMorphismCategoryByThreeArrows( category ); + source_cat := GeneralizedMorphismCategoryByThreeArrows( category : FinalizeCategory := true ); - range_cat := GeneralizedMorphismCategoryBySpans( category ); + range_cat := GeneralizedMorphismCategoryBySpans( category : FinalizeCategory := true ); functor := CapFunctor( Concatenation( "Functor from three arrows to cospans on ", Name( category ) ), source_cat, range_cat ); @@ -157,4 +157,4 @@ InstallMethod( FunctorFromThreeArrowsToSpans, return functor; -end ); \ No newline at end of file +end ); From dfce89a9b66aad6f9bfd23271381b1da159a26d9 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Tue, 26 Oct 2021 11:20:20 +0200 Subject: [PATCH 6/8] Fix derivation of IsEqualAsFactorobjects --- CAP/gap/DerivedMethods.gi | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CAP/gap/DerivedMethods.gi b/CAP/gap/DerivedMethods.gi index 409557a5cf..f256cc1dd3 100644 --- a/CAP/gap/DerivedMethods.gi +++ b/CAP/gap/DerivedMethods.gi @@ -1090,7 +1090,7 @@ AddDerivationToCAP( IsEqualAsFactorobjects, function( cat, factor1, factor2 ) - return IsCodominating( cat, factor1, factor2 ) and IsCodominating( cat, factor1, factor2 ); + return IsCodominating( cat, factor1, factor2 ) and IsCodominating( cat, factor2, factor1 ); end : Description := "IsEqualAsFactorobjects(factor1, factor2) if factor1 dominates factor2 and vice versa" ); From c9e5b1ee62fc708e8ba75364dae14aaa83bdca27 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Tue, 26 Oct 2021 11:20:12 +0200 Subject: [PATCH 7/8] Get rid of no_with_given and universal_type --- CAP/gap/MethodRecord.gi | 171 ++++-------------- .../gap/FreydCategoriesForCAP.gi | 44 +---- .../ClosedMonoidalCategoriesMethodRecord.gi | 14 +- .../CoclosedMonoidalCategoriesMethodRecord.gi | 14 +- ...ricClosedMonoidalCategoriesMethodRecord.gi | 8 +- ...cCoclosedMonoidalCategoriesMethodRecord.gi | 8 +- 6 files changed, 56 insertions(+), 203 deletions(-) diff --git a/CAP/gap/MethodRecord.gi b/CAP/gap/MethodRecord.gi index b287c26173..33e4f4cdc9 100644 --- a/CAP/gap/MethodRecord.gi +++ b/CAP/gap/MethodRecord.gi @@ -276,7 +276,6 @@ InverseForMorphisms := rec( KernelObject := rec( filter_list := [ "category", "morphism" ], - universal_type := "Limit", return_type := "object", dual_operation := "CokernelObject" ), @@ -284,14 +283,12 @@ KernelEmbedding := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "P", "alpha_source" ] ], with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := "CokernelProjection" ), KernelEmbeddingWithGivenKernelObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "P" ], [ "P", "alpha_source" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "CokernelProjectionWithGivenCokernelObject"), @@ -299,14 +296,12 @@ MorphismFromKernelObjectToSink := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "P", "alpha_range" ] ], with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "MorphismFromSourceToCokernelObject", return_type := "morphism" ), MorphismFromKernelObjectToSinkWithGivenKernelObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "P" ], [ "P", "alpha_range" ] ], - universal_type := "Limit", dual_operation := "MorphismFromSourceToCokernelObjectWithGivenCokernelObject", return_type := "morphism" ), @@ -314,20 +309,17 @@ KernelLift := rec( filter_list := [ "category", "morphism", "object", "morphism" ], io_type := [ [ "alpha", "T", "tau" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := "CokernelColift" ), KernelLiftWithGivenKernelObject := rec( filter_list := [ "category", "morphism", "object", "morphism", "object" ], io_type := [ [ "alpha", "T", "tau", "P" ], [ "T", "P" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "CokernelColiftWithGivenCokernelObject" ), CokernelObject := rec( filter_list := [ "category", "morphism" ], - universal_type := "Colimit", return_type := "object", dual_operation := "KernelObject" ), @@ -335,14 +327,12 @@ CokernelProjection := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "alpha_range", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", return_type := "morphism", dual_operation := "KernelEmbedding" ), CokernelProjectionWithGivenCokernelObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "P" ], [ "alpha_range", "P" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "KernelEmbeddingWithGivenKernelObject" ), @@ -350,14 +340,12 @@ MorphismFromSourceToCokernelObject := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "alpha_source", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "MorphismFromKernelObjectToSink", return_type := "morphism" ), MorphismFromSourceToCokernelObjectWithGivenCokernelObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "P" ], [ "alpha_source", "P" ] ], - universal_type := "Colimit", dual_operation := "MorphismFromKernelObjectToSinkWithGivenKernelObject", return_type := "morphism" ), @@ -365,14 +353,12 @@ CokernelColift := rec( filter_list := [ "category", "morphism", "object", "morphism" ], io_type := [ [ "alpha", "T", "tau" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", return_type := "morphism", dual_operation := "KernelLift" ), CokernelColiftWithGivenCokernelObject := rec( filter_list := [ "category", "morphism", "object", "morphism", "object" ], io_type := [ [ "alpha", "T", "tau", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "KernelLiftWithGivenKernelObject" ), @@ -427,7 +413,6 @@ PostCompose := rec( ZeroObject := rec( filter_list := [ "category" ], - universal_type := "LimitColimit", return_type := "object", dual_operation := "ZeroObject" ), @@ -436,20 +421,18 @@ ZeroObjectFunctorial := rec( ## TODO: io_type? return_type := "morphism", dual_operation := "ZeroObjectFunctorial", - no_with_given := true ), +), UniversalMorphismFromZeroObject := rec( filter_list := [ "category", "object" ], io_type := [ [ "T" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", return_type := "morphism", dual_operation := "UniversalMorphismIntoZeroObject" ), UniversalMorphismFromZeroObjectWithGivenZeroObject := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "T", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "UniversalMorphismIntoZeroObjectWithGivenZeroObject" ), @@ -457,14 +440,12 @@ UniversalMorphismIntoZeroObject := rec( filter_list := [ "category", "object" ], io_type := [ [ "T" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := "UniversalMorphismFromZeroObject" ), UniversalMorphismIntoZeroObjectWithGivenZeroObject := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "T", "P" ], [ "T", "P" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "UniversalMorphismFromZeroObjectWithGivenZeroObject" ), @@ -473,28 +454,28 @@ IsomorphismFromZeroObjectToInitialObject := rec( ## TODO: io_type? return_type := "morphism", dual_operation := "IsomorphismFromTerminalObjectToZeroObject", - no_with_given := true ), +), IsomorphismFromInitialObjectToZeroObject := rec( filter_list := [ "category" ], ## TODO: io_type? return_type := "morphism", dual_operation := "IsomorphismFromZeroObjectToTerminalObject", - no_with_given := true ), +), IsomorphismFromZeroObjectToTerminalObject := rec( filter_list := [ "category" ], ## TODO: io_type? return_type := "morphism", dual_operation := "IsomorphismFromInitialObjectToZeroObject", - no_with_given := true ), +), IsomorphismFromTerminalObjectToZeroObject := rec( filter_list := [ "category" ], ## TODO: io_type? return_type := "morphism", dual_operation := "IsomorphismFromZeroObjectToInitialObject", - no_with_given := true ), +), ZeroMorphism := rec( filter_list := [ "category", "object", "object" ], @@ -505,7 +486,6 @@ ZeroMorphism := rec( DirectSum := rec( filter_list := [ "category", "list_of_objects" ], - universal_type := "LimitColimit", return_type := "object", dual_operation := "DirectSum" ), @@ -513,14 +493,12 @@ ProjectionInFactorOfDirectSum := rec( filter_list := [ "category", "list_of_objects", IsInt ], io_type := [ [ "objects", "k" ], [ "P", "objects_k" ] ], with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := "InjectionOfCofactorOfDirectSum" ), ProjectionInFactorOfDirectSumWithGivenDirectSum := rec( filter_list := [ "category", "list_of_objects", IsInt, "object" ], io_type := [ [ "objects", "k", "P" ], [ "P", "objects_k" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "InjectionOfCofactorOfDirectSumWithGivenDirectSum" ), @@ -528,7 +506,6 @@ UniversalMorphismIntoDirectSum := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms" ], io_type := [ [ "objects", "T", "tau" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", dual_operation := "UniversalMorphismFromDirectSum", pre_function := function( cat, diagram, test_object, source ) @@ -558,7 +535,6 @@ UniversalMorphismIntoDirectSum := rec( UniversalMorphismIntoDirectSumWithGivenDirectSum := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms", "object" ], io_type := [ [ "objects", "T", "tau", "P" ], [ "T", "P" ] ], - universal_type := "Limit", dual_operation := "UniversalMorphismFromDirectSumWithGivenDirectSum", pre_function := function( cat, diagram, test_object, source, direct_sum ) @@ -589,14 +565,12 @@ InjectionOfCofactorOfDirectSum := rec( filter_list := [ "category", "list_of_objects", IsInt ], io_type := [ [ "objects", "k" ], [ "objects_k", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", return_type := "morphism", dual_operation := "ProjectionInFactorOfDirectSum" ), InjectionOfCofactorOfDirectSumWithGivenDirectSum := rec( filter_list := [ "category", "list_of_objects", IsInt, "object" ], io_type := [ [ "objects", "k", "P" ], [ "objects_k", "P" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "ProjectionInFactorOfDirectSumWithGivenDirectSum" ), @@ -604,7 +578,6 @@ UniversalMorphismFromDirectSum := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms" ], io_type := [ [ "objects", "T", "tau" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoDirectSum", pre_function := function( cat, diagram, test_object, sink ) @@ -634,7 +607,6 @@ UniversalMorphismFromDirectSum := rec( UniversalMorphismFromDirectSumWithGivenDirectSum := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms", "object" ], io_type := [ [ "objects", "T", "tau", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoDirectSumWithGivenDirectSum", pre_function := function( cat, diagram, test_object, sink, direct_sum ) @@ -663,7 +635,6 @@ UniversalMorphismFromDirectSumWithGivenDirectSum := rec( TerminalObject := rec( filter_list := [ "category" ], - universal_type := "Limit", return_type := "object", dual_operation := "InitialObject" ), @@ -671,20 +642,17 @@ UniversalMorphismIntoTerminalObject := rec( filter_list := [ "category", "object" ], io_type := [ [ "T" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := "UniversalMorphismFromInitialObject" ), UniversalMorphismIntoTerminalObjectWithGivenTerminalObject := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "T", "P" ], [ "T", "P" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "UniversalMorphismFromInitialObjectWithGivenInitialObject" ), InitialObject := rec( filter_list := [ "category" ], - universal_type := "Colimit", return_type := "object", dual_operation := "TerminalObject" ), @@ -692,20 +660,17 @@ UniversalMorphismFromInitialObject := rec( filter_list := [ "category", "object" ], io_type := [ [ "T" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", return_type := "morphism", dual_operation := "UniversalMorphismIntoTerminalObject" ), UniversalMorphismFromInitialObjectWithGivenInitialObject := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "T", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "UniversalMorphismIntoTerminalObjectWithGivenTerminalObject" ), DirectProduct := rec( filter_list := [ "category", "list_of_objects" ], - universal_type := "Limit", return_type := "object", dual_operation := "Coproduct" ), @@ -713,14 +678,12 @@ ProjectionInFactorOfDirectProduct := rec( filter_list := [ "category", "list_of_objects", IsInt ], io_type := [ [ "objects", "k" ], [ "P", "objects_k" ] ], with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := "InjectionOfCofactorOfCoproduct" ), ProjectionInFactorOfDirectProductWithGivenDirectProduct := rec( filter_list := [ "category", "list_of_objects", IsInt, "object" ], io_type := [ [ "objects", "k", "P" ], [ "P", "objects_k" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "InjectionOfCofactorOfCoproductWithGivenCoproduct" ), @@ -728,7 +691,6 @@ UniversalMorphismIntoDirectProduct := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms" ], io_type := [ [ "objects", "T", "tau" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", dual_operation := "UniversalMorphismFromCoproduct", pre_function := function( cat, diagram, test_object, source ) @@ -758,7 +720,6 @@ UniversalMorphismIntoDirectProduct := rec( UniversalMorphismIntoDirectProductWithGivenDirectProduct := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms", "object" ], io_type := [ [ "objects", "T", "tau", "P" ], [ "T", "P" ] ], - universal_type := "Limit", dual_operation := "UniversalMorphismFromCoproductWithGivenCoproduct", pre_function := function( cat, diagram, test_object, source, direct_product ) @@ -1092,7 +1053,6 @@ AdditiveInverseForMorphisms := rec( Coproduct := rec( filter_list := [ "category", "list_of_objects" ], - universal_type := "Colimit", return_type := "object", dual_operation := "DirectProduct" ), @@ -1100,14 +1060,12 @@ InjectionOfCofactorOfCoproduct := rec( filter_list := [ "category", "list_of_objects", IsInt ], io_type := [ [ "objects", "k" ], [ "objects_k", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", return_type := "morphism", dual_operation := "ProjectionInFactorOfDirectProduct" ), InjectionOfCofactorOfCoproductWithGivenCoproduct := rec( filter_list := [ "category", "list_of_objects", IsInt, "object" ], io_type := [ [ "objects", "k", "P" ], [ "objects_k", "P" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "ProjectionInFactorOfDirectProductWithGivenDirectProduct" ), @@ -1115,7 +1073,6 @@ UniversalMorphismFromCoproduct := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms" ], io_type := [ [ "objects", "T", "tau" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoDirectProduct", pre_function := function( cat, diagram, test_object, sink ) @@ -1145,7 +1102,6 @@ UniversalMorphismFromCoproduct := rec( UniversalMorphismFromCoproductWithGivenCoproduct := rec( filter_list := [ "category", "list_of_objects", "object", "list_of_morphisms", "object" ], io_type := [ [ "objects", "T", "tau", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoDirectProductWithGivenDirectProduct", pre_function := function( cat, diagram, test_object, sink, coproduct ) @@ -1235,7 +1191,6 @@ IsCodominating := rec( Equalizer := rec( filter_list := [ "category", "list_of_morphisms" ], return_type := "object", - universal_type := "Limit", dual_operation := "Coequalizer", pre_function := function( cat, diagram ) @@ -1283,7 +1238,6 @@ EmbeddingOfEqualizer := rec( return_type := "morphism", io_type := [ [ "morphisms" ], [ "P", "morphisms_1_source" ] ], with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "ProjectionOntoCoequalizer", pre_function := ~.Equalizer.pre_function ), @@ -1292,21 +1246,18 @@ EmbeddingOfEqualizerWithGivenEqualizer := rec( filter_list := [ "category", "list_of_morphisms", "object" ], return_type := "morphism", io_type := [ [ "morphisms", "P" ], [ "P", "morphisms_1_source" ] ], - universal_type := "Limit", dual_operation := "ProjectionOntoCoequalizerWithGivenCoequalizer" ), MorphismFromEqualizerToSink := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "morphisms" ], [ "P", "morphisms_1_range" ] ], with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "MorphismFromSourceToCoequalizer", return_type := "morphism" ), MorphismFromEqualizerToSinkWithGivenEqualizer := rec( filter_list := [ "category", "list_of_morphisms", "object" ], io_type := [ [ "morphisms", "P" ], [ "P", "morphisms_1_range" ] ], - universal_type := "Limit", dual_operation := "MorphismFromSourceToCoequalizerWithGivenCoequalizer", return_type := "morphism" ), @@ -1314,7 +1265,6 @@ UniversalMorphismIntoEqualizer := rec( filter_list := [ "category", "list_of_morphisms", "object", "morphism" ], io_type := [ [ "morphisms", "T", "tau" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := "UniversalMorphismFromCoequalizer", @@ -1373,13 +1323,11 @@ UniversalMorphismIntoEqualizer := rec( UniversalMorphismIntoEqualizerWithGivenEqualizer := rec( filter_list := [ "category", "list_of_morphisms", "object", "morphism", "object" ], io_type := [ [ "morphisms", "T", "tau", "P" ], [ "T", "P" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "UniversalMorphismFromCoequalizerWithGivenCoequalizer" ), FiberProduct := rec( filter_list := [ "category", "list_of_morphisms" ], - universal_type := "Limit", dual_operation := "Pushout", pre_function := function( cat, diagram ) @@ -1413,7 +1361,6 @@ ProjectionInFactorOfFiberProduct := rec( filter_list := [ "category", "list_of_morphisms", IsInt ], io_type := [ [ "morphisms", "k" ], [ "P", "morphisms_k_source" ] ], with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "InjectionOfCofactorOfPushout", pre_function := function( cat, diagram, projection_number ) @@ -1444,7 +1391,6 @@ ProjectionInFactorOfFiberProduct := rec( ProjectionInFactorOfFiberProductWithGivenFiberProduct := rec( filter_list := [ "category", "list_of_morphisms", IsInt, "object" ], io_type := [ [ "morphisms", "k", "P" ], [ "P", "morphisms_k_source" ] ], - universal_type := "Limit", dual_operation := "InjectionOfCofactorOfPushoutWithGivenPushout", pre_function := function( cat, diagram, projection_number, pullback ) @@ -1476,7 +1422,6 @@ MorphismFromFiberProductToSink := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "morphisms" ], [ "P", "morphisms_1_range" ] ], with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "MorphismFromSourceToPushout", pre_function := function( cat, diagram ) @@ -1503,7 +1448,6 @@ MorphismFromFiberProductToSink := rec( MorphismFromFiberProductToSinkWithGivenFiberProduct := rec( filter_list := [ "category", "list_of_morphisms", "object" ], io_type := [ [ "morphisms", "P" ], [ "P", "morphisms_1_range" ] ], - universal_type := "Limit", dual_operation := "MorphismFromSourceToPushoutWithGivenPushout", pre_function := function( cat, diagram, pullback ) @@ -1531,7 +1475,6 @@ UniversalMorphismIntoFiberProduct := rec( filter_list := [ "category", "list_of_morphisms", "object", "list_of_morphisms" ], io_type := [ [ "morphisms", "T", "tau" ], [ "T", "P" ] ], with_given_object_position := "Range", - universal_type := "Limit", dual_operation := "UniversalMorphismFromPushout", pre_function := function( cat, diagram, test_object, source ) @@ -1592,7 +1535,6 @@ UniversalMorphismIntoFiberProduct := rec( UniversalMorphismIntoFiberProductWithGivenFiberProduct := rec( filter_list := [ "category", "list_of_morphisms", "object", "list_of_morphisms", "object" ], io_type := [ [ "morphisms", "T", "tau", "P" ], [ "T", "P" ] ], - universal_type := "Limit", dual_operation := "UniversalMorphismFromPushoutWithGivenPushout", pre_function := function( cat, diagram, test_object, source, pullback ) @@ -1653,7 +1595,6 @@ UniversalMorphismIntoFiberProductWithGivenFiberProduct := rec( Coequalizer := rec( filter_list := [ "category", "list_of_morphisms" ], return_type := "object", - universal_type := "Colimit", dual_operation := "Equalizer", pre_function := function( cat, diagram ) @@ -1701,7 +1642,6 @@ ProjectionOntoCoequalizer := rec( return_type := "morphism", io_type := [ [ "morphisms" ], [ "morphisms_1_range", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "EmbeddingOfEqualizer", pre_function := ~.Coequalizer.pre_function ), @@ -1710,21 +1650,18 @@ ProjectionOntoCoequalizerWithGivenCoequalizer := rec( filter_list := [ "category", "list_of_morphisms", "object" ], return_type := "morphism", io_type := [ [ "morphisms", "P" ], [ "morphisms_1_range", "P" ] ], - universal_type := "Colimit", dual_operation := "EmbeddingOfEqualizerWithGivenEqualizer" ), MorphismFromSourceToCoequalizer := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "morphisms" ], [ "morphisms_1_source", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "MorphismFromEqualizerToSink", return_type := "morphism" ), MorphismFromSourceToCoequalizerWithGivenCoequalizer := rec( filter_list := [ "category", "list_of_morphisms", "object" ], io_type := [ [ "morphisms", "P" ], [ "morphisms_1_source", "P" ] ], - universal_type := "Colimit", dual_operation := "MorphismFromEqualizerToSinkWithGivenEqualizer", return_type := "morphism" ), @@ -1732,7 +1669,6 @@ UniversalMorphismFromCoequalizer := rec( filter_list := [ "category", "list_of_morphisms", "object", "morphism" ], io_type := [ [ "morphisms", "T", "tau" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", return_type := "morphism", dual_operation := "UniversalMorphismIntoEqualizer", @@ -1791,13 +1727,11 @@ UniversalMorphismFromCoequalizer := rec( UniversalMorphismFromCoequalizerWithGivenCoequalizer := rec( filter_list := [ "category", "list_of_morphisms", "object", "morphism", "object" ], io_type := [ [ "morphisms", "T", "tau", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "UniversalMorphismIntoEqualizerWithGivenEqualizer" ), Pushout := rec( filter_list := [ "category", "list_of_morphisms" ], - universal_type := "Colimit", dual_operation := "FiberProduct", pre_function := function( cat, diagram ) @@ -1831,7 +1765,6 @@ InjectionOfCofactorOfPushout := rec( filter_list := [ "category", "list_of_morphisms", IsInt ], io_type := [ [ "morphisms", "k" ], [ "morphisms_k_range", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "ProjectionInFactorOfFiberProduct", pre_function := function( cat, diagram, injection_number ) @@ -1862,7 +1795,6 @@ InjectionOfCofactorOfPushout := rec( InjectionOfCofactorOfPushoutWithGivenPushout := rec( filter_list := [ "category", "list_of_morphisms", IsInt, "object" ], io_type := [ [ "morphisms", "k", "P" ], [ "morphisms_k_range", "P" ] ], - universal_type := "Colimit", dual_operation := "ProjectionInFactorOfFiberProductWithGivenFiberProduct", pre_function := function( cat, diagram, injection_number, pushout ) @@ -1894,7 +1826,6 @@ MorphismFromSourceToPushout := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "morphisms" ], [ "morphisms_1_source", "P" ] ], with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "MorphismFromFiberProductToSink", pre_function := function( cat, diagram ) @@ -1921,7 +1852,6 @@ MorphismFromSourceToPushout := rec( MorphismFromSourceToPushoutWithGivenPushout := rec( filter_list := [ "category", "list_of_morphisms", "object" ], io_type := [ [ "morphisms", "P" ], [ "morphisms_1_source", "P" ] ], - universal_type := "Colimit", dual_operation := "MorphismFromFiberProductToSinkWithGivenFiberProduct", pre_function := function( cat, diagram, pushout ) @@ -1949,7 +1879,6 @@ UniversalMorphismFromPushout := rec( filter_list := [ "category", "list_of_morphisms", "object", "list_of_morphisms" ], io_type := [ [ "morphisms", "T", "tau" ], [ "P", "T" ] ], with_given_object_position := "Source", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoFiberProduct", pre_function := function( cat, diagram, test_object, sink ) @@ -2010,7 +1939,6 @@ UniversalMorphismFromPushout := rec( UniversalMorphismFromPushoutWithGivenPushout := rec( filter_list := [ "category", "list_of_morphisms", "object", "list_of_morphisms", "object" ], io_type := [ [ "morphisms", "T", "tau", "P" ], [ "P", "T" ] ], - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoFiberProductWithGivenFiberProduct", pre_function := function( cat, diagram, test_object, sink, pushout ) @@ -2070,7 +1998,6 @@ UniversalMorphismFromPushoutWithGivenPushout := rec( ImageObject := rec( filter_list := [ "category", "morphism" ], - universal_type := "Limit", return_type := "object", dual_operation := "Coimage" ), @@ -2078,20 +2005,17 @@ ImageEmbedding := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "I", "alpha_range" ] ], with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := "CoimageProjection" ), ImageEmbeddingWithGivenImageObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "I" ], [ "I", "alpha_range" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "CoimageProjectionWithGivenCoimage" ), Coimage := rec( filter_list := [ "category", "morphism" ], - universal_type := "Colimit", return_type := "object", dual_operation := "ImageObject" ), @@ -2099,14 +2023,12 @@ CoimageProjection := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "alpha_source", "C" ] ], with_given_object_position := "Range", - universal_type := "Colimit", return_type := "morphism", dual_operation := "ImageEmbedding" ), CoimageProjectionWithGivenCoimage := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "C" ], [ "alpha_source", "C" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "ImageEmbeddingWithGivenImageObject" ), @@ -2114,14 +2036,12 @@ AstrictionToCoimage := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "C", "alpha_range" ] ], with_given_object_position := "Source", - universal_type := "Colimit", return_type := "morphism", dual_operation := "CoastrictionToImage" ), AstrictionToCoimageWithGivenCoimage := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "C" ], [ "C", "alpha_range" ] ], - universal_type := "Colimit", return_type := "morphism", dual_operation := "CoastrictionToImageWithGivenImageObject" ), @@ -2129,7 +2049,6 @@ UniversalMorphismIntoCoimage := rec( filter_list := [ "category", "morphism", IsList ], io_type := [ [ "alpha", "tau" ], [ "tau_1_range", "C" ] ], with_given_object_position := "Range", - universal_type := "Colimit", dual_preprocessor_func := CAP_INTERNAL_REVERSE_LISTS_IN_ARGUMENTS_FOR_OPPOSITE, pre_function := function( cat, morphism, test_factorization ) local value; @@ -2163,7 +2082,6 @@ UniversalMorphismIntoCoimage := rec( UniversalMorphismIntoCoimageWithGivenCoimage := rec( filter_list := [ "category", "morphism", IsList, "object" ], io_type := [ [ "alpha", "tau", "C" ], [ "tau_1_range", "C" ] ], - universal_type := "Colimit", dual_preprocessor_func := CAP_INTERNAL_REVERSE_LISTS_IN_ARGUMENTS_FOR_OPPOSITE, pre_function := function( cat, morphism, test_factorization, image ) local value; @@ -2393,14 +2311,12 @@ CoastrictionToImage := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "alpha_source", "I" ] ], with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := "AstrictionToCoimage" ), CoastrictionToImageWithGivenImageObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "I" ], [ "alpha_source", "I" ] ], - universal_type := "Limit", return_type := "morphism", dual_operation := "AstrictionToCoimageWithGivenCoimage" ), @@ -2408,7 +2324,6 @@ UniversalMorphismFromImage := rec( filter_list := [ "category", "morphism", IsList ], io_type := [ [ "alpha", "tau" ], [ "I", "tau_1_range" ] ], with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "UniversalMorphismIntoCoimage", dual_preprocessor_func := CAP_INTERNAL_REVERSE_LISTS_IN_ARGUMENTS_FOR_OPPOSITE, pre_function := function( cat, morphism, test_factorization ) @@ -2442,7 +2357,6 @@ UniversalMorphismFromImage := rec( UniversalMorphismFromImageWithGivenImageObject := rec( filter_list := [ "category", "morphism", IsList, "object" ], io_type := [ [ "alpha", "tau", "I" ], [ "I", "tau_1_range" ] ], - universal_type := "Limit", dual_operation := "UniversalMorphismIntoCoimageWithGivenCoimage", dual_preprocessor_func := CAP_INTERNAL_REVERSE_LISTS_IN_ARGUMENTS_FOR_OPPOSITE, pre_function := function( cat, morphism, test_factorization, image ) @@ -2492,14 +2406,14 @@ TerminalObjectFunctorial := rec( ## TODO: io_type? return_type := "morphism", dual_operation := "InitialObjectFunctorial", - no_with_given := true ), +), InitialObjectFunctorial := rec( filter_list := [ "category" ], ## TODO: io_type? return_type := "morphism", dual_operation := "TerminalObjectFunctorial", - no_with_given := true ), +), DirectProductFunctorialWithGivenDirectProducts := rec( filter_list := [ "category", "object", "list_of_objects", "list_of_morphisms", "list_of_objects", "object" ], @@ -2651,154 +2565,154 @@ DirectSumDiagonalDifference := rec( io_type := [ [ "D" ], [ "S", "D_1_range" ] ], return_type := "morphism", dual_operation := "DirectSumCodiagonalDifference", - no_with_given := true ), +), FiberProductEmbeddingInDirectSum := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "P", "S" ] ], return_type := "morphism", dual_operation := "DirectSumProjectionInPushout", - no_with_given := true ), +), IsomorphismFromFiberProductToKernelOfDiagonalDifference := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "P", "Delta" ] ], return_type := "morphism", dual_operation := "IsomorphismFromCokernelOfDiagonalDifferenceToPushout", - no_with_given := true ), +), IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "Delta", "P" ] ], return_type := "morphism", dual_operation := "IsomorphismFromPushoutToCokernelOfDiagonalDifference", - no_with_given := true ), +), IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "P", "Delta" ] ], return_type := "morphism", dual_operation := "IsomorphismFromCoequalizerOfCoproductDiagramToPushout", - no_with_given := true ), +), IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "Delta", "P" ] ], return_type := "morphism", dual_operation := "IsomorphismFromPushoutToCoequalizerOfCoproductDiagram", - no_with_given := true ), +), IsomorphismFromPushoutToCokernelOfDiagonalDifference := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "I", "Delta" ] ], return_type := "morphism", dual_operation := "IsomorphismFromKernelOfDiagonalDifferenceToFiberProduct", - no_with_given := true ), +), IsomorphismFromCokernelOfDiagonalDifferenceToPushout := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "Delta", "I" ] ], return_type := "morphism", dual_operation := "IsomorphismFromFiberProductToKernelOfDiagonalDifference", - no_with_given := true ), +), IsomorphismFromPushoutToCoequalizerOfCoproductDiagram := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "P", "Delta" ] ], return_type := "morphism", dual_operation := "IsomorphismFromEqualizerOfDirectProductDiagramToFiberProduct", - no_with_given := true ), +), IsomorphismFromCoequalizerOfCoproductDiagramToPushout := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "Delta", "P" ] ], return_type := "morphism", dual_operation := "IsomorphismFromFiberProductToEqualizerOfDirectProductDiagram", - no_with_given := true ), +), IsomorphismFromImageObjectToKernelOfCokernel := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "I", "P" ] ], return_type := "morphism", dual_operation := "IsomorphismFromCokernelOfKernelToCoimage", - no_with_given := true ), +), IsomorphismFromKernelOfCokernelToImageObject := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "P", "I" ] ], return_type := "morphism", dual_operation := "IsomorphismFromCoimageToCokernelOfKernel", - no_with_given := true ), +), IsomorphismFromCoimageToCokernelOfKernel := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "CI", "C" ] ], return_type := "morphism", dual_operation := "IsomorphismFromKernelOfCokernelToImageObject", - no_with_given := true ), +), IsomorphismFromCokernelOfKernelToCoimage := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "I", "CI" ] ], return_type := "morphism", dual_operation := "IsomorphismFromImageObjectToKernelOfCokernel", - no_with_given := true ), +), CanonicalIdentificationFromImageObjectToCoimage := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "I", "C" ] ], return_type := "morphism", dual_operation := "CanonicalIdentificationFromCoimageToImageObject", - no_with_given := true ), +), CanonicalIdentificationFromCoimageToImageObject := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "C", "I" ] ], return_type := "morphism", dual_operation := "CanonicalIdentificationFromImageObjectToCoimage", - no_with_given := true ), +), IsomorphismFromDirectSumToDirectProduct := rec( filter_list := [ "category", "list_of_objects" ], io_type := [ [ "D" ], [ "S", "P" ] ], return_type := "morphism", dual_operation := "IsomorphismFromCoproductToDirectSum", - no_with_given := true ), +), IsomorphismFromDirectSumToCoproduct := rec( filter_list := [ "category", "list_of_objects" ], io_type := [ [ "D" ], [ "S", "C" ] ], return_type := "morphism", dual_operation := "IsomorphismFromDirectProductToDirectSum", - no_with_given := true ), +), IsomorphismFromDirectProductToDirectSum := rec( filter_list := [ "category", "list_of_objects" ], io_type := [ [ "D" ], [ "P", "S" ] ], return_type := "morphism", dual_operation := "IsomorphismFromDirectSumToCoproduct", - no_with_given := true ), +), IsomorphismFromCoproductToDirectSum := rec( filter_list := [ "category", "list_of_objects" ], io_type := [ [ "D" ], [ "C", "S" ] ], return_type := "morphism", dual_operation := "IsomorphismFromDirectSumToDirectProduct", - no_with_given := true ), +), DirectSumCodiagonalDifference := rec( io_type := [ [ "D" ], [ "D_1_source", "S" ] ], filter_list := [ "category", "list_of_morphisms" ], return_type := "morphism", dual_operation := "DirectSumDiagonalDifference", - no_with_given := true ), +), DirectSumProjectionInPushout := rec( filter_list := [ "category", "list_of_morphisms" ], io_type := [ [ "D" ], [ "S", "I" ] ], return_type := "morphism", dual_operation := "FiberProductEmbeddingInDirectSum", - no_with_given := true ), +), SomeProjectiveObject := rec( filter_list := [ "category", "object" ], @@ -2810,7 +2724,6 @@ EpimorphismFromSomeProjectiveObject := rec( filter_list := [ "category", "object" ], io_type := [ [ "A" ], [ "P", "A" ] ], with_given_object_position := "Source", - universal_type := "Limit", #FIXME: this is not a limit, but on a technical level, it behaves as if it was return_type := "morphism", dual_operation := "MonomorphismIntoSomeInjectiveObject", is_merely_set_theoretic := true ), @@ -2818,7 +2731,6 @@ EpimorphismFromSomeProjectiveObject := rec( EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "A", "P" ], [ "P", "A" ] ], - universal_type := "Limit", #FIXME: this is not a limit, but on a technical level, it behaves as if it was return_type := "morphism", dual_operation := "MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject", is_merely_set_theoretic := true ), @@ -2833,7 +2745,6 @@ MonomorphismIntoSomeInjectiveObject := rec( filter_list := [ "category", "object" ], io_type := [ [ "A" ], [ "A", "I" ] ], with_given_object_position := "Range", - universal_type := "Colimit", #FIXME: this is not a colimit, but on a technical level, it behaves as if it was return_type := "morphism", dual_operation := "EpimorphismFromSomeProjectiveObject", is_merely_set_theoretic := true ), @@ -2841,7 +2752,6 @@ MonomorphismIntoSomeInjectiveObject := rec( MonomorphismIntoSomeInjectiveObjectWithGivenSomeInjectiveObject := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "A", "I" ], [ "A", "I" ] ], - universal_type := "Colimit", #FIXME: this is not a colimit, but on a technical level, it behaves as if it was return_type := "morphism", dual_operation := "EpimorphismFromSomeProjectiveObjectWithGivenSomeProjectiveObject", is_merely_set_theoretic := true ), @@ -3735,7 +3645,7 @@ end ); InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, function ( method_name_record, limits ) - local make_record_with_given, make_colimit, object_universal_type, object_filter_list, projection_filter_list, projection_io_type, morphism_to_sink_filter_list, morphism_to_sink_io_type, universal_morphism_filter_list, universal_morphism_io_type, object_record, projection_record, morphism_to_sink_record, filter_list, io_type, with_given_object_position, universal_type, return_type, dual_operation, universal_morphism_record, functorial_record, no_with_given, dual_arguments_reversed, limit; + local make_record_with_given, make_colimit, object_filter_list, projection_filter_list, projection_io_type, morphism_to_sink_filter_list, morphism_to_sink_io_type, universal_morphism_filter_list, universal_morphism_io_type, object_record, projection_record, morphism_to_sink_record, filter_list, io_type, with_given_object_position, return_type, dual_operation, universal_morphism_record, functorial_record, dual_arguments_reversed, limit; #### helper functions make_record_with_given := function ( record, object_name, coobject_name ) @@ -3786,24 +3696,12 @@ InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, record.with_given_object_position := "Source"; fi; fi; - - if IsBound( record.universal_type ) then - if record.universal_type = "Limit" then - record.universal_type := "Colimit"; - fi; - fi; - + return record; end; for limit in limits do - #### get universal type - if limit.limit_object_name = limit.colimit_object_name then - object_universal_type := "LimitColimit"; - else - object_universal_type := "Limit"; - fi; - + #### get filter lists and io types object_filter_list := Concatenation( [ "category" ], StructuralCopy( limit.diagram_filter_list ) ); @@ -3867,7 +3765,6 @@ InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, object_record := rec( function_name := limit.limit_object_name, filter_list := object_filter_list, - universal_type := object_universal_type, return_type := "object", dual_operation := limit.colimit_object_name, ); @@ -3878,7 +3775,6 @@ InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, filter_list := projection_filter_list, io_type := projection_io_type, with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := limit.colimit_injection_name, ); @@ -3890,7 +3786,6 @@ InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, filter_list := morphism_to_sink_filter_list, io_type := morphism_to_sink_io_type, with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := limit.colimit_morphism_from_source_name, ); @@ -3901,7 +3796,6 @@ InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, filter_list := universal_morphism_filter_list, io_type := universal_morphism_io_type, with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := limit.colimit_universal_morphism_name, ); @@ -3912,7 +3806,6 @@ InstallGlobalFunction( CAP_INTERNAL_VALIDATE_LIMITS_IN_NAME_RECORD, filter_list := [ "category" ], return_type := "morphism", dual_operation := limit.colimit_functorial_name, - no_with_given := true, ); else functorial_record := rec( diff --git a/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi b/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi index 98fa5f1047..1229fceb0a 100644 --- a/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi +++ b/FreydCategoriesForCAP/gap/FreydCategoriesForCAP.gi @@ -153,7 +153,6 @@ InstallValue( FREYD_CATEGORIES_METHOD_NAME_RECORD, rec( WeakKernelObject := rec( filter_list := [ "category", "morphism" ], - universal_type := "Limit", return_type := "object", dual_operation := "WeakCokernelObject", is_merely_set_theoretic := true ), @@ -162,7 +161,6 @@ WeakKernelEmbedding := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "K", "alpha_source" ] ], with_given_object_position := "Source", - universal_type := "Limit", return_type := "morphism", dual_operation := "WeakCokernelProjection", is_merely_set_theoretic := true ), @@ -171,7 +169,6 @@ WeakKernelEmbeddingWithGivenWeakKernelObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "K" ], [ "K", "alpha_source" ] ], cache_name := "WeakKernelEmbeddingWithGivenWeakKernelObject", - universal_type := "Limit", return_type := "morphism", dual_operation := "WeakCokernelProjectionWithGivenWeakCokernelObject", is_merely_set_theoretic := true ), @@ -181,7 +178,6 @@ WeakKernelLift := rec( io_type := [ [ "alpha", "tau" ], [ "tau_source", "K" ] ], cache_name := "WeakKernelLift", with_given_object_position := "Range", - universal_type := "Limit", return_type := "morphism", dual_operation := "WeakCokernelColift", is_merely_set_theoretic := true ), @@ -190,7 +186,6 @@ WeakKernelLiftWithGivenWeakKernelObject := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "alpha", "tau", "K" ], [ "tau_source", "K" ] ], cache_name := "WeakKernelLiftWithGivenWeakKernelObject", - universal_type := "Limit", return_type := "morphism", dual_operation := "WeakCokernelColiftWithGivenWeakCokernelObject", is_merely_set_theoretic := true ), @@ -199,7 +194,6 @@ WeakKernelLiftWithGivenWeakKernelObject := rec( WeakCokernelObject := rec( filter_list := [ "category", "morphism" ], - universal_type := "Colimit", return_type := "object", dual_operation := "WeakKernelObject", is_merely_set_theoretic := true ), @@ -208,7 +202,6 @@ WeakCokernelProjection := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "alpha_range", "K" ] ], with_given_object_position := "Range", - universal_type := "Colimit", return_type := "morphism", dual_operation := "WeakKernelEmbedding", is_merely_set_theoretic := true ), @@ -217,7 +210,6 @@ WeakCokernelProjectionWithGivenWeakCokernelObject := rec( filter_list := [ "category", "morphism", "object" ], io_type := [ [ "alpha", "K" ], [ "alpha_range", "K" ] ], cache_name := "WeakCokernelProjectionWithGivenWeakCokernelObject", - universal_type := "Colimit", return_type := "morphism", dual_operation := "WeakKernelEmbeddingWithGivenWeakKernelObject", is_merely_set_theoretic := true ), @@ -227,7 +219,6 @@ WeakCokernelColift := rec( io_type := [ [ "alpha", "tau" ], [ "K", "tau_range" ] ], cache_name := "WeakCokernelColift", with_given_object_position := "Source", - universal_type := "Colimit", return_type := "morphism", dual_operation := "WeakKernelLift", is_merely_set_theoretic := true ), @@ -236,18 +227,15 @@ WeakCokernelColiftWithGivenWeakCokernelObject := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "alpha", "tau", "K" ], [ "K", "tau_range" ] ], cache_name := "WeakCokernelColiftWithGivenWeakCokernelObject", - universal_type := "Colimit", return_type := "morphism", dual_operation := "WeakKernelLiftWithGivenWeakKernelObject", is_merely_set_theoretic := true ), ## Weak bi-fiber product -## FIXME: create universal_type substitute WeakBiFiberProduct := rec( filter_list := [ "category", "morphism", "morphism" ], cache_name := "WeakBiFiberProduct", - universal_type := "Limit", dual_operation := "WeakBiPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "object", @@ -258,7 +246,6 @@ ProjectionInFirstFactorOfWeakBiFiberProduct := rec( io_type := [ [ "a", "b" ], [ "P", "a_source" ] ], cache_name := "ProjectionInFirstFactorOfWeakBiFiberProduct", with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "InjectionOfFirstCofactorOfWeakBiPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -268,7 +255,6 @@ ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "P" ], [ "P", "a_source" ] ], cache_name := "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - universal_type := "Limit", dual_operation := "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -279,7 +265,6 @@ ProjectionInSecondFactorOfWeakBiFiberProduct := rec( io_type := [ [ "a", "b" ], [ "P", "b_source" ] ], cache_name := "ProjectionInSecondFactorOfWeakBiFiberProduct", with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "InjectionOfSecondCofactorOfWeakBiPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -289,7 +274,6 @@ ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "P" ], [ "P", "b_source" ] ], cache_name := "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", - universal_type := "Limit", dual_operation := "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -300,7 +284,6 @@ UniversalMorphismIntoWeakBiFiberProduct := rec( io_type := [ [ "a", "b", "t", "s" ], [ "t_source", "P" ] ], cache_name := "UniversalMorphismIntoWeakBiFiberProduct", with_given_object_position := "Range", - universal_type := "Limit", dual_operation := "UniversalMorphismFromWeakBiPushout", pre_function := UNIVERSAL_MORPHISM_INTO_WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -310,7 +293,6 @@ UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct := rec( filter_list := [ "category", "morphism", "morphism", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "t", "s", "P", ], [ "t_source", "P" ] ], cache_name := "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", - universal_type := "Limit", dual_operation := "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", pre_function := UNIVERSAL_MORPHISM_INTO_WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -322,14 +304,13 @@ WeakBiFiberProductMorphismToDirectSum := rec( cache_name := "WeakBiFiberProductMorphismToDirectSum", return_type := "morphism", dual_operation := "DirectSumMorphismToWeakBiPushout", - no_with_given := true ), +), ## Weak pushouts WeakBiPushout := rec( filter_list := [ "category", "morphism", "morphism" ], cache_name := "WeakBiPushout", - universal_type := "Colimit", dual_operation := "WeakBiFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "object", @@ -340,7 +321,6 @@ InjectionOfFirstCofactorOfWeakBiPushout := rec( io_type := [ [ "a", "b" ], [ "a_range", "P" ] ], cache_name := "InjectionOfFirstCofactorOfWeakBiPushout", with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "ProjectionInFirstFactorOfWeakBiFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -350,7 +330,6 @@ InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "P" ], [ "a_range", "P" ] ], cache_name := "InjectionOfFirstCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - universal_type := "Colimit", dual_operation := "ProjectionInFirstFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -361,7 +340,6 @@ InjectionOfSecondCofactorOfWeakBiPushout := rec( io_type := [ [ "a", "b" ], [ "b_range", "P" ] ], cache_name := "InjectionOfSecondCofactorOfWeakBiPushout", with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "ProjectionInSecondFactorOfWeakBiFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -371,7 +349,6 @@ InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "P" ], [ "b_range", "P" ] ], cache_name := "InjectionOfSecondCofactorOfWeakBiPushoutWithGivenWeakBiPushout", - universal_type := "Colimit", dual_operation := "ProjectionInSecondFactorOfWeakBiFiberProductWithGivenWeakBiFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -382,7 +359,6 @@ UniversalMorphismFromWeakBiPushout := rec( io_type := [ [ "a", "b", "t", "s" ], [ "P", "t_range" ] ], cache_name := "UniversalMorphismFromWeakBiPushout", with_given_object_position := "Source", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoWeakBiFiberProduct", pre_function := UNIVERSAL_MORPHISM_FROM_WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -392,7 +368,6 @@ UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout := rec( filter_list := [ "category", "morphism", "morphism", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "t", "s", "P", ], [ "P", "t_range" ] ], cache_name := "UniversalMorphismFromWeakBiPushoutWithGivenWeakBiPushout", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoWeakBiFiberProductWithGivenWeakBiFiberProduct", pre_function := UNIVERSAL_MORPHISM_FROM_WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -404,15 +379,13 @@ DirectSumMorphismToWeakBiPushout := rec( cache_name := "DirectSumMorphismToWeakBiPushout", return_type := "morphism", dual_operation := "WeakBiFiberProductMorphismToDirectSum", - no_with_given := true ), +), ## biased weak fiber product -## FIXME: create universal_type substitute BiasedWeakFiberProduct := rec( filter_list := [ "category", "morphism", "morphism" ], cache_name := "BiasedWeakFiberProduct", - universal_type := "Limit", dual_operation := "BiasedWeakPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "object", @@ -423,7 +396,6 @@ ProjectionOfBiasedWeakFiberProduct := rec( io_type := [ [ "a", "b" ], [ "P", "a_source" ] ], cache_name := "ProjectionOfBiasedWeakFiberProduct", with_given_object_position := "Source", - universal_type := "Limit", dual_operation := "InjectionOfBiasedWeakPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -433,7 +405,6 @@ ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "P" ], [ "P", "a_source" ] ], cache_name := "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - universal_type := "Limit", dual_operation := "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", pre_function := WEAK_BI_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -444,7 +415,6 @@ UniversalMorphismIntoBiasedWeakFiberProduct := rec( io_type := [ [ "a", "b", "t" ], [ "t_source", "P" ] ], cache_name := "UniversalMorphismIntoBiasedWeakFiberProduct", with_given_object_position := "Range", - universal_type := "Limit", dual_operation := "UniversalMorphismFromBiasedWeakPushout", pre_function := UNIVERSAL_MORPHISM_INTO_BIASED_WEAK_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -454,7 +424,6 @@ UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct := re filter_list := [ "category", "morphism", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "t", "P", ], [ "t_source", "P" ] ], cache_name := "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", - universal_type := "Limit", dual_operation := "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", pre_function := UNIVERSAL_MORPHISM_INTO_BIASED_WEAK_FIBER_PRODUCT_PREFUNCTION, return_type := "morphism", @@ -467,7 +436,6 @@ UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct := re BiasedWeakPushout := rec( filter_list := [ "category", "morphism", "morphism" ], cache_name := "BiasedWeakPushout", - universal_type := "Colimit", dual_operation := "BiasedWeakFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "object", @@ -478,7 +446,6 @@ InjectionOfBiasedWeakPushout := rec( io_type := [ [ "a", "b" ], [ "a_range", "P" ] ], cache_name := "InjectionOfBiasedWeakPushout", with_given_object_position := "Range", - universal_type := "Colimit", dual_operation := "ProjectionOfBiasedWeakFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -488,7 +455,6 @@ InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout := rec( filter_list := [ "category", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "P" ], [ "a_range", "P" ] ], cache_name := "InjectionOfBiasedWeakPushoutWithGivenBiasedWeakPushout", - universal_type := "Colimit", dual_operation := "ProjectionOfBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", pre_function := WEAK_BI_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -499,7 +465,6 @@ UniversalMorphismFromBiasedWeakPushout := rec( io_type := [ [ "a", "b", "t" ], [ "P", "t_range" ] ], cache_name := "UniversalMorphismFromBiasedWeakPushout", with_given_object_position := "Source", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoBiasedWeakFiberProduct", pre_function := UNIVERSAL_MORPHISM_FROM_BIASED_WEAK_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -509,7 +474,6 @@ UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout := rec( filter_list := [ "category", "morphism", "morphism", "morphism", "object" ], io_type := [ [ "a", "b", "t", "P", ], [ "P", "t_range" ] ], cache_name := "UniversalMorphismFromBiasedWeakPushoutWithGivenBiasedWeakPushout", - universal_type := "Colimit", dual_operation := "UniversalMorphismIntoBiasedWeakFiberProductWithGivenBiasedWeakFiberProduct", pre_function := UNIVERSAL_MORPHISM_FROM_BIASED_WEAK_PUSHOUT_PREFUNCTION, return_type := "morphism", @@ -526,7 +490,6 @@ EpimorphismFromSomeProjectiveObjectForKernelObject := rec( filter_list := [ "category", "morphism" ], input_arguments_names := [ "cat", "alpha" ], with_given_object_position := "Source", - universal_type := "Limit", #FIXME: this is not a limit, but on a technical level, it behaves as if it was return_type := "morphism", dual_operation := "MonomorphismToSomeInjectiveObjectForCokernelObject", is_merely_set_theoretic := true ), @@ -534,7 +497,6 @@ EpimorphismFromSomeProjectiveObjectForKernelObject := rec( EpimorphismFromSomeProjectiveObjectForKernelObjectWithGivenSomeProjectiveObjectForKernelObject := rec( filter_list := [ "category", "morphism", "object" ], input_arguments_names := [ "cat", "alpha", "source" ], - universal_type := "Limit", #FIXME: this is not a limit, but on a technical level, it behaves as if it was cache_name := "EpimorphismFromSomeProjectiveObjectForKernelObjectWithGivenSomeProjectiveObjectForKernelObject", return_type := "morphism", output_source_getter_string := "source", @@ -551,7 +513,6 @@ MonomorphismToSomeInjectiveObjectForCokernelObject := rec( filter_list := [ "category", "morphism" ], input_arguments_names := [ "cat", "alpha" ], with_given_object_position := "Range", - universal_type := "Colimit", #FIXME: this is not a colimit, but on a technical level, it behaves as if it was return_type := "morphism", dual_operation := "EpimorphismFromSomeProjectiveObjectForKernelObject", is_merely_set_theoretic := true ), @@ -559,7 +520,6 @@ MonomorphismToSomeInjectiveObjectForCokernelObject := rec( MonomorphismToSomeInjectiveObjectForCokernelObjectWithGivenSomeInjectiveObjectForCokernelObject := rec( filter_list := [ "category", "morphism", "object" ], input_arguments_names := [ "cat", "alpha", "range" ], - universal_type := "Colift", #FIXME: this is not a limit, but on a technical level, it behaves as if it was cache_name := "MonomorphismToSomeInjectiveObjectForCokernelObjectWithGivenSomeInjectiveObjectForCokernelObject", return_type := "morphism", output_range_getter_string := "range", diff --git a/MonoidalCategories/gap/ClosedMonoidalCategoriesMethodRecord.gi b/MonoidalCategories/gap/ClosedMonoidalCategoriesMethodRecord.gi index cb9126942c..df859125b3 100644 --- a/MonoidalCategories/gap/ClosedMonoidalCategoriesMethodRecord.gi +++ b/MonoidalCategories/gap/ClosedMonoidalCategoriesMethodRecord.gi @@ -48,13 +48,13 @@ TensorProductToInternalHomAdjunctionMap := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "a", "b", "f" ], [ "a", "i" ] ], return_type := "morphism", - no_with_given := true ), +), InternalHomToTensorProductAdjunctionMap := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "b", "c", "g" ], [ "t", "c" ] ], return_type := "morphism", - no_with_given := true ), +), MonoidalPreComposeMorphism := rec( filter_list := [ "category", "object", "object", "object" ], @@ -171,31 +171,31 @@ IsomorphismFromInternalHomToDual := rec( filter_list := [ "category", "object" ], io_type := [ [ "a" ], [ "i", "d" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromDualToInternalHom := rec( filter_list := [ "category", "object" ], io_type := [ [ "a" ], [ "d", "i" ] ], return_type := "morphism", - no_with_given := true ), +), UniversalPropertyOfDual := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "t", "a", "alpha" ], [ "t", "d" ] ], return_type := "morphism", - no_with_given := true ), +), LambdaIntroduction := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "u", "i" ] ], return_type := "morphism", - no_with_given := true ), +), LambdaElimination := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "a", "b", "alpha" ], [ "a", "b" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromObjectToInternalHom := rec( filter_list := [ "category", "object" ], diff --git a/MonoidalCategories/gap/CoclosedMonoidalCategoriesMethodRecord.gi b/MonoidalCategories/gap/CoclosedMonoidalCategoriesMethodRecord.gi index aedd747523..9e3b6e4cad 100644 --- a/MonoidalCategories/gap/CoclosedMonoidalCategoriesMethodRecord.gi +++ b/MonoidalCategories/gap/CoclosedMonoidalCategoriesMethodRecord.gi @@ -48,13 +48,13 @@ InternalCoHomToTensorProductAdjunctionMap := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "a", "b", "f" ], [ "a", "t" ] ], return_type := "morphism", - no_with_given := true ), +), TensorProductToInternalCoHomAdjunctionMap := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "b", "c", "g" ], [ "i", "c" ] ], return_type := "morphism", - no_with_given := true ), +), MonoidalPreCoComposeMorphism := rec( filter_list := [ "category", "object", "object", "object" ], @@ -171,31 +171,31 @@ IsomorphismFromCoDualToInternalCoHom := rec( filter_list := [ "category", "object" ], io_type := [ [ "a" ], [ "i", "d" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromInternalCoHomToCoDual := rec( filter_list := [ "category", "object" ], io_type := [ [ "a" ], [ "d", "i" ] ], return_type := "morphism", - no_with_given := true ), +), UniversalPropertyOfCoDual := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "a", "t", "alpha" ], [ "d", "t" ] ], return_type := "morphism", - no_with_given := true ), +), CoLambdaIntroduction := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "u", "i" ] ], return_type := "morphism", - no_with_given := true ), +), CoLambdaElimination := rec( filter_list := [ "category", "object", "object", "morphism" ], io_type := [ [ "a", "b", "alpha" ], [ "a", "b" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromObjectToInternalCoHom := rec( filter_list := [ "category", "object" ], diff --git a/MonoidalCategories/gap/RigidSymmetricClosedMonoidalCategoriesMethodRecord.gi b/MonoidalCategories/gap/RigidSymmetricClosedMonoidalCategoriesMethodRecord.gi index c7a2cc9049..d5bffe9a18 100644 --- a/MonoidalCategories/gap/RigidSymmetricClosedMonoidalCategoriesMethodRecord.gi +++ b/MonoidalCategories/gap/RigidSymmetricClosedMonoidalCategoriesMethodRecord.gi @@ -58,25 +58,25 @@ TraceMap := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "u", "u" ] ], return_type := "morphism", - no_with_given := true ), +), RankMorphism := rec( filter_list := [ "category", "object" ], io_type := [ [ "a" ], [ "u", "u" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromTensorProductToInternalHom := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "a", "b" ], [ "t", "i" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromInternalHomToTensorProduct := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "a", "b" ], [ "i", "t" ] ], return_type := "morphism", - no_with_given := true ), +), ) ); diff --git a/MonoidalCategories/gap/RigidSymmetricCoclosedMonoidalCategoriesMethodRecord.gi b/MonoidalCategories/gap/RigidSymmetricCoclosedMonoidalCategoriesMethodRecord.gi index 0cd1c62132..c270df64f0 100644 --- a/MonoidalCategories/gap/RigidSymmetricCoclosedMonoidalCategoriesMethodRecord.gi +++ b/MonoidalCategories/gap/RigidSymmetricCoclosedMonoidalCategoriesMethodRecord.gi @@ -58,25 +58,25 @@ CoTraceMap := rec( filter_list := [ "category", "morphism" ], io_type := [ [ "alpha" ], [ "u", "u" ] ], return_type := "morphism", - no_with_given := true ), +), CoRankMorphism := rec( filter_list := [ "category", "object" ], io_type := [ [ "a" ], [ "u", "u" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromInternalCoHomToTensorProduct := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "a", "b" ], [ "i", "t" ] ], return_type := "morphism", - no_with_given := true ), +), IsomorphismFromTensorProductToInternalCoHom := rec( filter_list := [ "category", "object", "object" ], io_type := [ [ "a", "b" ], [ "t", "i" ] ], return_type := "morphism", - no_with_given := true ), +), ) ); From 84f819b022be05af68b2999191e724b94b372831 Mon Sep 17 00:00:00 2001 From: Fabian Zickgraf Date: Tue, 26 Oct 2021 11:36:01 +0200 Subject: [PATCH 8/8] Bump versions --- ActionsForCAP/PackageInfo.g | 10 +--------- AttributeCategoryForCAP/PackageInfo.g | 2 +- CAP/PackageInfo.g | 2 +- CompilerForCAP/PackageInfo.g | 2 +- FreydCategoriesForCAP/PackageInfo.g | 2 +- GeneralizedMorphismsForCAP/PackageInfo.g | 11 +---------- MonoidalCategories/PackageInfo.g | 2 +- 7 files changed, 7 insertions(+), 24 deletions(-) diff --git a/ActionsForCAP/PackageInfo.g b/ActionsForCAP/PackageInfo.g index f8e2391c9a..4f8f4288c2 100644 --- a/ActionsForCAP/PackageInfo.g +++ b/ActionsForCAP/PackageInfo.g @@ -11,15 +11,7 @@ SetPackageInfo( rec( PackageName := "ActionsForCAP", Subtitle := "Actions and Coactions for CAP", -Version := Maximum( [ - "2019.09-16", ## Mohamed's version - ## this line prevents merge conflicts - "2015.08-19", ## Sebas' version - ## this line prevents merge conflicts - "2017.01-11", ## Sepp's version - ## this line prevents merge conflicts - "2020.10-01", ## Fabian's version -] ), +Version := "2021.10-01", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later", diff --git a/AttributeCategoryForCAP/PackageInfo.g b/AttributeCategoryForCAP/PackageInfo.g index 9a43c85f37..be8e2c23ca 100644 --- a/AttributeCategoryForCAP/PackageInfo.g +++ b/AttributeCategoryForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "AttributeCategoryForCAP", Subtitle := "Automatic enhancement with attributes of a CAP category", -Version := "2021.08-01", +Version := "2021.10-01", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later", diff --git a/CAP/PackageInfo.g b/CAP/PackageInfo.g index 8d89b1ef0b..bc1c35ac53 100644 --- a/CAP/PackageInfo.g +++ b/CAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "CAP", Subtitle := "Categories, Algorithms, Programming", -Version := "2021.10-04", +Version := "2021.10-05", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later", diff --git a/CompilerForCAP/PackageInfo.g b/CompilerForCAP/PackageInfo.g index 7f4dd213bd..5e7e9078eb 100644 --- a/CompilerForCAP/PackageInfo.g +++ b/CompilerForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "CompilerForCAP", Subtitle := "Speed up computations in CAP categories", -Version := "2021.10-04", +Version := "2021.10-05", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later", diff --git a/FreydCategoriesForCAP/PackageInfo.g b/FreydCategoriesForCAP/PackageInfo.g index e173e8ff64..2649694bb4 100644 --- a/FreydCategoriesForCAP/PackageInfo.g +++ b/FreydCategoriesForCAP/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "FreydCategoriesForCAP", Subtitle := "Freyd categories - Formal (co)kernels for additive categories", -Version := "2021.10-04", +Version := "2021.10-05", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later", diff --git a/GeneralizedMorphismsForCAP/PackageInfo.g b/GeneralizedMorphismsForCAP/PackageInfo.g index 7413eb1655..24a26d777e 100644 --- a/GeneralizedMorphismsForCAP/PackageInfo.g +++ b/GeneralizedMorphismsForCAP/PackageInfo.g @@ -3,16 +3,7 @@ SetPackageInfo( rec( PackageName := "GeneralizedMorphismsForCAP", Subtitle := "Implementations of generalized morphisms for the CAP project", -Version := Maximum( [ - "2017.12-30", ## Sebas' version -## this line prevents merge conflicts - "2020.04-16", ## Sepp's version -## this line prevents merge conflicts - "2020.04-29", ## Mohamed's version -## this line prevents merge conflicts - "2021.05-01", ## Fabian's version -## this line prevents merge conflicts - ] ), +Version := "2021.10-01", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later", diff --git a/MonoidalCategories/PackageInfo.g b/MonoidalCategories/PackageInfo.g index a2226c4cc0..d85d17667c 100644 --- a/MonoidalCategories/PackageInfo.g +++ b/MonoidalCategories/PackageInfo.g @@ -10,7 +10,7 @@ SetPackageInfo( rec( PackageName := "MonoidalCategories", Subtitle := "Monoidal and monoidal (co)closed categories", -Version := "2021.08-02", +Version := "2021.10-01", Date := Concatenation( "01/", ~.Version{[ 6, 7 ]}, "/", ~.Version{[ 1 .. 4 ]} ), License := "GPL-2.0-or-later",