fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
@[mk_iff]
IsPrime (F : PFilter P) : Prop where
compl_ideal : IsIdeal (F : Set P)ᶜ | class | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime | A filter `F` is prime if its complement is an ideal. |
IsPrime.toPrimePair {F : PFilter P} (h : IsPrime F) : Ideal.PrimePair P :=
{ I := h.compl_ideal.toIdeal
F
isCompl_I_F := isCompl_compl.symm } | def | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | IsPrime.toPrimePair | Create an element of type `Order.Ideal.PrimePair` from a filter satisfying the predicate
`Order.PFilter.IsPrime`. |
_root_.Order.Ideal.PrimePair.F_isPrime (IF : Ideal.PrimePair P) : IsPrime IF.F :=
{
compl_ideal := by
rw [IF.compl_F_eq_I]
exact IF.I.isIdeal } | theorem | Order | [
"Mathlib.Order.Ideal",
"Mathlib.Order.PFilter"
] | Mathlib/Order/PrimeIdeal.lean | _root_.Order.Ideal.PrimePair.F_isPrime | null |
mem_ideal_sup_principal (a b : α) (J : Ideal α) : b ∈ J ⊔ principal a ↔ ∃ j ∈ J, b ≤ j ⊔ a :=
⟨fun ⟨j, ⟨jJ, _, ha', bja'⟩⟩ => ⟨j, jJ, le_trans bja' (sup_le_sup_left ha' j)⟩,
fun ⟨j, hj, hbja⟩ => ⟨j, hj, a, le_refl a, hbja⟩⟩ | lemma | Order | [
"Mathlib.Order.PrimeIdeal",
"Mathlib.Order.Zorn"
] | Mathlib/Order/PrimeSeparator.lean | mem_ideal_sup_principal | null |
prime_ideal_of_disjoint_filter_ideal (hFI : Disjoint (F : Set α) (I : Set α)) :
∃ J : Ideal α, (IsPrime J) ∧ I ≤ J ∧ Disjoint (F : Set α) J := by
set S : Set (Set α) := { J : Set α | IsIdeal J ∧ I ≤ J ∧ Disjoint (F : Set α) J }
have IinS : ↑I ∈ S := by
refine ⟨Order.Ideal.isIdeal I, by trivial⟩
have chain... | theorem | Order | [
"Mathlib.Order.PrimeIdeal",
"Mathlib.Order.Zorn"
] | Mathlib/Order/PrimeSeparator.lean | prime_ideal_of_disjoint_filter_ideal | null |
Prop.instDistribLattice : DistribLattice Prop where
sup := Or
le_sup_left := @Or.inl
le_sup_right := @Or.inr
sup_le := fun _ _ _ => Or.rec
inf := And
inf_le_left := @And.left
inf_le_right := @And.right
le_inf := fun _ _ _ Hab Hac Ha => And.intro (Hab Ha) (Hac Ha)
le_sup_inf := fun _ _ _ => or_and_left... | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.instDistribLattice | Propositions form a distributive lattice. |
Prop.instBoundedOrder : BoundedOrder Prop where
top := True
le_top _ _ := True.intro
bot := False
bot_le := @False.elim
@[simp] | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.instBoundedOrder | Propositions form a bounded order. |
Prop.bot_eq_false : (⊥ : Prop) = False :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.bot_eq_false | null |
Prop.top_eq_true : (⊤ : Prop) = True :=
rfl | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.top_eq_true | null |
Prop.le_isTotal : IsTotal Prop (· ≤ ·) :=
⟨fun p q => by by_cases h : q <;> simp [h]⟩ | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.le_isTotal | null |
noncomputable Prop.linearOrder : LinearOrder Prop := by
classical
exact Lattice.toLinearOrder Prop
@[simp] | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.linearOrder | null |
sup_Prop_eq : (· ⊔ ·) = (· ∨ ·) :=
rfl
@[simp] | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | sup_Prop_eq | null |
inf_Prop_eq : (· ⊓ ·) = (· ∧ ·) :=
rfl | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | inf_Prop_eq | null |
disjoint_iff [∀ i, OrderBot (α' i)] {f g : ∀ i, α' i} :
Disjoint f g ↔ ∀ i, Disjoint (f i) (g i) := by
classical
constructor
· intro h i x hf hg
exact (update_le_iff.mp <| h (update_le_iff.mpr ⟨hf, fun _ _ => bot_le⟩)
(update_le_iff.mpr ⟨hg, fun _ _ => bot_le⟩)).1
· intro h x hf hg i
apply h i... | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | disjoint_iff | null |
codisjoint_iff [∀ i, OrderTop (α' i)] {f g : ∀ i, α' i} :
Codisjoint f g ↔ ∀ i, Codisjoint (f i) (g i) :=
@disjoint_iff _ (fun i => (α' i)ᵒᵈ) _ _ _ _ | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | codisjoint_iff | null |
isCompl_iff [∀ i, BoundedOrder (α' i)] {f g : ∀ i, α' i} :
IsCompl f g ↔ ∀ i, IsCompl (f i) (g i) := by
simp_rw [_root_.isCompl_iff, disjoint_iff, codisjoint_iff, forall_and] | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | isCompl_iff | null |
@[simp]
Prop.disjoint_iff {P Q : Prop} : Disjoint P Q ↔ ¬(P ∧ Q) :=
disjoint_iff_inf_le
@[simp] | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.disjoint_iff | null |
Prop.codisjoint_iff {P Q : Prop} : Codisjoint P Q ↔ P ∨ Q :=
codisjoint_iff_le_sup.trans <| forall_const True
@[simp] | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.codisjoint_iff | null |
Prop.isCompl_iff {P Q : Prop} : IsCompl P Q ↔ ¬(P ↔ Q) := by
rw [_root_.isCompl_iff, Prop.disjoint_iff, Prop.codisjoint_iff, not_iff]
by_cases P <;> by_cases Q <;> simp [*] | theorem | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.isCompl_iff | null |
Prop.decidablePredBot : DecidablePred (⊥ : α → Prop) := fun _ => instDecidableFalse | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.decidablePredBot | null |
Prop.decidablePredTop : DecidablePred (⊤ : α → Prop) := fun _ => instDecidableTrue | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.decidablePredTop | null |
Prop.decidableRelBot : DecidableRel (⊥ : α → α → Prop) := fun _ _ => instDecidableFalse | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.decidableRelBot | null |
Prop.decidableRelTop : DecidableRel (⊤ : α → α → Prop) := fun _ _ => instDecidableTrue | instance | Order | [
"Mathlib.Order.Disjoint"
] | Mathlib/Order/PropInstances.lean | Prop.decidableRelTop | null |
Order.radical (α : Type*) [Preorder α] [OrderTop α] [InfSet α] : α :=
⨅ a ∈ {H | IsCoatom H}, a
variable {α : Type*} [CompleteLattice α] | def | Order | [
"Mathlib.Order.Atoms"
] | Mathlib/Order/Radical.lean | Order.radical | The infimum of all coatoms.
This notion specializes, e.g. in the subgroup lattice of a group to the Frattini subgroup,
or in the lattices of ideals in a ring `R` to the Jacobson ideal. |
Order.radical_le_coatom {a : α} (h : IsCoatom a) : radical α ≤ a := biInf_le _ h
variable {β : Type*} [CompleteLattice β] | lemma | Order | [
"Mathlib.Order.Atoms"
] | Mathlib/Order/Radical.lean | Order.radical_le_coatom | null |
OrderIso.map_radical (f : α ≃o β) : f (Order.radical α) = Order.radical β := by
unfold Order.radical
simp only [OrderIso.map_iInf]
fapply Equiv.iInf_congr
· exact f.toEquiv
· simp | theorem | Order | [
"Mathlib.Order.Atoms"
] | Mathlib/Order/Radical.lean | OrderIso.map_radical | null |
Order.radical_nongenerating [IsCoatomic α] {a : α} (h : a ⊔ radical α = ⊤) : a = ⊤ := by
obtain (rfl | w) := eq_top_or_exists_le_coatom a
· -- In the first case, we're done, this was already the goal.
rfl
· obtain ⟨m, c, le⟩ := w
have q : a ⊔ radical α ≤ m := sup_le le (radical_le_coatom c)
rw [h, top... | theorem | Order | [
"Mathlib.Order.Atoms"
] | Mathlib/Order/Radical.lean | Order.radical_nongenerating | null |
IsRefl.swap (r) [IsRefl α r] : IsRefl α (swap r) :=
⟨refl_of r⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsRefl.swap | null |
IsIrrefl.swap (r) [IsIrrefl α r] : IsIrrefl α (swap r) :=
⟨irrefl_of r⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsIrrefl.swap | null |
IsTrans.swap (r) [IsTrans α r] : IsTrans α (swap r) :=
⟨fun _ _ _ h₁ h₂ => trans_of r h₂ h₁⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsTrans.swap | null |
IsAntisymm.swap (r) [IsAntisymm α r] : IsAntisymm α (swap r) :=
⟨fun _ _ h₁ h₂ => _root_.antisymm h₂ h₁⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsAntisymm.swap | null |
IsAsymm.swap (r) [IsAsymm α r] : IsAsymm α (swap r) :=
⟨fun _ _ h₁ h₂ => asymm_of r h₂ h₁⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsAsymm.swap | null |
IsTotal.swap (r) [IsTotal α r] : IsTotal α (swap r) :=
⟨fun a b => (total_of r a b).symm⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsTotal.swap | null |
IsTrichotomous.swap (r) [IsTrichotomous α r] : IsTrichotomous α (swap r) :=
⟨fun a b => by simpa [Function.swap, or_comm, or_left_comm] using trichotomous_of r a b⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsTrichotomous.swap | null |
IsPreorder.swap (r) [IsPreorder α r] : IsPreorder α (swap r) :=
{ @IsRefl.swap α r _, @IsTrans.swap α r _ with } | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsPreorder.swap | null |
IsStrictOrder.swap (r) [IsStrictOrder α r] : IsStrictOrder α (swap r) :=
{ @IsIrrefl.swap α r _, @IsTrans.swap α r _ with } | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsStrictOrder.swap | null |
IsPartialOrder.swap (r) [IsPartialOrder α r] : IsPartialOrder α (swap r) :=
{ @IsPreorder.swap α r _, @IsAntisymm.swap α r _ with } | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsPartialOrder.swap | null |
eq_empty_relation (r) [IsIrrefl α r] [Subsingleton α] : r = EmptyRelation :=
funext₂ <| by simpa using not_rel_of_subsingleton r | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | eq_empty_relation | null |
partialOrderOfSO (r) [IsStrictOrder α r] : PartialOrder α where
le x y := x = y ∨ r x y
lt := r
le_refl _ := Or.inl rfl
le_trans x y z h₁ h₂ :=
match y, z, h₁, h₂ with
| _, _, Or.inl rfl, h₂ => h₂
| _, _, h₁, Or.inl rfl => h₁
| _, _, Or.inr h₁, Or.inr h₂ => Or.inr (_root_.trans h₁ h₂)
le_antis... | abbrev | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | partialOrderOfSO | Construct a partial order from an `isStrictOrder` relation.
See note [reducible non-instances]. |
linearOrderOfSTO (r) [IsStrictTotalOrder α r] [DecidableRel r] : LinearOrder α :=
let hD : DecidableRel (fun x y => x = y ∨ r x y) := fun x y => decidable_of_iff (¬r y x)
⟨fun h => ((trichotomous_of r y x).resolve_left h).imp Eq.symm id, fun h =>
h.elim (fun h => h ▸ irrefl_of _ _) (asymm_of r)⟩
{ __ := p... | abbrev | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | linearOrderOfSTO | Construct a linear order from an `IsStrictTotalOrder` relation.
See note [reducible non-instances]. |
IsStrictTotalOrder.swap (r) [IsStrictTotalOrder α r] : IsStrictTotalOrder α (swap r) :=
{ IsTrichotomous.swap r, IsStrictOrder.swap r with }
/-! ### Order connection -/ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsStrictTotalOrder.swap | null |
IsOrderConnected (α : Type u) (lt : α → α → Prop) : Prop where
/-- A connected order is one satisfying the condition `a < c → a < b ∨ b < c`. -/
conn : ∀ a b c, lt a c → lt a b ∨ lt b c | class | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsOrderConnected | A connected order is one satisfying the condition `a < c → a < b ∨ b < c`.
This is recognizable as an intuitionistic substitute for `a ≤ b ∨ b ≤ a` on
the constructive reals, and is also known as negative transitivity,
since the contrapositive asserts transitivity of the relation `¬ a < b`. |
IsOrderConnected.neg_trans {r : α → α → Prop} [IsOrderConnected α r] {a b c}
(h₁ : ¬r a b) (h₂ : ¬r b c) : ¬r a c :=
mt (IsOrderConnected.conn a b c) <| by simp [h₁, h₂] | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsOrderConnected.neg_trans | null |
isStrictWeakOrder_of_isOrderConnected [IsAsymm α r] [IsOrderConnected α r] :
IsStrictWeakOrder α r :=
{ @IsAsymm.isIrrefl α r _ with
trans := fun _ _ c h₁ h₂ => (IsOrderConnected.conn _ c _ h₁).resolve_right (asymm h₂),
incomp_trans := fun _ _ _ ⟨h₁, h₂⟩ ⟨h₃, h₄⟩ =>
⟨IsOrderConnected.neg_trans h₁ h₃... | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | isStrictWeakOrder_of_isOrderConnected | null |
InvImage.isTrichotomous [IsTrichotomous α r] {f : β → α} (h : Function.Injective f) :
IsTrichotomous β (InvImage r f) where
trichotomous a b := trichotomous (f a) (f b) |>.imp3 id (h ·) id | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | InvImage.isTrichotomous | null |
InvImage.isAsymm [IsAsymm α r] (f : β → α) : IsAsymm β (InvImage r f) where
asymm a b h h2 := IsAsymm.asymm (f a) (f b) h h2
/-! ### Well-order -/ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | InvImage.isAsymm | null |
@[mk_iff] IsWellFounded (α : Type u) (r : α → α → Prop) : Prop where
/-- The relation is `WellFounded`, as a proposition. -/
wf : WellFounded r | class | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsWellFounded | A well-founded relation. Not to be confused with `IsWellOrder`. |
WellFoundedRelation.isWellFounded [h : WellFoundedRelation α] :
IsWellFounded α WellFoundedRelation.rel :=
{ h with } | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFoundedRelation.isWellFounded | null |
WellFoundedRelation.asymmetric {α : Sort*} [WellFoundedRelation α] {a b : α} :
WellFoundedRelation.rel a b → ¬ WellFoundedRelation.rel b a :=
fun hab hba => WellFoundedRelation.asymmetric hba hab
termination_by a | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFoundedRelation.asymmetric | null |
WellFoundedRelation.asymmetric₃ {α : Sort*} [WellFoundedRelation α] {a b c : α} :
WellFoundedRelation.rel a b → WellFoundedRelation.rel b c → ¬ WellFoundedRelation.rel c a :=
fun hab hbc hca => WellFoundedRelation.asymmetric₃ hca hab hbc
termination_by a | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFoundedRelation.asymmetric₃ | null |
WellFounded.prod_lex {ra : α → α → Prop} {rb : β → β → Prop} (ha : WellFounded ra)
(hb : WellFounded rb) : WellFounded (Prod.Lex ra rb) :=
(Prod.lex ⟨_, ha⟩ ⟨_, hb⟩).wf | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFounded.prod_lex | null |
WellFounded.psigma_lex
{α : Sort*} {β : α → Sort*} {r : α → α → Prop} {s : ∀ a : α, β a → β a → Prop}
(ha : WellFounded r) (hb : ∀ x, WellFounded (s x)) : WellFounded (Lex r s) :=
WellFounded.intro fun ⟨a, b⟩ => lexAccessible (WellFounded.apply ha a) hb b | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFounded.psigma_lex | The lexicographical order of well-founded relations is well-founded. |
WellFounded.psigma_revLex
{α : Sort*} {β : Sort*} {r : α → α → Prop} {s : β → β → Prop}
(ha : WellFounded r) (hb : WellFounded s) : WellFounded (RevLex r s) :=
WellFounded.intro fun ⟨a, b⟩ => revLexAccessible (apply hb b) (WellFounded.apply ha) a | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFounded.psigma_revLex | null |
WellFounded.psigma_skipLeft (α : Type u) {β : Type v} {s : β → β → Prop}
(hb : WellFounded s) : WellFounded (SkipLeft α s) :=
psigma_revLex emptyWf.wf hb | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFounded.psigma_skipLeft | null |
induction {C : α → Prop} (a : α) (ind : ∀ x, (∀ y, r y x → C y) → C x) : C a :=
wf.induction _ ind | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | induction | Induction on a well-founded relation. |
apply : ∀ a, Acc r a :=
wf.apply | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | apply | All values are accessible under the well-founded relation. |
fix {C : α → Sort*} : (∀ x : α, (∀ y : α, r y x → C y) → C x) → ∀ x : α, C x :=
wf.fix | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | fix | Creates data, given a way to generate a value from all that compare as less under a well-founded
relation. See also `IsWellFounded.fix_eq`. |
fix_eq {C : α → Sort*} (F : ∀ x : α, (∀ y : α, r y x → C y) → C x) :
∀ x, fix r F x = F x fun y _ => fix r F y :=
wf.fix_eq F | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | fix_eq | The value from `IsWellFounded.fix` is built from the previous ones as specified. |
toWellFoundedRelation : WellFoundedRelation α :=
⟨r, IsWellFounded.wf⟩ | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | toWellFoundedRelation | Derive a `WellFoundedRelation` instance from an `isWellFounded` instance. |
WellFounded.asymmetric {α : Sort*} {r : α → α → Prop} (h : WellFounded r) (a b) :
r a b → ¬r b a :=
@WellFoundedRelation.asymmetric _ ⟨_, h⟩ _ _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFounded.asymmetric | null |
WellFounded.asymmetric₃ {α : Sort*} {r : α → α → Prop} (h : WellFounded r) (a b c) :
r a b → r b c → ¬r c a :=
@WellFoundedRelation.asymmetric₃ _ ⟨_, h⟩ _ _ _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFounded.asymmetric₃ | null |
WellFoundedLT (α : Type*) [LT α] : Prop :=
IsWellFounded α (· < ·) | abbrev | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFoundedLT | A class for a well-founded relation `<`. |
WellFoundedGT (α : Type*) [LT α] : Prop :=
IsWellFounded α (· > ·) | abbrev | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | WellFoundedGT | A class for a well-founded relation `>`. |
wellFounded_lt [LT α] [WellFoundedLT α] : @WellFounded α (· < ·) := IsWellFounded.wf | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | wellFounded_lt | null |
wellFounded_gt [LT α] [WellFoundedGT α] : @WellFounded α (· > ·) := IsWellFounded.wf | lemma | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | wellFounded_gt | null |
wellFoundedGT_dual_iff (α : Type*) [LT α] : WellFoundedGT αᵒᵈ ↔ WellFoundedLT α :=
⟨fun h => ⟨h.wf⟩, fun h => ⟨h.wf⟩⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | wellFoundedGT_dual_iff | null |
wellFoundedLT_dual_iff (α : Type*) [LT α] : WellFoundedLT αᵒᵈ ↔ WellFoundedGT α :=
⟨fun h => ⟨h.wf⟩, fun h => ⟨h.wf⟩⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | wellFoundedLT_dual_iff | null |
IsWellOrder (α : Type u) (r : α → α → Prop) : Prop
extends IsTrichotomous α r, IsTrans α r, IsWellFounded α r | class | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsWellOrder | A well order is a well-founded linear order. |
induction {C : α → Prop} (a : α) (ind : ∀ x, (∀ y, y < x → C y) → C x) : C a :=
IsWellFounded.induction _ _ ind | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | induction | Inducts on a well-founded `<` relation. |
apply : ∀ a : α, Acc (· < ·) a :=
IsWellFounded.apply _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | apply | All values are accessible under the well-founded `<`. |
fix {C : α → Sort*} : (∀ x : α, (∀ y : α, y < x → C y) → C x) → ∀ x : α, C x :=
IsWellFounded.fix (· < ·) | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | fix | Creates data, given a way to generate a value from all that compare as lesser. See also
`WellFoundedLT.fix_eq`. |
fix_eq {C : α → Sort*} (F : ∀ x : α, (∀ y : α, y < x → C y) → C x) :
∀ x, fix F x = F x fun y _ => fix F y :=
IsWellFounded.fix_eq _ F | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | fix_eq | The value from `WellFoundedLT.fix` is built from the previous ones as specified. |
toWellFoundedRelation : WellFoundedRelation α :=
IsWellFounded.toWellFoundedRelation (· < ·) | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | toWellFoundedRelation | Derive a `WellFoundedRelation` instance from a `WellFoundedLT` instance. |
induction {C : α → Prop} (a : α) (ind : ∀ x, (∀ y, x < y → C y) → C x) : C a :=
IsWellFounded.induction _ _ ind | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | induction | Inducts on a well-founded `>` relation. |
apply : ∀ a : α, Acc (· > ·) a :=
IsWellFounded.apply _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | apply | All values are accessible under the well-founded `>`. |
fix {C : α → Sort*} : (∀ x : α, (∀ y : α, x < y → C y) → C x) → ∀ x : α, C x :=
IsWellFounded.fix (· > ·) | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | fix | Creates data, given a way to generate a value from all that compare as greater. See also
`WellFoundedGT.fix_eq`. |
fix_eq {C : α → Sort*} (F : ∀ x : α, (∀ y : α, x < y → C y) → C x) :
∀ x, fix F x = F x fun y _ => fix F y :=
IsWellFounded.fix_eq _ F | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | fix_eq | The value from `WellFoundedGT.fix` is built from the successive ones as specified. |
toWellFoundedRelation : WellFoundedRelation α :=
IsWellFounded.toWellFoundedRelation (· > ·) | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | toWellFoundedRelation | Derive a `WellFoundedRelation` instance from a `WellFoundedGT` instance. |
noncomputable IsWellOrder.linearOrder (r : α → α → Prop) [IsWellOrder α r] : LinearOrder α :=
linearOrderOfSTO r | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsWellOrder.linearOrder | Construct a decidable linear order from a well-founded linear order. |
IsWellOrder.toHasWellFounded [LT α] [hwo : IsWellOrder α (· < ·)] : WellFoundedRelation α where
rel := (· < ·)
wf := hwo.wf | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | IsWellOrder.toHasWellFounded | Derive a `WellFoundedRelation` instance from an `IsWellOrder` instance. |
Subsingleton.isWellOrder [Subsingleton α] (r : α → α → Prop) [hr : IsIrrefl α r] :
IsWellOrder α r :=
{ hr with
trichotomous := fun a b => Or.inr <| Or.inl <| Subsingleton.elim a b,
trans := fun a b _ h => (not_rel_of_subsingleton r a b h).elim,
wf := ⟨fun a => ⟨_, fun y h => (not_rel_of_subsingleton ... | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Subsingleton.isWellOrder | null |
Prod.Lex.instIsWellFounded [IsWellFounded α r] [IsWellFounded β s] :
IsWellFounded (α × β) (Prod.Lex r s) :=
⟨IsWellFounded.wf.prod_lex IsWellFounded.wf⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Prod.Lex.instIsWellFounded | null |
Subrelation.isWellFounded (r : α → α → Prop) [IsWellFounded α r] {s : α → α → Prop}
(h : Subrelation s r) : IsWellFounded α s :=
⟨h.wf IsWellFounded.wf⟩ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Subrelation.isWellFounded | null |
Prod.wellFoundedLT' [PartialOrder α] [WellFoundedLT α] [Preorder β] [WellFoundedLT β] :
WellFoundedLT (α × β) :=
Subrelation.isWellFounded (Prod.Lex (· < ·) (· < ·))
fun {x y} h ↦ (Prod.lt_iff.mp h).elim (fun h ↦ .left _ _ h.1)
fun h ↦ h.1.lt_or_eq.elim (.left _ _) <| by cases x; cases y; rintro rfl; exac... | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Prod.wellFoundedLT' | See `Prod.wellFoundedLT` for a version that only requires `Preorder α`. |
Prod.wellFoundedGT' [PartialOrder α] [WellFoundedGT α] [Preorder β] [WellFoundedGT β] :
WellFoundedGT (α × β) :=
@Prod.wellFoundedLT' αᵒᵈ βᵒᵈ _ _ _ _ | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Prod.wellFoundedGT' | See `Prod.wellFoundedGT` for a version that only requires `Preorder α`. |
Unbounded (r : α → α → Prop) (s : Set α) : Prop :=
∀ a, ∃ b ∈ s, ¬r b a | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Unbounded | An unbounded or cofinal set. |
Bounded (r : α → α → Prop) (s : Set α) : Prop :=
∃ a, ∀ b ∈ s, r b a
@[simp] | def | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | Bounded | A bounded or final set. Not to be confused with `Bornology.IsBounded`. |
not_bounded_iff {r : α → α → Prop} (s : Set α) : ¬Bounded r s ↔ Unbounded r s := by
simp only [Bounded, Unbounded, not_forall, not_exists, exists_prop]
@[simp] | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | not_bounded_iff | null |
not_unbounded_iff {r : α → α → Prop} (s : Set α) : ¬Unbounded r s ↔ Bounded r s := by
rw [not_iff_comm, not_bounded_iff] | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | not_unbounded_iff | null |
unbounded_of_isEmpty [IsEmpty α] {r : α → α → Prop} (s : Set α) : Unbounded r s :=
isEmptyElim | theorem | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | unbounded_of_isEmpty | null |
instIsRefl [IsRefl α r] {f : β → α} : IsRefl β (f ⁻¹'o r) :=
⟨fun _ => refl_of r _⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsRefl | null |
instIsIrrefl [IsIrrefl α r] {f : β → α} : IsIrrefl β (f ⁻¹'o r) :=
⟨fun _ => irrefl_of r _⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsIrrefl | null |
instIsSymm [IsSymm α r] {f : β → α} : IsSymm β (f ⁻¹'o r) :=
⟨fun _ _ ↦ symm_of r⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsSymm | null |
instIsAsymm [IsAsymm α r] {f : β → α} : IsAsymm β (f ⁻¹'o r) :=
⟨fun _ _ ↦ asymm_of r⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsAsymm | null |
instIsTrans [IsTrans α r] {f : β → α} : IsTrans β (f ⁻¹'o r) :=
⟨fun _ _ _ => trans_of r⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsTrans | null |
instIsPreorder [IsPreorder α r] {f : β → α} : IsPreorder β (f ⁻¹'o r) where | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsPreorder | null |
instIsStrictOrder [IsStrictOrder α r] {f : β → α} : IsStrictOrder β (f ⁻¹'o r) where | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsStrictOrder | null |
instIsStrictWeakOrder [IsStrictWeakOrder α r] {f : β → α} :
IsStrictWeakOrder β (f ⁻¹'o r) where
incomp_trans _ _ _ := IsStrictWeakOrder.incomp_trans (lt := r) _ _ _ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsStrictWeakOrder | null |
instIsEquiv [IsEquiv α r] {f : β → α} : IsEquiv β (f ⁻¹'o r) where | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsEquiv | null |
instIsTotal [IsTotal α r] {f : β → α} : IsTotal β (f ⁻¹'o r) :=
⟨fun _ _ => total_of r _ _⟩ | instance | Order | [
"Mathlib.Logic.IsEmpty",
"Mathlib.Order.Basic",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Batteries.WF"
] | Mathlib/Order/RelClasses.lean | instIsTotal | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.