Package evaluation of FreydCategoriesForCAP on Julia 1.12.0-DEV.1805 (a080deafdd*) started at 2025-03-24T13:42:54.613


################################################################################
# Set-up
#

Installing PkgEval dependencies (TestEnv)...

Set-up completed after 8.66s


################################################################################
# Installation
#

Installing FreydCategoriesForCAP...
   Resolving package versions...
    Updating `~/.julia/environments/v1.12/Project.toml`
  [cec356e3] + FreydCategoriesForCAP v0.1.2
    Updating `~/.julia/environments/v1.12/Manifest.toml`
  [c3fe647b] + AbstractAlgebra v0.44.10
  [d64df2ee] + CAP v0.3.3
  [cec356e3] + FreydCategoriesForCAP v0.1.2
  [692b3bcd] + JLLWrappers v1.7.0
  [3dc4824f] + LinearAlgebraForCAP v0.1.2
  [1914dd2f] + MacroTools v0.5.15
  [29b9b1b6] + MatricesForHomalg v0.1.1
  [bfd98c86] + MonoidalCategories v0.1.3
  [2edaba10] + Nemo v0.49.3
  [21216c6a] + Preferences v1.4.3
  [fb686558] + RandomExtensions v0.4.4
  [e134572f] + FLINT_jll v300.200.100+0
  [656ef2d0] + OpenBLAS32_jll v0.3.29+0
  [56f22d72] + Artifacts v1.11.0
  [2a0f44e3] + Base64 v1.11.0
  [ade2ca70] + Dates v1.11.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] + LinearAlgebra v1.11.0
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v0.7.0
  [9e88b42a] + Serialization v1.11.0
  [2f01184e] + SparseArrays v1.12.0
  [fa267f1f] + TOML v1.0.3
  [4ec0a83e] + Unicode v1.11.0
  [e66e0078] + CompilerSupportLibraries_jll v1.2.0+0
  [781609d7] + GMP_jll v6.3.0+1
  [3a97d323] + MPFR_jll v4.2.1+1
  [4536629a] + OpenBLAS_jll v0.3.28+3
  [bea87d4a] + SuiteSparse_jll v7.8.0+1
  [8e850b90] + libblastrampoline_jll v5.11.2+0

Installation completed after 1.62s


################################################################################
# Precompilation
#

Precompiling PkgEval dependencies...

Precompiling package dependencies...

Precompilation completed after 121.66s


################################################################################
# Testing
#

     Testing FreydCategoriesForCAP
      Status `/tmp/jl_3tdDlf/Project.toml`
  [d64df2ee] CAP v0.3.3
  [c5961c08] CartesianCategories v0.1.3
  [e30172f5] Documenter v1.9.0
  [0a079e9b] FinSetsForCAP v0.1.4
  [cec356e3] FreydCategoriesForCAP v0.1.2
  [3dc4824f] LinearAlgebraForCAP v0.1.2
  [29b9b1b6] MatricesForHomalg v0.1.1
  [bfd98c86] MonoidalCategories v0.1.3
  [36a15fe6] Toposes v0.1.4
  [8dfed614] Test v1.11.0
      Status `/tmp/jl_3tdDlf/Manifest.toml`
  [a4c015fc] ANSIColoredPrinters v0.0.1
  [c3fe647b] AbstractAlgebra v0.44.10
  [1520ce14] AbstractTrees v0.4.5
  [d64df2ee] CAP v0.3.3
  [c5961c08] CartesianCategories v0.1.3
  [944b1d66] CodecZlib v0.7.8
  [ffbed154] DocStringExtensions v0.9.3
  [e30172f5] Documenter v1.9.0
  [0a079e9b] FinSetsForCAP v0.1.4
  [cec356e3] FreydCategoriesForCAP v0.1.2
  [d7ba0133] Git v1.3.1
  [b5f81e59] IOCapture v0.2.5
  [692b3bcd] JLLWrappers v1.7.0
  [682c06a0] JSON v0.21.4
  [0e77f7df] LazilyInitializedFields v1.3.0
  [3dc4824f] LinearAlgebraForCAP v0.1.2
  [1914dd2f] MacroTools v0.5.15
  [d0879d2d] MarkdownAST v0.1.2
  [29b9b1b6] MatricesForHomalg v0.1.1
  [bfd98c86] MonoidalCategories v0.1.3
  [2edaba10] Nemo v0.49.3
  [69de0a69] Parsers v2.8.1
  [aea7be01] PrecompileTools v1.2.1
  [21216c6a] Preferences v1.4.3
  [fb686558] RandomExtensions v0.4.4
  [2792f1a3] RegistryInstances v0.1.0
  [36a15fe6] Toposes v0.1.4
  [3bb67fe8] TranscodingStreams v0.11.3
  [2e619515] Expat_jll v2.6.5+0
  [e134572f] FLINT_jll v300.200.100+0
  [f8c6e375] Git_jll v2.47.1+0
  [94ce4f54] Libiconv_jll v1.18.0+0
  [656ef2d0] OpenBLAS32_jll v0.3.29+0
  [458c3c95] OpenSSL_jll v3.0.16+0
  [0dad84c5] ArgTools v1.1.2
  [56f22d72] Artifacts v1.11.0
  [2a0f44e3] Base64 v1.11.0
  [ade2ca70] Dates v1.11.0
  [f43a241f] Downloads v1.6.0
  [7b1f6079] FileWatching v1.11.0
  [b77e0a4c] InteractiveUtils v1.11.0
  [dc6e5ff7] JuliaSyntaxHighlighting v1.12.0
  [b27032c2] LibCURL v0.6.4
  [76f85450] LibGit2 v1.11.0
  [8f399da3] Libdl v1.11.0
  [37e2e46d] LinearAlgebra v1.11.0
  [56ddb016] Logging v1.11.0
  [d6f4376e] Markdown v1.11.0
  [a63ad114] Mmap v1.11.0
  [ca575930] NetworkOptions v1.2.0
  [44cfe95a] Pkg v1.12.0
  [de0858da] Printf v1.11.0
  [3fa0cd96] REPL v1.11.0
  [9a3f8284] Random v1.11.0
  [ea8e919c] SHA v0.7.0
  [9e88b42a] Serialization v1.11.0
  [6462fe0b] Sockets v1.11.0
  [2f01184e] SparseArrays v1.12.0
  [f489334b] StyledStrings v1.11.0
  [fa267f1f] TOML v1.0.3
  [a4e569a6] Tar v1.10.0
  [8dfed614] Test v1.11.0
  [cf7118a7] UUIDs v1.11.0
  [4ec0a83e] Unicode v1.11.0
  [e66e0078] CompilerSupportLibraries_jll v1.2.0+0
  [781609d7] GMP_jll v6.3.0+1
  [deac9b47] LibCURL_jll v8.6.0+0
  [e37daf67] LibGit2_jll v1.8.0+0
  [29816b5a] LibSSH2_jll v1.11.0+1
  [3a97d323] MPFR_jll v4.2.1+1
  [c8ffd9c3] MbedTLS_jll v2.28.6+1
  [14a3606d] MozillaCACerts_jll v2024.11.26
  [4536629a] OpenBLAS_jll v0.3.28+3
  [efcefdf7] PCRE2_jll v10.44.0+0
  [bea87d4a] SuiteSparse_jll v7.8.0+1
  [83775a58] Zlib_jll v1.3.1+1
  [8e850b90] libblastrampoline_jll v5.11.2+0
  [8e850ede] nghttp2_jll v1.63.0+1
  [3f19e933] p7zip_jll v17.5.0+1
     Testing Running tests...
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
ignoring installation for Display, use DisplayString instead
WARNING: ignoring conflicting import of Toposes.HasPseudoInverse into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.HasUnderlyingCategory into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.PseudoInverse into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.PseudoInverse_OPERATION into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.SetPseudoInverse into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.SetUnderlyingCategory into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.TheJuliaAttributeTypePseudoInverse into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.TheJuliaAttributeTypeUnderlyingCategory into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.UnderlyingCategory into FreydCategoriesForCAPFinSetsForCAPExtension
WARNING: ignoring conflicting import of Toposes.UnderlyingCategory_OPERATION into FreydCategoriesForCAPFinSetsForCAPExtension
┌ Warning: Unable to determine HTML(edit_link = ...) from remote HEAD branch, defaulting to "master".
│ Calling `git remote` failed with an exception. Set JULIA_DEBUG=Documenter to see the error.
│ Unless this is due to a configuration error, the relevant variable should be set explicitly.
└ @ Documenter ~/.julia/packages/Documenter/QLA7E/src/utilities/utilities.jl:655
[ Info: SetupBuildDirectory: setting up build directory.
[ Info: Doctest: running doctests.
┌ Error: doctest failure in ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:394-482
│ 
│ ```jldoctest AutoDocTests
│ julia> using MatricesForHomalg; using CAP; using MonoidalCategories; using LinearAlgebraForCAP; using CartesianCategories; using Toposes; using FinSetsForCAP; using FreydCategoriesForCAP
│ 
│ julia> R = HomalgRingOfIntegers();
│ 
│ julia> rows = CategoryOfRows( R );
│ 
│ julia> adelman = AdelmanCategory( rows );
│ 
│ julia> obj1 = CategoryOfRowsObject( 1, rows );
│ 
│ julia> obj2 = CategoryOfRowsObject( 2, rows );
│ 
│ julia> id = IdentityMorphism( obj2 );
│ 
│ julia> alpha = CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 1, 2 ] ], 1, 2, R ), obj2 );
│ 
│ julia> beta = CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> gamma = CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 3, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> obj1_a = AsAdelmanCategoryObject( obj1 );
│ 
│ julia> obj2_a = AsAdelmanCategoryObject( obj2 );
│ 
│ julia> m = AsAdelmanCategoryMorphism( beta );
│ 
│ julia> n = AsAdelmanCategoryMorphism( gamma );
│ 
│ julia> IsWellDefined( m )
│ true
│ 
│ julia> # backwards compatibility
│         IsIdenticalObj( MorphismDatum( m ), beta )
│ true
│ 
│ julia> IsCongruentForMorphisms( PreCompose( m, n ), PreCompose( n, m ) )
│ false
│ 
│ julia> IsCongruentForMorphisms( SubtractionForMorphisms( m, m ), ZeroMorphism( obj2_a, obj2_a ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( ZeroObjectFunctorial( adelman ),
│                                  PreCompose( UniversalMorphismFromZeroObject( obj1_a), UniversalMorphismIntoZeroObject( obj1_a ) ) 
│                                 )
│ true
│ 
│ julia> d = [ obj1_a, obj2_a ];
│ 
│ julia> pi1 = ProjectionInFactorOfDirectSum( d, 1 );
│ 
│ julia> pi2 = ProjectionInFactorOfDirectSum( d, 2 );
│ 
│ julia> id = IdentityMorphism( DirectSum( d ) );
│ 
│ julia> iota1 = InjectionOfCofactorOfDirectSum( d, 1 );
│ 
│ julia> iota2 = InjectionOfCofactorOfDirectSum( d, 2 );
│ 
│ julia> IsCongruentForMorphisms( PreCompose( pi1, iota1 ) + PreCompose( pi2, iota2 ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismIntoDirectSum( d, [ pi1, pi2 ] ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismFromDirectSum( d, [ iota1, iota2 ] ), id )
│ true
│ 
│ julia> c = CokernelProjection( m );
│ 
│ julia> c2 = CokernelProjection( c );
│ 
│ julia> IsCongruentForMorphisms( c2, ZeroMorphism( Source( c2 ), Range( c2 ) ) )
│ true
│ 
│ julia> IsWellDefined( CokernelProjection( m ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) )
│ true
│ 
│ julia> k = KernelEmbedding( c );
│ 
│ julia> IsZeroForMorphisms( PreCompose( k, c ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) )
│ true
│ 
│ ```
│ 
│ Subexpression:
│ 
│ IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) )
│ 
│ Evaluated output:
│ 
│ ERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│ Stacktrace:
│   [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│   [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│   [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│   [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│   [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│   [6] (::FreydCategoriesForCAP.var"#4233#4234")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, cokernel_object::Any)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:613
│   [7] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│   [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, FreydCategoriesForCAP.var"#4233#4234", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│   [9] CokernelColiftWithGivenCokernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [10] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasCokernelObject), typeof(CokernelColiftWithGivenCokernelObject), TheJuliaAttributeTypeCokernelObject})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│  [12] CallFuncList(func::Function, list::Any)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│  [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, CAP.var"#3470#3471", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│  [14] CokernelColift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [15] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [16] (::CAP.var"#671#672"{typeof(CokernelColift)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│  [17] CokernelColift
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│  [18] CokernelColift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:718
│  [19] top-level scope
│     @ none:1
│ 
│ Expected output:
│ 
│ true
│ 
│   diff =
│    Warning: Diff output requires color.
│    trueERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│    Stacktrace:
│      [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│      [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│      [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│      [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│      [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│      [6] (::FreydCategoriesForCAP.var"#4233#4234")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, cokernel_object::Any)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:613
│      [7] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│      [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, FreydCategoriesForCAP.var"#4233#4234", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│      [9] CokernelColiftWithGivenCokernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [10] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasCokernelObject), typeof(CokernelColiftWithGivenCokernelObject), TheJuliaAttributeTypeCokernelObject})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│     [12] CallFuncList(func::Function, list::Any)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│     [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, CAP.var"#3470#3471", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│     [14] CokernelColift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [15] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [16] (::CAP.var"#671#672"{typeof(CokernelColift)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│     [17] CokernelColift
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│     [18] CokernelColift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:718
│     [19] top-level scope
│        @ none:1
└ @ Documenter ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:394
┌ Error: doctest failure in ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:394-482
│ 
│ ```jldoctest AutoDocTests
│ julia> using MatricesForHomalg; using CAP; using MonoidalCategories; using LinearAlgebraForCAP; using CartesianCategories; using Toposes; using FinSetsForCAP; using FreydCategoriesForCAP
│ 
│ julia> R = HomalgRingOfIntegers();
│ 
│ julia> rows = CategoryOfRows( R );
│ 
│ julia> adelman = AdelmanCategory( rows );
│ 
│ julia> obj1 = CategoryOfRowsObject( 1, rows );
│ 
│ julia> obj2 = CategoryOfRowsObject( 2, rows );
│ 
│ julia> id = IdentityMorphism( obj2 );
│ 
│ julia> alpha = CategoryOfRowsMorphism( obj1, HomalgMatrix( [ [ 1, 2 ] ], 1, 2, R ), obj2 );
│ 
│ julia> beta = CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 2 ], [ 3, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> gamma = CategoryOfRowsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 3, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> obj1_a = AsAdelmanCategoryObject( obj1 );
│ 
│ julia> obj2_a = AsAdelmanCategoryObject( obj2 );
│ 
│ julia> m = AsAdelmanCategoryMorphism( beta );
│ 
│ julia> n = AsAdelmanCategoryMorphism( gamma );
│ 
│ julia> IsWellDefined( m )
│ true
│ 
│ julia> # backwards compatibility
│         IsIdenticalObj( MorphismDatum( m ), beta )
│ true
│ 
│ julia> IsCongruentForMorphisms( PreCompose( m, n ), PreCompose( n, m ) )
│ false
│ 
│ julia> IsCongruentForMorphisms( SubtractionForMorphisms( m, m ), ZeroMorphism( obj2_a, obj2_a ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( ZeroObjectFunctorial( adelman ),
│                                  PreCompose( UniversalMorphismFromZeroObject( obj1_a), UniversalMorphismIntoZeroObject( obj1_a ) ) 
│                                 )
│ true
│ 
│ julia> d = [ obj1_a, obj2_a ];
│ 
│ julia> pi1 = ProjectionInFactorOfDirectSum( d, 1 );
│ 
│ julia> pi2 = ProjectionInFactorOfDirectSum( d, 2 );
│ 
│ julia> id = IdentityMorphism( DirectSum( d ) );
│ 
│ julia> iota1 = InjectionOfCofactorOfDirectSum( d, 1 );
│ 
│ julia> iota2 = InjectionOfCofactorOfDirectSum( d, 2 );
│ 
│ julia> IsCongruentForMorphisms( PreCompose( pi1, iota1 ) + PreCompose( pi2, iota2 ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismIntoDirectSum( d, [ pi1, pi2 ] ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismFromDirectSum( d, [ iota1, iota2 ] ), id )
│ true
│ 
│ julia> c = CokernelProjection( m );
│ 
│ julia> c2 = CokernelProjection( c );
│ 
│ julia> IsCongruentForMorphisms( c2, ZeroMorphism( Source( c2 ), Range( c2 ) ) )
│ true
│ 
│ julia> IsWellDefined( CokernelProjection( m ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) )
│ true
│ 
│ julia> k = KernelEmbedding( c );
│ 
│ julia> IsZeroForMorphisms( PreCompose( k, c ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) )
│ true
│ 
│ ```
│ 
│ Subexpression:
│ 
│ IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) )
│ 
│ Evaluated output:
│ 
│ ERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│ Stacktrace:
│   [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│   [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│   [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│   [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│   [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│   [6] (::FreydCategoriesForCAP.var"#4239#4240")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, kernel_object::Any)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:716
│   [7] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│   [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, FreydCategoriesForCAP.var"#4239#4240", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│   [9] KernelLiftWithGivenKernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [10] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasKernelObject), typeof(KernelLiftWithGivenKernelObject), TheJuliaAttributeTypeKernelObject})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│  [12] CallFuncList(func::Function, list::Any)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│  [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, CAP.var"#2299#2300", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│  [14] KernelLift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [15] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [16] (::CAP.var"#671#672"{typeof(KernelLift)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│  [17] KernelLift
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│  [18] KernelLift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:678
│  [19] top-level scope
│     @ none:1
│ 
│ Expected output:
│ 
│ true
│ 
│   diff =
│    Warning: Diff output requires color.
│    trueERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│    Stacktrace:
│      [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│      [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfRowsMorphism{Symbol("Rows( Z )InstanceMorphismFilter##346")}})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│      [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│      [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│      [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│      [6] (::FreydCategoriesForCAP.var"#4239#4240")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, kernel_object::Any)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:716
│      [7] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│      [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, FreydCategoriesForCAP.var"#4239#4240", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│      [9] KernelLiftWithGivenKernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [10] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasKernelObject), typeof(KernelLiftWithGivenKernelObject), TheJuliaAttributeTypeKernelObject})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│     [12] CallFuncList(func::Function, list::Any)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│     [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, CAP.var"#2299#2300", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│     [14] KernelLift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Rows( Z ) )InstanceCategoryFilter##348")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Rows( Z ) )InstanceObjectFilter##349")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Rows( Z ) )InstanceMorphismFilter##350")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [15] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [16] (::CAP.var"#671#672"{typeof(KernelLift)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│     [17] KernelLift
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│     [18] KernelLift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:678
│     [19] top-level scope
│        @ none:1
└ @ Documenter ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:394
┌ Error: doctest failure in ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:485-569
│ 
│ ```jldoctest AutoDocTests
│ julia> using MatricesForHomalg; using CAP; using MonoidalCategories; using LinearAlgebraForCAP; using CartesianCategories; using Toposes; using FinSetsForCAP; using FreydCategoriesForCAP
│ 
│ julia> R = HomalgRingOfIntegers();
│ 
│ julia> cols = CategoryOfColumns( R );
│ 
│ julia> adelman = AdelmanCategory( cols );
│ 
│ julia> obj1 = CategoryOfColumnsObject( 1, cols );
│ 
│ julia> obj2 = CategoryOfColumnsObject( 2, cols );
│ 
│ julia> id = IdentityMorphism( obj2 );
│ 
│ julia> alpha = CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 1 ], [ 2 ] ], 2, 1, R ), obj2 );
│ 
│ julia> beta = CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 2, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> gamma = CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 3, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> obj1_a = AsAdelmanCategoryObject( obj1 );
│ 
│ julia> obj2_a = AsAdelmanCategoryObject( obj2 );
│ 
│ julia> m = AsAdelmanCategoryMorphism( beta );
│ 
│ julia> n = AsAdelmanCategoryMorphism( gamma );
│ 
│ julia> IsWellDefined( m )
│ true
│ 
│ julia> IsCongruentForMorphisms( PreCompose( m, n ), PreCompose( n, m ) )
│ false
│ 
│ julia> IsCongruentForMorphisms( SubtractionForMorphisms( m, m ), ZeroMorphism( obj2_a, obj2_a ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( ZeroObjectFunctorial( adelman ),
│                                  PreCompose( UniversalMorphismFromZeroObject( obj1_a), UniversalMorphismIntoZeroObject( obj1_a ) ) 
│                                 )
│ true
│ 
│ julia> d = [ obj1_a, obj2_a ];
│ 
│ julia> pi1 = ProjectionInFactorOfDirectSum( d, 1 );
│ 
│ julia> pi2 = ProjectionInFactorOfDirectSum( d, 2 );
│ 
│ julia> id = IdentityMorphism( DirectSum( d ) );
│ 
│ julia> iota1 = InjectionOfCofactorOfDirectSum( d, 1 );
│ 
│ julia> iota2 = InjectionOfCofactorOfDirectSum( d, 2 );
│ 
│ julia> IsCongruentForMorphisms( PreCompose( pi1, iota1 ) + PreCompose( pi2, iota2 ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismIntoDirectSum( d, [ pi1, pi2 ] ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismFromDirectSum( d, [ iota1, iota2 ] ), id )
│ true
│ 
│ julia> c = CokernelProjection( m );
│ 
│ julia> c2 = CokernelProjection( c );
│ 
│ julia> IsCongruentForMorphisms( c2, ZeroMorphism( Source( c2 ), Range( c2 ) ) )
│ true
│ 
│ julia> IsWellDefined( CokernelProjection( m ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) )
│ true
│ 
│ julia> k = KernelEmbedding( c );
│ 
│ julia> IsZeroForMorphisms( PreCompose( k, c ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) )
│ true
│ 
│ ```
│ 
│ Subexpression:
│ 
│ IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) )
│ 
│ Evaluated output:
│ 
│ ERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│ Stacktrace:
│   [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│   [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│   [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│   [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│   [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│   [6] (::FreydCategoriesForCAP.var"#4233#4234")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, cokernel_object::Any)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:613
│   [7] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│   [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, FreydCategoriesForCAP.var"#4233#4234", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│   [9] CokernelColiftWithGivenCokernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [10] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasCokernelObject), typeof(CokernelColiftWithGivenCokernelObject), TheJuliaAttributeTypeCokernelObject})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│  [12] CallFuncList(func::Function, list::Any)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│  [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, CAP.var"#3470#3471", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│  [14] CokernelColift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [15] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [16] (::CAP.var"#671#672"{typeof(CokernelColift)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│  [17] CokernelColift
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│  [18] CokernelColift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:718
│  [19] top-level scope
│     @ none:1
│ 
│ Expected output:
│ 
│ true
│ 
│   diff =
│    Warning: Diff output requires color.
│    trueERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│    Stacktrace:
│      [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│      [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│      [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│      [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│      [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│      [6] (::FreydCategoriesForCAP.var"#4233#4234")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, cokernel_object::Any)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:613
│      [7] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│      [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, FreydCategoriesForCAP.var"#4233#4234", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│      [9] CokernelColiftWithGivenCokernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [10] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasCokernelObject), typeof(CokernelColiftWithGivenCokernelObject), TheJuliaAttributeTypeCokernelObject})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│     [12] CallFuncList(func::Function, list::Any)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│     [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, CAP.var"#3470#3471", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│     [14] CokernelColift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [15] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [16] (::CAP.var"#671#672"{typeof(CokernelColift)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│     [17] CokernelColift
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│     [18] CokernelColift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:718
│     [19] top-level scope
│        @ none:1
└ @ Documenter ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:485
┌ Error: doctest failure in ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:485-569
│ 
│ ```jldoctest AutoDocTests
│ julia> using MatricesForHomalg; using CAP; using MonoidalCategories; using LinearAlgebraForCAP; using CartesianCategories; using Toposes; using FinSetsForCAP; using FreydCategoriesForCAP
│ 
│ julia> R = HomalgRingOfIntegers();
│ 
│ julia> cols = CategoryOfColumns( R );
│ 
│ julia> adelman = AdelmanCategory( cols );
│ 
│ julia> obj1 = CategoryOfColumnsObject( 1, cols );
│ 
│ julia> obj2 = CategoryOfColumnsObject( 2, cols );
│ 
│ julia> id = IdentityMorphism( obj2 );
│ 
│ julia> alpha = CategoryOfColumnsMorphism( obj1, HomalgMatrix( [ [ 1 ], [ 2 ] ], 2, 1, R ), obj2 );
│ 
│ julia> beta = CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 2, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> gamma = CategoryOfColumnsMorphism( obj2, HomalgMatrix( [ [ 1, 3 ], [ 3, 4 ] ], 2, 2, R ), obj2 );
│ 
│ julia> obj1_a = AsAdelmanCategoryObject( obj1 );
│ 
│ julia> obj2_a = AsAdelmanCategoryObject( obj2 );
│ 
│ julia> m = AsAdelmanCategoryMorphism( beta );
│ 
│ julia> n = AsAdelmanCategoryMorphism( gamma );
│ 
│ julia> IsWellDefined( m )
│ true
│ 
│ julia> IsCongruentForMorphisms( PreCompose( m, n ), PreCompose( n, m ) )
│ false
│ 
│ julia> IsCongruentForMorphisms( SubtractionForMorphisms( m, m ), ZeroMorphism( obj2_a, obj2_a ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( ZeroObjectFunctorial( adelman ),
│                                  PreCompose( UniversalMorphismFromZeroObject( obj1_a), UniversalMorphismIntoZeroObject( obj1_a ) ) 
│                                 )
│ true
│ 
│ julia> d = [ obj1_a, obj2_a ];
│ 
│ julia> pi1 = ProjectionInFactorOfDirectSum( d, 1 );
│ 
│ julia> pi2 = ProjectionInFactorOfDirectSum( d, 2 );
│ 
│ julia> id = IdentityMorphism( DirectSum( d ) );
│ 
│ julia> iota1 = InjectionOfCofactorOfDirectSum( d, 1 );
│ 
│ julia> iota2 = InjectionOfCofactorOfDirectSum( d, 2 );
│ 
│ julia> IsCongruentForMorphisms( PreCompose( pi1, iota1 ) + PreCompose( pi2, iota2 ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismIntoDirectSum( d, [ pi1, pi2 ] ), id )
│ true
│ 
│ julia> IsCongruentForMorphisms( UniversalMorphismFromDirectSum( d, [ iota1, iota2 ] ), id )
│ true
│ 
│ julia> c = CokernelProjection( m );
│ 
│ julia> c2 = CokernelProjection( c );
│ 
│ julia> IsCongruentForMorphisms( c2, ZeroMorphism( Source( c2 ), Range( c2 ) ) )
│ true
│ 
│ julia> IsWellDefined( CokernelProjection( m ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( CokernelColift( m, CokernelProjection( m ) ), IdentityMorphism( CokernelObject( m ) ) )
│ true
│ 
│ julia> k = KernelEmbedding( c );
│ 
│ julia> IsZeroForMorphisms( PreCompose( k, c ) )
│ true
│ 
│ julia> IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) )
│ true
│ 
│ ```
│ 
│ Subexpression:
│ 
│ IsCongruentForMorphisms( KernelLift( m, KernelEmbedding( m ) ), IdentityMorphism( KernelObject( m ) ) )
│ 
│ Evaluated output:
│ 
│ ERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│ Stacktrace:
│   [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│   [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│   [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│   [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│   [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│   [6] (::FreydCategoriesForCAP.var"#4239#4240")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, kernel_object::Any)
│     @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:716
│   [7] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│   [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, FreydCategoriesForCAP.var"#4239#4240", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│   [9] KernelLiftWithGivenKernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [10] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasKernelObject), typeof(KernelLiftWithGivenKernelObject), TheJuliaAttributeTypeKernelObject})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│  [12] CallFuncList(func::Function, list::Any)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│  [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, CAP.var"#2299#2300", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│  [14] KernelLift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")})
│     @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│  [15] CallFuncList
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│  [16] (::CAP.var"#671#672"{typeof(KernelLift)})(::Any, ::Vararg{Any})
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│  [17] KernelLift
│     @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│  [18] KernelLift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│     @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:678
│  [19] top-level scope
│     @ none:1
│ 
│ Expected output:
│ 
│ true
│ 
│   diff =
│    Warning: Diff output requires color.
│    trueERROR: (Internal Error - IR Validity): Returned from function we expected not to.
│    Stacktrace:
│      [1] (::CAP.var"#683#684"{typeof(SolveLinearSystemInAbCategory)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:367
│      [2] SolveLinearSystemInAbCategory(arg1::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg2::Vector{Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}}}, arg3::Vector{TheJuliaConcreteTypeIsCategoryOfColumnsMorphism{Symbol("Columns( Z )InstanceMorphismFilter##374")}})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│      [3] WitnessPairForBeingCongruentToZero_OPERATION(morphism::TheJuliaAbstractTypeIsAdelmanCategoryMorphism)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:243
│      [4] (::TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero)(obj::AttributeStoringRep; kwargs...)
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:57
│      [5] TheJuliaAttributeTypeWitnessPairForBeingCongruentToZero
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/attributes.jl:55 [inlined]
│      [6] (::FreydCategoriesForCAP.var"#4239#4240")(cat::Any, morphism::Any, test_object::Any, test_morphism::Any, kernel_object::Any)
│        @ FreydCategoriesForCAP ~/.julia/packages/FreydCategoriesForCAP/cPpw5/src/gap/AdelmanCategory.gi.autogen.jl:716
│      [7] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│      [8] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, FreydCategoriesForCAP.var"#4239#4240", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:283
│      [9] KernelLiftWithGivenKernelObject(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg5::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [10] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [11] (::CAP.var"#601#602"{String, String, String, UnitRange{Int64}, typeof(HasKernelObject), typeof(KernelLiftWithGivenKernelObject), TheJuliaAttributeTypeKernelObject})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/MethodRecordTools.gi.autogen.jl:833
│     [12] CallFuncList(func::Function, list::Any)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039
│     [13] (::CAP.var"#659#660"{String, TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, CAP.var"#2299#2300", Vector{Any}, Bool, Bool, String, CAPRecord})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:245
│     [14] KernelLift(arg1::TheJuliaConcreteTypeIsAdelmanCategory{Symbol("Adelman category( Columns( Z ) )InstanceCategoryFilter##376")}, arg2::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")}, arg3::TheJuliaConcreteTypeIsAdelmanCategoryObject{Symbol("Adelman category( Columns( Z ) )InstanceObjectFilter##377")}, arg4::TheJuliaConcreteTypeIsAdelmanCategoryMorphism{Symbol("Adelman category( Columns( Z ) )InstanceMorphismFilter##378")})
│        @ FreydCategoriesForCAP ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220
│     [15] CallFuncList
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation.jl:1039 [inlined]
│     [16] (::CAP.var"#671#672"{typeof(KernelLift)})(::Any, ::Vararg{Any})
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/InstallAdds.gi.autogen.jl:355
│     [17] KernelLift
│        @ ~/.julia/packages/CAP/jDep1/src/gap_emulation/operations.jl:220 [inlined]
│     [18] KernelLift(alpha::TheJuliaAbstractTypeIsCapCategoryMorphism, tau::TheJuliaAbstractTypeIsCapCategoryMorphism)
│        @ CAP ~/.julia/packages/CAP/jDep1/src/gap/LimitConvenienceOutput.gi.autogen.jl:678
│     [19] top-level scope
│        @ none:1
└ @ Documenter ~/.julia/packages/FreydCategoriesForCAP/cPpw5/docs/src/AutoDocTests.tst.autogen.md:485
┌ Error: Doctesting failed
│   exception =
│    `makedocs` encountered a doctest error. Terminating build
│    Stacktrace:
│      [1] error(s::String)
│        @ Base ./error.jl:44
│      [2] runner(::Type{Documenter.Builder.Doctest}, doc::Documenter.Document)
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/builder_pipeline.jl:213
│      [3] dispatch(::Type{Documenter.Builder.DocumentPipeline}, x::Documenter.Document)
│        @ Documenter.Selectors ~/.julia/packages/Documenter/QLA7E/src/utilities/Selectors.jl:170
│      [4] #90
│        @ ~/.julia/packages/Documenter/QLA7E/src/makedocs.jl:274 [inlined]
│      [5] withenv(::Documenter.var"#90#91"{Documenter.Document}, ::Pair{String, Nothing}, ::Vararg{Pair{String, Nothing}})
│        @ Base ./env.jl:265
│      [6] #88
│        @ ~/.julia/packages/Documenter/QLA7E/src/makedocs.jl:273 [inlined]
│      [7] cd(f::Documenter.var"#88#89"{Documenter.Document}, dir::String)
│        @ Base.Filesystem ./file.jl:112
│      [8] makedocs(; debug::Bool, format::Documenter.HTMLWriter.HTML, kwargs::@Kwargs{root::String, source::String, sitename::String, doctest::Symbol, modules::Vector{Module}, doctestfilters::Vector{Regex}, remotes::Nothing, plugins::Vector{Documenter.Plugin}})
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/makedocs.jl:272
│      [9] (::Documenter.var"#all_doctests#140"{Bool, Vector{Regex}, Vector{Documenter.Plugin}, Vector{Module}})()
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:85
│     [10] macro expansion
│        @ ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:110 [inlined]
│     [11] macro expansion
│        @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:676 [inlined]
│     [12] macro expansion
│        @ ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:110 [inlined]
│     [13] macro expansion
│        @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:1724 [inlined]
│     [14] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin})
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:110
│     [15] doctest
│        @ ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:69 [inlined]
│     [16] doctest(package::Module; manual::Bool, testset::Nothing, kwargs::@Kwargs{})
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:37
│     [17] doctest(package::Module)
│        @ Documenter ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:20
│     [18] top-level scope
│        @ ~/.julia/packages/FreydCategoriesForCAP/cPpw5/test/runtests.jl:9
│     [19] include(mapexpr::Function, mod::Module, _path::String)
│        @ Base ./Base.jl:301
│     [20] top-level scope
│        @ none:6
│     [21] eval(m::Module, e::Any)
│        @ Core ./boot.jl:485
│     [22] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:295
│     [23] _start()
│        @ Base ./client.jl:558
└ @ Documenter ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:99
Doctests: FreydCategoriesForCAP: Test Failed at /home/pkgeval/.julia/packages/Documenter/QLA7E/src/doctest.jl:110
  Expression: all_doctests()

Stacktrace:
 [1] macro expansion
   @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:679 [inlined]
 [2] macro expansion
   @ ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:110 [inlined]
 [3] macro expansion
   @ /opt/julia/share/julia/stdlib/v1.12/Test/src/Test.jl:1724 [inlined]
 [4] doctest(source::String, modules::Vector{Module}; fix::Bool, testset::String, doctestfilters::Vector{Regex}, plugins::Vector{Documenter.Plugin})
   @ Documenter ~/.julia/packages/Documenter/QLA7E/src/doctest.jl:110
Test Summary:                   | Fail  Total     Time
Doctests: FreydCategoriesForCAP |    1      1  8m02.8s
ERROR: LoadError: Some tests did not pass: 0 passed, 1 failed, 0 errored, 0 broken.
in expression starting at /home/pkgeval/.julia/packages/FreydCategoriesForCAP/cPpw5/test/runtests.jl:9

Testing failed after 872.13s

ERROR: LoadError: Package FreydCategoriesForCAP errored during testing
Stacktrace:
  [1] pkgerror(msg::String)
    @ Pkg.Types /opt/julia/share/julia/stdlib/v1.12/Pkg/src/Types.jl:68
  [2] test(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool)
    @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.12/Pkg/src/Operations.jl:2359
  [3] test
    @ /opt/julia/share/julia/stdlib/v1.12/Pkg/src/Operations.jl:2214 [inlined]
  [4] test(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:481
  [5] test(pkgs::Vector{Pkg.Types.PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:159
  [6] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd})
    @ Pkg.API /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:147
  [7] test
    @ /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:147 [inlined]
  [8] #test#81
    @ /opt/julia/share/julia/stdlib/v1.12/Pkg/src/API.jl:146 [inlined]
  [9] top-level scope
    @ /PkgEval.jl/scripts/evaluate.jl:219
 [10] include(mod::Module, _path::String)
    @ Base ./Base.jl:300
 [11] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:329
 [12] _start()
    @ Base ./client.jl:558
in expression starting at /PkgEval.jl/scripts/evaluate.jl:210

PkgEval failed after 1043.43s: package has test failures