Note about Mathlib/Init/

The files in Mathlib/Init are leftovers from the port from Mathlib3. (They contain content moved from lean3 itself that Mathlib needed but was not moved to lean4.)

We intend to move all the content of these files out into the main Mathlib directory structure. Contributions assisting with this are appreciated.

(Yaël): The only things of interest in this file now are the unbundled algebra classes

Unbundled algebra classes

These classes are part of an incomplete refactor described here on the github Wiki. However a subset of them are widely used in mathlib3, and it has been tricky to clean this up as this file was in core Lean 3.

By themselves, these classes are not good replacements for the Monoid / Group etc structures provided by mathlib, as they are not discoverable by simp unlike the current lemmas due to there being little to index on. The Wiki page linked above describes an algebraic normalizer, but it was never implemented in Lean 3.

Porting note:

This file is ancient, and it would be good to replace it with a clean version that provides what mathlib4 actually needs.

I've omitted all the @[algebra] attributes, as they are not used elsewhere.

The section StrictWeakOrder has been omitted, but I've left the mathport output in place. Please delete if cleaning up.

I've commented out some classes which we think are completely unused in mathlib.

I've added many of the declarations to nolints.json. If you clean up this file, please add documentation to classes that we are keeping.

Mario made the following analysis of uses in mathlib3:

• is_symm_op: unused except for some instances
• is_commutative: used a fair amount via some theorems about folds (also assuming is_associative)
• is_associative: ditto, also used in noncomm_fold
• is_left_id, is_right_id: unused except in the mathlib class is_unital and in mono (which looks like it could use is_unital)
• is_left_null, is_right_null: unused
• is_left_cancel, is_right_cancel: unused except for instances
• is_idempotent: this one is actually used to prove things not directly about is_idempotent
• is_left_distrib, is_right_distrib, is_left_inv, is_right_inv, is_cond_left_inv, is_cond_right_inv: unused
• is_distinct: unused (although we reinvented this one as nontrivial)
• is_irrefl, is_refl, is_symm, is_trans: significant usage
• is_asymm, is_antisymm, is_total, is_strict_order: a lot of uses but all in order theory and it's unclear how much could not be transferred to another typeclass
• is_preorder: unused except for instances (except antisymmetrization, maybe it could be transferred)
• is_total_preorder, is_partial_order: unused except for instances
• is_linear_order: unused except for instances
• is_equiv: unused except for instances (most uses can use equivalence instead)
• is_per: unused
• is_incomp_trans: unused
• is_strict_weak_order: significant usage (most of it on rbmap, could be transferred)
• is_trichotomous: some usage
• is_strict_total_order: looks like the only usage is in rbmap again

class IsSymmOp (α : Sort u) (β : Sort v) (op : α → α → β) : Prop

• symm_op : ∀ (a b : α), op a b = op b a

theorem IsSymmOp.symm_op {α : Sort u} {β : Sort v} {op : α → α → β} [self : IsSymmOp α β op] (a : α) (b : α) : op a b = op b a

@[reducible, inline, deprecated Std.Commutative]

abbrev IsCommutative (α : Sort u) (op : α → α → α) : Prop

A commutative binary operation.

Equations

• IsCommutative α op = Std.Commutative op

@[instance 100]

instance isSymmOp_of_isCommutative (α : Sort u) (op : α → α → α) [Std.Commutative op] : IsSymmOp α α op

Equations

• ⋯ = ⋯

@[reducible, inline, deprecated Std.Associative]

abbrev IsAssociative (α : Sort u) (op : α → α → α) : Prop

An associative binary operation.

Equations

• IsAssociative α op = Std.Associative op

@[reducible, inline, deprecated Std.LawfulLeftIdentity]

abbrev IsLeftId (α : Sort u) (op : α → α → α) (o : outParam α) : Prop

A binary operation with a left identity.

Equations

• IsLeftId α op o = Std.LawfulLeftIdentity op o

@[reducible, inline, deprecated Std.LawfulRightIdentity]

abbrev IsRightId (α : Sort u) (op : α → α → α) (o : outParam α) : Prop

A binary operation with a right identity.

Equations

• IsRightId α op o = Std.LawfulRightIdentity op o

class IsLeftCancel (α : Sort u) (op : α → α → α) : Prop

• left_cancel : ∀ (a b c : α), op a b = op a c → b = c

theorem IsLeftCancel.left_cancel {α : Sort u} {op : α → α → α} [self : IsLeftCancel α op] (a : α) (b : α) (c : α) : op a b = op a c → b = c

class IsRightCancel (α : Sort u) (op : α → α → α) : Prop

• right_cancel : ∀ (a b c : α), op a b = op c b → a = c

theorem IsRightCancel.right_cancel {α : Sort u} {op : α → α → α} [self : IsRightCancel α op] (a : α) (b : α) (c : α) : op a b = op c b → a = c

@[reducible, inline, deprecated Std.IdempotentOp]

abbrev IsIdempotent (α : Sort u) (op : α → α → α) : Prop

Equations

• IsIdempotent α op = Std.IdempotentOp op

@[instance 100]

instance isSymmOp_of_isSymm (α : Sort u) (r : α → α → Prop) [IsSymm α r] : IsSymmOp α Prop r

The opposite of a symmetric relation is symmetric.

Equations

• ⋯ = ⋯

@[deprecated]

class IsTotalPreorder (α : Sort u) (r : α → α → Prop) extends IsTrans , IsTotal : Prop

IsTotalPreorder X r means that the binary relation r on X is total and a preorder.

@[instance 100]

instance isTotalPreorder_isPreorder (α : Sort u) (r : α → α → Prop) [s : IsTotalPreorder α r] : IsPreorder α r

Every total pre-order is a pre-order.

Equations

• ⋯ = ⋯

@[deprecated]

class IsIncompTrans (α : Sort u) (lt : α → α → Prop) : Prop

IsIncompTrans X lt means that for lt a binary relation on X, the incomparable relation fun a b => ¬ lt a b ∧ ¬ lt b a is transitive.

• incomp_trans : ∀ (a b c : α), ¬lt a b ∧ ¬lt b a → ¬lt b c ∧ ¬lt c b → ¬lt a c ∧ ¬lt c a

theorem IsIncompTrans.incomp_trans {α : Sort u} {lt : α → α → Prop} [self : IsIncompTrans α lt] (a : α) (b : α) (c : α) : ¬lt a b ∧ ¬lt b a → ¬lt b c ∧ ¬lt c b → ¬lt a c ∧ ¬lt c a

@[deprecated, instance 100]

instance instIsIncompTransOfIsStrictWeakOrder (α : Sort u) (lt : α → α → Prop) [IsStrictWeakOrder α lt] : IsIncompTrans α lt

Equations

• ⋯ = ⋯

@[deprecated]

theorem incomp_trans {α : Sort u} {r : α → α → Prop} [IsIncompTrans α r] {a : α} {b : α} {c : α} : ¬r a b ∧ ¬r b a → ¬r b c ∧ ¬r c b → ¬r a c ∧ ¬r c a

@[elab_without_expected_type, deprecated]

theorem incomp_trans_of {α : Sort u} (r : α → α → Prop) [IsIncompTrans α r] {a : α} {b : α} {c : α} : ¬r a b ∧ ¬r b a → ¬r b c ∧ ¬r c b → ¬r a c ∧ ¬r c a

@[deprecated]

def StrictWeakOrder.Equiv {α : Sort u} {r : α → α → Prop} (a : α) (b : α) : Prop

Equations

• StrictWeakOrder.Equiv a b = (¬r a b ∧ ¬r b a)

@[deprecated]

theorem StrictWeakOrder.esymm {α : Sort u} {r : α → α → Prop} {a : α} {b : α} : StrictWeakOrder.Equiv a b → StrictWeakOrder.Equiv b a

@[deprecated]

theorem StrictWeakOrder.not_lt_of_equiv {α : Sort u} {r : α → α → Prop} {a : α} {b : α} : StrictWeakOrder.Equiv a b → ¬r a b

@[deprecated]

theorem StrictWeakOrder.not_lt_of_equiv' {α : Sort u} {r : α → α → Prop} {a : α} {b : α} : StrictWeakOrder.Equiv a b → ¬r b a

@[deprecated]

theorem StrictWeakOrder.erefl {α : Sort u} {r : α → α → Prop} [IsStrictWeakOrder α r] (a : α) : StrictWeakOrder.Equiv a a

@[deprecated]

theorem StrictWeakOrder.etrans {α : Sort u} {r : α → α → Prop} [IsStrictWeakOrder α r] {a : α} {b : α} {c : α} : StrictWeakOrder.Equiv a b → StrictWeakOrder.Equiv b c → StrictWeakOrder.Equiv a c

@[deprecated]

instance StrictWeakOrder.isEquiv {α : Sort u} {r : α → α → Prop} [IsStrictWeakOrder α r] : IsEquiv α StrictWeakOrder.Equiv

Equations

• ⋯ = ⋯

def StrictWeakOrder.«term_≈[_]_» : Lean.TrailingParserDescr

The equivalence relation induced by lt

Equations

• One or more equations did not get rendered due to their size.

@[deprecated]

theorem isStrictWeakOrder_of_isTotalPreorder {α : Sort u} {le : α → α → Prop} {lt : α → α → Prop} [DecidableRel le] [IsTotalPreorder α le] (h : ∀ (a b : α), lt a b ↔ ¬le b a) : IsStrictWeakOrder α lt

@[deprecated]

instance instIsTotalPreorderLe {α : Type u_1} [LinearOrder α] : IsTotalPreorder α fun (x1 x2 : α) => x1 ≤ x2

Equations

• ⋯ = ⋯

@[deprecated]

instance isStrictWeakOrder_of_linearOrder {α : Type u_1} [LinearOrder α] : IsStrictWeakOrder α fun (x1 x2 : α) => x1 < x2

Equations

• ⋯ = ⋯

@[deprecated]

theorem lt_of_lt_of_incomp {α : Sort u} {lt : α → α → Prop} [IsStrictWeakOrder α lt] [DecidableRel lt] {a : α} {b : α} {c : α} : lt a b → ¬lt b c ∧ ¬lt c b → lt a c

@[deprecated]

theorem lt_of_incomp_of_lt {α : Sort u} {lt : α → α → Prop} [IsStrictWeakOrder α lt] [DecidableRel lt] {a : α} {b : α} {c : α} : ¬lt a b ∧ ¬lt b a → lt b c → lt a c

@[deprecated]

theorem eq_of_incomp {α : Sort u} {lt : α → α → Prop} [IsTrichotomous α lt] {a : α} {b : α} : ¬lt a b ∧ ¬lt b a → a = b

@[deprecated]

theorem eq_of_eqv_lt {α : Sort u} {lt : α → α → Prop} [IsTrichotomous α lt] {a : α} {b : α} : StrictWeakOrder.Equiv a b → a = b

@[deprecated]

theorem incomp_iff_eq {α : Sort u} {lt : α → α → Prop} [IsTrichotomous α lt] [IsIrrefl α lt] (a : α) (b : α) : ¬lt a b ∧ ¬lt b a ↔ a = b

@[deprecated]

theorem eqv_lt_iff_eq {α : Sort u} {lt : α → α → Prop} [IsTrichotomous α lt] [IsIrrefl α lt] (a : α) (b : α) : StrictWeakOrder.Equiv a b ↔ a = b