CHANGELOG.md

Version 2.1-dev

The library has been tested using Agda 2.6.4 and 2.6.4.1.

Highlights

Bug-fixes

• Fix statement of Data.Vec.Properties.toList-replicate, where replicate was mistakenly applied to the level of the type A instead of the variable x of type A.

Non-backwards compatible changes

• The modules and morphisms in Algebra.Module.Morphism.Structures are now parametrized by raw bundles rather than lawful bundles, in line with other modules defining morphism structures.
• The definitions in Algebra.Module.Morphism.Construct.Composition are now parametrized by raw bundles, and as such take a proof of transitivity.
• The definitions in Algebra.Module.Morphism.Construct.Identity are now parametrized by raw bundles, and as such take a proof of reflexivity.

Other major improvements

Deprecated modules

Deprecated names

• In Algebra.Properties.Semiring.Mult:

  1×-identityʳ  ↦  ×-homo-1

• In Data.Nat.Divisibility.Core:

  *-pres-∣  ↦  Data.Nat.Divisibility.*-pres-∣

New modules

• Algebra.Module.Bundles.Raw: raw bundles for module-like algebraic structures

• Data.List.Effectful.Foldable: List is Foldable

• Data.Vec.Effectful.Foldable: Vec is Foldable

• Effect.Foldable: implementation of haskell-like Foldable

Additions to existing modules

• Exporting more Raw substructures from Algebra.Bundles.Ring:

  rawNearSemiring   : RawNearSemiring _ _
  rawRingWithoutOne : RawRingWithoutOne _ _
  +-rawGroup        : RawGroup _ _

• In Algebra.Module.Bundles, raw bundles are re-exported and the bundles expose their raw counterparts.

• In Algebra.Module.Construct.DirectProduct:

  rawLeftSemimodule  : RawLeftSemimodule R m ℓm → RawLeftSemimodule m′ ℓm′ → RawLeftSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawLeftModule      : RawLeftModule R m ℓm → RawLeftModule m′ ℓm′ → RawLeftModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawRightSemimodule : RawRightSemimodule R m ℓm → RawRightSemimodule m′ ℓm′ → RawRightSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawRightModule     : RawRightModule R m ℓm → RawRightModule m′ ℓm′ → RawRightModule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawBisemimodule    : RawBisemimodule R m ℓm → RawBisemimodule m′ ℓm′ → RawBisemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawBimodule        : RawBimodule R m ℓm → RawBimodule m′ ℓm′ → RawBimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawSemimodule      : RawSemimodule R m ℓm → RawSemimodule m′ ℓm′ → RawSemimodule R (m ⊔ m′) (ℓm ⊔ ℓm′)
  rawModule          : RawModule R m ℓm → RawModule m′ ℓm′ → RawModule R (m ⊔ m′) (ℓm ⊔ ℓm′)

• In Algebra.Module.Construct.TensorUnit:

  rawLeftSemimodule  : RawLeftSemimodule _ c ℓ
  rawLeftModule      : RawLeftModule _ c ℓ
  rawRightSemimodule : RawRightSemimodule _ c ℓ
  rawRightModule     : RawRightModule _ c ℓ
  rawBisemimodule    : RawBisemimodule _ _ c ℓ
  rawBimodule        : RawBimodule _ _ c ℓ
  rawSemimodule      : RawSemimodule _ c ℓ
  rawModule          : RawModule _ c ℓ

• In Algebra.Module.Construct.Zero:

  rawLeftSemimodule  : RawLeftSemimodule R c ℓ
  rawLeftModule      : RawLeftModule R c ℓ
  rawRightSemimodule : RawRightSemimodule R c ℓ
  rawRightModule     : RawRightModule R c ℓ
  rawBisemimodule    : RawBisemimodule R c ℓ
  rawBimodule        : RawBimodule R c ℓ
  rawSemimodule      : RawSemimodule R c ℓ
  rawModule          : RawModule R c ℓ

• In Algebra.Properties.Monoid.Mult:

  ×-homo-0 : ∀ x → 0 × x ≈ 0#
  ×-homo-1 : ∀ x → 1 × x ≈ x

• In Algebra.Properties.Semiring.Mult:

  ×-homo-0#     : ∀ x → 0 × x ≈ 0# * x
  ×-homo-1#     : ∀ x → 1 × x ≈ 1# * x
  idem-×-homo-* : (_*_ IdempotentOn x) → (m × x) * (n × x) ≈ (m ℕ.* n) × x

• In Data.Fin.Properties:

  nonZeroIndex : Fin n → ℕ.NonZero n

• In Data.List.Relation.Unary.All.Properties:

  All-catMaybes⁺ : All (Maybe.All P) xs → All P (catMaybes xs)
  Any-catMaybes⁺ : All (Maybe.Any P) xs → All P (catMaybes xs)

• In Data.List.Relation.Unary.AllPairs.Properties:

  catMaybes⁺ : AllPairs (Pointwise R) xs → AllPairs R (catMaybes xs)
  tabulate⁺-< : (i < j → R (f i) (f j)) → AllPairs R (tabulate f)

• In Data.Maybe.Relation.Binary.Pointwise:

  pointwise⊆any : Pointwise R (just x) ⊆ Any (R x)

• In Data.Nat.Divisibility:

  quotient≢0       : m ∣ n → .{{NonZero n}} → NonZero quotient
  
  m∣n⇒n≡quotient*m : m ∣ n → n ≡ quotient * m
  m∣n⇒n≡m*quotient : m ∣ n → n ≡ m * quotient
  quotient-∣       : m ∣ n → quotient ∣ n
  quotient>1       : m ∣ n → m < n → 1 < quotient
  quotient-<       : m ∣ n → .{{NonTrivial m}} → .{{NonZero n}} → quotient < n
  n/m≡quotient     : m ∣ n → .{{_ : NonZero m}} → n / m ≡ quotient
  
  m/n≡0⇒m<n    : .{{_ : NonZero n}} → m / n ≡ 0 → m < n
  m/n≢0⇒n≤m    : .{{_ : NonZero n}} → m / n ≢ 0 → n ≤ m
  
  nonZeroDivisor : DivMod dividend divisor → NonZero divisor

• Added new proofs in Data.Nat.Properties:

  m≤n+o⇒m∸n≤o : ∀ m n {o} → m ≤ n + o → m ∸ n ≤ o
  m<n+o⇒m∸n<o : ∀ m n {o} → .{{NonZero o}} → m < n + o → m ∸ n < o
  pred-cancel-≤ : pred m ≤ pred n → (m ≡ 1 × n ≡ 0) ⊎ m ≤ n
  pred-cancel-< : pred m < pred n → m < n
  pred-injective : .{{NonZero m}} → .{{NonZero n}} → pred m ≡ pred n → m ≡ n
  pred-cancel-≡ : pred m ≡ pred n → ((m ≡ 0 × n ≡ 1) ⊎ (m ≡ 1 × n ≡ 0)) ⊎ m ≡ n

• Added new functions in Data.String.Base:

  map : (Char → Char) → String → String

• In Function.Bundles, added _⟶ₛ_ as a synonym for Func that can be used infix.

• Added new definitions in Relation.Binary

  Stable          : Pred A ℓ → Set _
  

• Added new definitions in Relation.Nullary

  Recomputable    : Set _
  WeaklyDecidable : Set _
  

• Added new definitions in Relation.Unary

  Stable          : Pred A ℓ → Set _
  WeaklyDecidable : Pred A ℓ → Set _
  

• Added new proof in Relation.Nullary.Decidable:

  ⌊⌋-map′ : (a? : Dec A) → ⌊ map′ t f a? ⌋ ≡ ⌊ a? ⌋