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 ⌀ |
|---|---|---|---|---|---|---|
bind_def {α β} : ((· >>= ·) : Erased α → (α → Erased β) → Erased β) = @bind _ _ :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Erased.lean | bind_def | null |
map_def {α β} : ((· <$> ·) : (α → β) → Erased α → Erased β) = @map _ _ :=
rfl | theorem | Data | [
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Erased.lean | map_def | null |
protected instLawfulMonad : LawfulMonad Erased :=
{ id_map := by intros; ext; simp
map_const := by intros; ext; simp [Functor.mapConst]
pure_bind := by intros; ext; simp
bind_assoc := by intros; ext; simp
bind_pure_comp := by intros; ext; simp
bind_map := by intros; ext; simp [Seq.seq]
seqLeft_eq := by intros; ext; simp [Seq.seq, SeqLeft.seqLeft]
seqRight_eq := by intros; ext; simp [Seq.seq, SeqRight.seqRight]
pure_seq := by intros; ext; simp [Seq.seq] } | instance | Data | [
"Mathlib.Logic.Equiv.Defs"
] | Mathlib/Data/Erased.lean | instLawfulMonad | null |
FinEnum (α : Sort*) where
/-- `FinEnum.card` is the cardinality of the `FinEnum` -/
card : ℕ
/-- `FinEnum.Equiv` states that type `α` is in bijection with `Fin card`,
the size of the `FinEnum` -/
equiv : α ≃ Fin card
[decEq : DecidableEq α]
attribute [instance 100] FinEnum.decEq | class | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | FinEnum | `FinEnum α` means that `α` is finite and can be enumerated in some order,
i.e. `α` has an explicit bijection with `Fin n` for some n. |
ofEquiv (α) {β} [FinEnum α] (h : β ≃ α) : FinEnum β where
card := card α
equiv := h.trans (equiv)
decEq := (h.trans (equiv)).decidableEq | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofEquiv | transport a `FinEnum` instance across an equivalence |
ofNodupList [DecidableEq α] (xs : List α) (h : ∀ x : α, x ∈ xs) (h' : List.Nodup xs) :
FinEnum α where
card := xs.length
equiv :=
⟨fun x => ⟨xs.idxOf x, by rw [List.idxOf_lt_length_iff]; apply h⟩, xs.get, fun x => by simp,
fun i => by ext; simp [List.idxOf_getElem h']⟩ | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofNodupList | create a `FinEnum` instance from an exhaustive list without duplicates |
ofList [DecidableEq α] (xs : List α) (h : ∀ x : α, x ∈ xs) : FinEnum α :=
ofNodupList xs.dedup (by simp [*]) (List.nodup_dedup _) | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofList | create a `FinEnum` instance from an exhaustive list; duplicates are removed |
toList (α) [FinEnum α] : List α :=
(List.finRange (card α)).map (equiv).symm
open Function
@[simp] | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | toList | create an exhaustive list of the values of a given type |
mem_toList [FinEnum α] (x : α) : x ∈ toList α := by
simp only [toList, List.mem_map, List.mem_finRange, true_and]; exists equiv x; simp
@[simp] | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | mem_toList | null |
nodup_toList [FinEnum α] : List.Nodup (toList α) := by
simp only [toList]; apply List.Nodup.map <;> [apply Equiv.injective; apply List.nodup_finRange] | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | nodup_toList | null |
ofSurjective {β} (f : β → α) [DecidableEq α] [FinEnum β] (h : Surjective f) : FinEnum α :=
ofList ((toList β).map f) (by intro; simpa using h _) | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofSurjective | create a `FinEnum` instance using a surjection |
noncomputable ofInjective {α β} (f : α → β) [DecidableEq α] [FinEnum β] (h : Injective f) :
FinEnum α :=
ofList ((toList β).filterMap (partialInv f))
(by
intro x
simp only [mem_toList, true_and, List.mem_filterMap]
use f x
simp only [h, Function.partialInv_left]) | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofInjective | create a `FinEnum` instance using an injection |
_root_.ULift.instFinEnum [FinEnum α] : FinEnum (ULift α) :=
⟨card α, Equiv.ulift.trans equiv⟩
@[simp] | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | _root_.ULift.instFinEnum | null |
card_ulift [FinEnum (ULift α)] [FinEnum α] : card (ULift α) = card α :=
Fin.equiv_iff_eq.mp ⟨equiv.symm.trans Equiv.ulift |>.trans equiv⟩ | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_ulift | null |
@[simp] equiv_up : equiv (ULift.up a) = equiv a := rfl
@[simp] lemma equiv_down : equiv a'.down = equiv a' := rfl
@[simp] lemma up_equiv_symm : ULift.up (equiv.symm i) = (equiv (α := ULift α)).symm i := rfl
@[simp] lemma down_equiv_symm : ((equiv (α := ULift α)).symm i).down = equiv.symm i := rfl | lemma | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | equiv_up | null |
pempty : FinEnum PEmpty :=
ofList [] fun x => PEmpty.elim x | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | pempty | null |
empty : FinEnum Empty :=
ofList [] fun x => Empty.elim x | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | empty | null |
punit : FinEnum PUnit :=
ofList [PUnit.unit] fun x => by simp | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | punit | null |
prod {β} [FinEnum α] [FinEnum β] : FinEnum (α × β) :=
ofList (toList α ×ˢ toList β) fun x => by cases x; simp | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | prod | null |
sum {β} [FinEnum α] [FinEnum β] : FinEnum (α ⊕ β) :=
ofList ((toList α).map Sum.inl ++ (toList β).map Sum.inr) fun x => by cases x <;> simp | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | sum | null |
fin {n} : FinEnum (Fin n) :=
ofList (List.finRange _) (by simp)
@[simp] | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | fin | null |
card_fin {n} [FinEnum (Fin n)] : card (Fin n) = n := Fin.equiv_iff_eq.mp ⟨equiv.symm⟩ | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_fin | null |
Quotient.enum [FinEnum α] (s : Setoid α) [DecidableRel ((· ≈ ·) : α → α → Prop)] :
FinEnum (Quotient s) :=
FinEnum.ofSurjective Quotient.mk'' fun x => Quotient.inductionOn x fun x => ⟨x, rfl⟩ | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Quotient.enum | null |
Finset.enum [DecidableEq α] : List α → List (Finset α)
| [] => [∅]
| x :: xs => do
let r ← Finset.enum xs
[r, insert x r]
@[simp, grind =] | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Finset.enum | enumerate all finite sets of a given type |
Finset.mem_enum [DecidableEq α] (s : Finset α) (xs : List α) :
s ∈ Finset.enum xs ↔ ∀ x ∈ s, x ∈ xs := by
induction xs generalizing s with
| nil => simp [enum, eq_empty_iff_forall_notMem]
| cons x xs ih =>
simp only [enum, List.bind_eq_flatMap, List.mem_flatMap, List.mem_cons,
List.not_mem_nil, or_false, ih]
refine ⟨by aesop, fun hs => ⟨s.erase x, ?_⟩⟩
simp only [or_iff_not_imp_left] at hs
simp +contextual [eq_comm (a := s), or_iff_not_imp_left, hs] | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Finset.mem_enum | null |
Finset.finEnum [FinEnum α] : FinEnum (Finset α) :=
ofList (Finset.enum (toList α)) (by simp) | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Finset.finEnum | null |
Subtype.finEnum [FinEnum α] (p : α → Prop) [DecidablePred p] : FinEnum { x // p x } :=
ofList ((toList α).filterMap fun x => if h : p x then some ⟨_, h⟩ else none)
(by rintro ⟨x, h⟩; simpa) | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Subtype.finEnum | null |
PSigma.finEnum [FinEnum α] [∀ a, FinEnum (β a)] : FinEnum (Σ' a, β a) :=
FinEnum.ofEquiv _ (Equiv.psigmaEquivSigma _) | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | PSigma.finEnum | null |
PSigma.finEnumPropLeft {α : Prop} {β : α → Type v} [∀ a, FinEnum (β a)] [Decidable α] :
FinEnum (Σ' a, β a) :=
if h : α then ofList ((toList (β h)).map <| PSigma.mk h) fun ⟨a, Ba⟩ => by simp
else ofList [] fun ⟨a, _⟩ => (h a).elim | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | PSigma.finEnumPropLeft | null |
PSigma.finEnumPropRight {β : α → Prop} [FinEnum α] [∀ a, Decidable (β a)] :
FinEnum (Σ' a, β a) :=
FinEnum.ofEquiv { a // β a }
⟨fun ⟨x, y⟩ => ⟨x, y⟩, fun ⟨x, y⟩ => ⟨x, y⟩, fun ⟨_, _⟩ => rfl, fun ⟨_, _⟩ => rfl⟩ | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | PSigma.finEnumPropRight | null |
PSigma.finEnumPropProp {α : Prop} {β : α → Prop} [Decidable α] [∀ a, Decidable (β a)] :
FinEnum (Σ' a, β a) :=
if h : ∃ a, β a then ofList [⟨h.fst, h.snd⟩] (by simp)
else ofList [] fun a => (h ⟨a.fst, a.snd⟩).elim | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | PSigma.finEnumPropProp | null |
card_eq_fintypeCard {α : Type u} [FinEnum α] [Fintype α] : card α = Fintype.card α :=
Fintype.truncEquivFin α |>.inductionOn (fun h ↦ Fin.equiv_iff_eq.mp ⟨equiv.symm.trans h⟩) | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_eq_fintypeCard | The enumeration merely adds an ordering, leaving the cardinality as is. |
card_unique {α : Type u} (e₁ e₂ : FinEnum α) : e₁.card = e₂.card :=
calc _
_ = _ := @card_eq_fintypeCard _ e₁ inferInstance
_ = _ := Fintype.card_congr' rfl
_ = _ := @card_eq_fintypeCard _ e₂ inferInstance |>.symm | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_unique | Any two enumerations of the same type have the same length. |
card_eq_zero_iff {α : Type u} [FinEnum α] : card α = 0 ↔ IsEmpty α :=
Eq.congr_left card_eq_fintypeCard |>.trans Fintype.card_eq_zero_iff | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_eq_zero_iff | A type indexable by `Fin 0` is empty and vice versa. |
card_eq_zero {α : Type u} [FinEnum α] [IsEmpty α] : card α = 0 :=
card_eq_zero_iff.mpr ‹_› | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_eq_zero | Any enumeration of an empty type has length 0. |
card_pos_iff {α : Type u} [FinEnum α] : 0 < card α ↔ Nonempty α :=
card_eq_fintypeCard (α := α) ▸ Fintype.card_pos_iff | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_pos_iff | A type indexable by `Fin n` with positive `n` is inhabited and vice versa. |
card_pos {α : Type*} [FinEnum α] [Nonempty α] : 0 < card α :=
card_pos_iff.mpr ‹_› | lemma | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_pos | Any non-empty enumeration has more than one element. |
card_ne_zero {α : Type*} [FinEnum α] [Nonempty α] : card α ≠ 0 := card_pos.ne' | lemma | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_ne_zero | No non-empty enumeration has 0 elements. |
card_eq_one (α : Type u) [FinEnum α] [Unique α] : card α = 1 :=
card_eq_fintypeCard.trans <| Fintype.card_eq_one_iff_nonempty_unique.mpr ⟨‹_›⟩ | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | card_eq_one | Any enumeration of a type with unique inhabitant has length 1. |
ofIsEmpty [IsEmpty α] : FinEnum α := default | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofIsEmpty | An empty type has a trivial enumeration. Not registered as an instance, to make sure that there
aren't two definitionally differing instances around. |
ofUnique [Unique α] : FinEnum α := default | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | ofUnique | A type with unique inhabitant has a trivial enumeration. Not registered as an instance, to make
sure that there aren't two definitionally differing instances around. |
mem_pi_toList (xs : List α)
(f : ∀ a, a ∈ xs → β a) : f ∈ pi xs fun x => toList (β x) :=
(mem_pi _ _).mpr fun _ _ ↦ mem_toList _ | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | mem_pi_toList | null |
Pi.enum (β : α → Type*) [∀ a, FinEnum (β a)] : List (∀ a, β a) :=
(pi (toList α) fun x => toList (β x)).map (fun f x => f x (mem_toList _)) | def | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Pi.enum | enumerate all functions whose domain and range are finitely enumerable |
Pi.mem_enum (f : ∀ a, β a) :
f ∈ Pi.enum β := by simpa [Pi.enum] using ⟨fun a _ => f a, mem_pi_toList _ _, rfl⟩ | theorem | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Pi.mem_enum | null |
Pi.finEnum : FinEnum (∀ a, β a) :=
ofList (Pi.enum _) fun _ => Pi.mem_enum _ | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | Pi.finEnum | null |
pfunFinEnum (p : Prop) [Decidable p] (α : p → Type) [∀ hp, FinEnum (α hp)] :
FinEnum (∀ hp : p, α hp) :=
if hp : p then
ofList ((toList (α hp)).map fun x _ => x) (by intro x; simpa using ⟨x hp, rfl⟩)
else ofList [fun hp' => (hp hp').elim] (by simp [funext_iff, hp]) | instance | Data | [
"Mathlib.Data.Fintype.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.List.ProdSigma",
"Mathlib.Data.List.Pi"
] | Mathlib/Data/FinEnum.lean | pfunFinEnum | null |
keys (s : Multiset (Sigma β)) : Multiset α :=
s.map Sigma.fst
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys | Multiset of keys of an association multiset. |
coe_keys {l : List (Sigma β)} : keys (l : Multiset (Sigma β)) = (l.keys : Multiset α) :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | coe_keys | null |
keys_zero : keys (0 : Multiset (Sigma β)) = 0 := rfl
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_zero | null |
keys_cons {a : α} {b : β a} {s : Multiset (Sigma β)} :
keys (⟨a, b⟩ ::ₘ s) = a ::ₘ keys s := by
simp [keys]
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_cons | null |
keys_singleton {a : α} {b : β a} : keys ({⟨a, b⟩} : Multiset (Sigma β)) = {a} := rfl | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_singleton | null |
NodupKeys (s : Multiset (Sigma β)) : Prop :=
Quot.liftOn s List.NodupKeys fun _ _ p => propext <| perm_nodupKeys p
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | NodupKeys | `NodupKeys s` means that `s` has no duplicate keys. |
coe_nodupKeys {l : List (Sigma β)} : @NodupKeys α β l ↔ l.NodupKeys :=
Iff.rfl | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | coe_nodupKeys | null |
nodup_keys {m : Multiset (Σ a, β a)} : m.keys.Nodup ↔ m.NodupKeys := by
rcases m with ⟨l⟩; rfl
alias ⟨_, NodupKeys.nodup_keys⟩ := nodup_keys | lemma | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | nodup_keys | null |
protected NodupKeys.nodup {m : Multiset (Σ a, β a)} (h : m.NodupKeys) : m.Nodup :=
h.nodup_keys.of_map _ | lemma | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | NodupKeys.nodup | null |
Finmap (β : α → Type v) : Type max u v where
/-- The underlying `Multiset` of a `Finmap` -/
entries : Multiset (Sigma β)
/-- There are no duplicate keys in `entries` -/
nodupKeys : entries.NodupKeys | structure | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | Finmap | `Finmap β` is the type of finite maps over a multiset. It is effectively
a quotient of `AList β` by permutation of the underlying list. |
AList.toFinmap (s : AList β) : Finmap β :=
⟨s.entries, s.nodupKeys⟩
local notation:arg "⟦" a "⟧" => AList.toFinmap a | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | AList.toFinmap | The quotient map from `AList` to `Finmap`. |
AList.toFinmap_eq {s₁ s₂ : AList β} :
toFinmap s₁ = toFinmap s₂ ↔ s₁.entries ~ s₂.entries := by
cases s₁
cases s₂
simp [AList.toFinmap]
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | AList.toFinmap_eq | null |
AList.toFinmap_entries (s : AList β) : ⟦s⟧.entries = s.entries :=
rfl | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | AList.toFinmap_entries | null |
List.toFinmap [DecidableEq α] (s : List (Sigma β)) : Finmap β :=
s.toAList.toFinmap | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | List.toFinmap | Given `l : List (Sigma β)`, create a term of type `Finmap β` by removing
entries with duplicate keys. |
nodup_entries (f : Finmap β) : f.entries.Nodup := f.nodupKeys.nodup
/-! ### Lifting from AList -/ | lemma | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | nodup_entries | null |
liftOn {γ} (s : Finmap β) (f : AList β → γ)
(H : ∀ a b : AList β, a.entries ~ b.entries → f a = f b) : γ := by
refine
(Quotient.liftOn s.entries
(fun (l : List (Sigma β)) => (⟨_, fun nd => f ⟨l, nd⟩⟩ : Part γ))
(fun l₁ l₂ p => Part.ext' (perm_nodupKeys p) ?_) : Part γ).get ?_
· exact fun h1 h2 => H _ _ p
· have := s.nodupKeys
revert this
rcases s.entries with ⟨l⟩
exact id
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | liftOn | Lift a permutation-respecting function on `AList` to `Finmap`. |
liftOn_toFinmap {γ} (s : AList β) (f : AList β → γ) (H) : liftOn ⟦s⟧ f H = f s := by
cases s
rfl | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | liftOn_toFinmap | null |
liftOn₂ {γ} (s₁ s₂ : Finmap β) (f : AList β → AList β → γ)
(H : ∀ a₁ b₁ a₂ b₂ : AList β,
a₁.entries ~ a₂.entries → b₁.entries ~ b₂.entries → f a₁ b₁ = f a₂ b₂) : γ :=
liftOn s₁ (fun l₁ => liftOn s₂ (f l₁) fun _ _ p => H _ _ _ _ (Perm.refl _) p) fun a₁ a₂ p => by
have H' : f a₁ = f a₂ := funext fun _ => H _ _ _ _ p (Perm.refl _)
simp only [H']
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | liftOn₂ | Lift a permutation-respecting function on 2 `AList`s to 2 `Finmap`s. |
liftOn₂_toFinmap {γ} (s₁ s₂ : AList β) (f : AList β → AList β → γ) (H) :
liftOn₂ ⟦s₁⟧ ⟦s₂⟧ f H = f s₁ s₂ := by
cases s₁; cases s₂; rfl
/-! ### Induction -/
@[elab_as_elim] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | liftOn₂_toFinmap | null |
induction_on {C : Finmap β → Prop} (s : Finmap β) (H : ∀ a : AList β, C ⟦a⟧) : C s := by
rcases s with ⟨⟨a⟩, h⟩; exact H ⟨a, h⟩
@[elab_as_elim] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | induction_on | null |
induction_on₂ {C : Finmap β → Finmap β → Prop} (s₁ s₂ : Finmap β)
(H : ∀ a₁ a₂ : AList β, C ⟦a₁⟧ ⟦a₂⟧) : C s₁ s₂ :=
induction_on s₁ fun l₁ => induction_on s₂ fun l₂ => H l₁ l₂
@[elab_as_elim] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | induction_on₂ | null |
induction_on₃ {C : Finmap β → Finmap β → Finmap β → Prop} (s₁ s₂ s₃ : Finmap β)
(H : ∀ a₁ a₂ a₃ : AList β, C ⟦a₁⟧ ⟦a₂⟧ ⟦a₃⟧) : C s₁ s₂ s₃ :=
induction_on₂ s₁ s₂ fun l₁ l₂ => induction_on s₃ fun l₃ => H l₁ l₂ l₃
/-! ### extensionality -/
@[ext] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | induction_on₃ | null |
ext : ∀ {s t : Finmap β}, s.entries = t.entries → s = t
| ⟨l₁, h₁⟩, ⟨l₂, _⟩, H => by congr
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | ext | null |
ext_iff' {s t : Finmap β} : s.entries = t.entries ↔ s = t :=
Finmap.ext_iff.symm
/-! ### mem -/ | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | ext_iff' | null |
keys (s : Finmap β) : Finset α :=
⟨s.entries.keys, s.nodupKeys.nodup_keys⟩
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys | The predicate `a ∈ s` means that `s` has a value associated to the key `a`. -/
instance : Membership α (Finmap β) :=
⟨fun s a => a ∈ s.entries.keys⟩
theorem mem_def {a : α} {s : Finmap β} : a ∈ s ↔ a ∈ s.entries.keys :=
Iff.rfl
@[simp]
theorem mem_toFinmap {a : α} {s : AList β} : a ∈ toFinmap s ↔ a ∈ s :=
Iff.rfl
/-! ### keys -/
/-- The set of keys of a finite map. |
keys_val (s : AList β) : (keys ⟦s⟧).val = s.keys :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_val | null |
keys_ext {s₁ s₂ : AList β} : keys ⟦s₁⟧ = keys ⟦s₂⟧ ↔ s₁.keys ~ s₂.keys := by
simp [keys, AList.keys] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_ext | null |
mem_keys {a : α} {s : Finmap β} : a ∈ s.keys ↔ a ∈ s :=
induction_on s fun _ => AList.mem_keys
/-! ### empty -/ | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | mem_keys | null |
singleton (a : α) (b : β a) : Finmap β :=
⟦AList.singleton a b⟧
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | singleton | The empty map. -/
instance : EmptyCollection (Finmap β) :=
⟨⟨0, nodupKeys_nil⟩⟩
instance : Inhabited (Finmap β) :=
⟨∅⟩
@[simp]
theorem empty_toFinmap : (⟦∅⟧ : Finmap β) = ∅ :=
rfl
@[simp]
theorem toFinmap_nil [DecidableEq α] : ([].toFinmap : Finmap β) = ∅ :=
rfl
theorem notMem_empty {a : α} : a ∉ (∅ : Finmap β) :=
Multiset.notMem_zero a
@[deprecated (since := "2025-05-23")] alias not_mem_empty := notMem_empty
@[simp]
theorem keys_empty : (∅ : Finmap β).keys = ∅ :=
rfl
/-! ### singleton -/
/-- The singleton map. |
keys_singleton (a : α) (b : β a) : (singleton a b).keys = {a} :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_singleton | null |
mem_singleton (x y : α) (b : β y) : x ∈ singleton y b ↔ x = y := by
simp [singleton, mem_def] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | mem_singleton | null |
decidableEq [∀ a, DecidableEq (β a)] : DecidableEq (Finmap β)
| _, _ => decidable_of_iff _ Finmap.ext_iff.symm
/-! ### lookup -/ | instance | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | decidableEq | null |
lookup (a : α) (s : Finmap β) : Option (β a) :=
liftOn s (AList.lookup a) fun _ _ => perm_lookup
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup | Look up the value associated to a key in a map. |
lookup_toFinmap (a : α) (s : AList β) : lookup a ⟦s⟧ = s.lookup a :=
rfl
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup_toFinmap | null |
dlookup_list_toFinmap (a : α) (s : List (Sigma β)) : lookup a s.toFinmap = s.dlookup a := by
rw [List.toFinmap, lookup_toFinmap, lookup_to_alist]
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | dlookup_list_toFinmap | null |
lookup_empty (a) : lookup a (∅ : Finmap β) = none :=
rfl | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup_empty | null |
lookup_isSome {a : α} {s : Finmap β} : (s.lookup a).isSome ↔ a ∈ s :=
induction_on s fun _ => AList.lookup_isSome | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup_isSome | null |
lookup_eq_none {a} {s : Finmap β} : lookup a s = none ↔ a ∉ s :=
induction_on s fun _ => AList.lookup_eq_none | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup_eq_none | null |
mem_lookup_iff {s : Finmap β} {a : α} {b : β a} :
b ∈ s.lookup a ↔ Sigma.mk a b ∈ s.entries := by
rcases s with ⟨⟨l⟩, hl⟩; exact List.mem_dlookup_iff hl | lemma | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | mem_lookup_iff | null |
lookup_eq_some_iff {s : Finmap β} {a : α} {b : β a} :
s.lookup a = b ↔ Sigma.mk a b ∈ s.entries := mem_lookup_iff
@[simp] lemma sigma_keys_lookup (s : Finmap β) :
s.keys.sigma (fun i => (s.lookup i).toFinset) = ⟨s.entries, s.nodup_entries⟩ := by
ext x
have : x ∈ s.entries → x.1 ∈ s.keys := Multiset.mem_map_of_mem _
simpa [lookup_eq_some_iff]
@[simp] | lemma | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup_eq_some_iff | null |
lookup_singleton_eq {a : α} {b : β a} : (singleton a b).lookup a = some b := by
rw [singleton, lookup_toFinmap, AList.singleton, AList.lookup, dlookup_cons_eq] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | lookup_singleton_eq | null |
mem_iff {a : α} {s : Finmap β} : a ∈ s ↔ ∃ b, s.lookup a = some b :=
induction_on s fun s =>
Iff.trans List.mem_keys <| exists_congr fun _ => (mem_dlookup_iff s.nodupKeys).symm | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | mem_iff | null |
mem_of_lookup_eq_some {a : α} {b : β a} {s : Finmap β} (h : s.lookup a = some b) : a ∈ s :=
mem_iff.mpr ⟨_, h⟩ | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | mem_of_lookup_eq_some | null |
ext_lookup {s₁ s₂ : Finmap β} : (∀ x, s₁.lookup x = s₂.lookup x) → s₁ = s₂ :=
induction_on₂ s₁ s₂ fun s₁ s₂ h => by
simp only [AList.lookup, lookup_toFinmap] at h
rw [AList.toFinmap_eq]
apply lookup_ext s₁.nodupKeys s₂.nodupKeys
intro x y
rw [h] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | ext_lookup | null |
@[simps apply_coe_fst apply_coe_snd]
keysLookupEquiv :
Finmap β ≃ { f : Finset α × (∀ a, Option (β a)) // ∀ i, (f.2 i).isSome ↔ i ∈ f.1 } where
toFun s := ⟨(s.keys, fun i => s.lookup i), fun _ => lookup_isSome⟩
invFun f := mk (f.1.1.sigma fun i => (f.1.2 i).toFinset).val <| by
refine Multiset.nodup_keys.1 ((Finset.nodup _).map_on ?_)
simp only [Finset.mem_val, Finset.mem_sigma, Option.mem_toFinset, Option.mem_def]
rintro ⟨i, x⟩ ⟨_, hx⟩ ⟨j, y⟩ ⟨_, hy⟩ (rfl : i = j)
simpa using hx.symm.trans hy
left_inv f := ext <| by simp
right_inv := fun ⟨(s, f), hf⟩ => by
dsimp only at hf
ext
· simp [keys, Multiset.keys, ← hf, Option.isSome_iff_exists]
· simp +contextual [lookup_eq_some_iff, ← hf]
@[simp] lemma keysLookupEquiv_symm_apply_keys :
∀ f : {f : Finset α × (∀ a, Option (β a)) // ∀ i, (f.2 i).isSome ↔ i ∈ f.1},
(keysLookupEquiv.symm f).keys = f.1.1 :=
keysLookupEquiv.surjective.forall.2 fun _ => by
simp only [Equiv.symm_apply_apply, keysLookupEquiv_apply_coe_fst]
@[simp] lemma keysLookupEquiv_symm_apply_lookup :
∀ (f : {f : Finset α × (∀ a, Option (β a)) // ∀ i, (f.2 i).isSome ↔ i ∈ f.1}) a,
(keysLookupEquiv.symm f).lookup a = f.1.2 a :=
keysLookupEquiv.surjective.forall.2 fun _ _ => by
simp only [Equiv.symm_apply_apply, keysLookupEquiv_apply_coe_snd]
/-! ### replace -/ | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keysLookupEquiv | An equivalence between `Finmap β` and pairs `(keys : Finset α, lookup : ∀ a, Option (β a))` such
that `(lookup a).isSome ↔ a ∈ keys`. |
replace (a : α) (b : β a) (s : Finmap β) : Finmap β :=
(liftOn s fun t => AList.toFinmap (AList.replace a b t))
fun _ _ p => toFinmap_eq.2 <| perm_replace p
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | replace | Replace a key with a given value in a finite map.
If the key is not present it does nothing. |
replace_toFinmap (a : α) (b : β a) (s : AList β) :
replace a b ⟦s⟧ = (⟦s.replace a b⟧ : Finmap β) := by
simp [replace]
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | replace_toFinmap | null |
keys_replace (a : α) (b : β a) (s : Finmap β) : (replace a b s).keys = s.keys :=
induction_on s fun s => by simp
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | keys_replace | null |
mem_replace {a a' : α} {b : β a} {s : Finmap β} : a' ∈ replace a b s ↔ a' ∈ s :=
induction_on s fun s => by simp | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | mem_replace | null |
foldl {δ : Type w} (f : δ → ∀ a, β a → δ)
(H : ∀ d a₁ b₁ a₂ b₂, f (f d a₁ b₁) a₂ b₂ = f (f d a₂ b₂) a₁ b₁) (d : δ) (m : Finmap β) : δ :=
letI : RightCommutative fun d (s : Sigma β) ↦ f d s.1 s.2 := ⟨fun _ _ _ ↦ H _ _ _ _ _⟩
m.entries.foldl (fun d s => f d s.1 s.2) d | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | foldl | Fold a commutative function over the key-value pairs in the map |
any (f : ∀ x, β x → Bool) (s : Finmap β) : Bool :=
s.foldl (fun x y z => x || f y z)
(fun _ _ _ _ => by simp_rw [Bool.or_assoc, Bool.or_comm, imp_true_iff]) false | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | any | `any f s` returns `true` iff there exists a value `v` in `s` such that `f v = true`. |
all (f : ∀ x, β x → Bool) (s : Finmap β) : Bool :=
s.foldl (fun x y z => x && f y z)
(fun _ _ _ _ => by simp_rw [Bool.and_assoc, Bool.and_comm, imp_true_iff]) true
/-! ### erase -/ | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | all | `all f s` returns `true` iff `f v = true` for all values `v` in `s`. |
erase (a : α) (s : Finmap β) : Finmap β :=
(liftOn s fun t => AList.toFinmap (AList.erase a t)) fun _ _ p => toFinmap_eq.2 <| perm_erase p
@[simp] | def | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | erase | Erase a key from the map. If the key is not present it does nothing. |
erase_toFinmap (a : α) (s : AList β) : erase a ⟦s⟧ = AList.toFinmap (s.erase a) := by
simp [erase]
@[simp] | theorem | Data | [
"Mathlib.Data.List.AList",
"Mathlib.Data.Finset.Sigma",
"Mathlib.Data.Part"
] | Mathlib/Data/Finmap.lean | erase_toFinmap | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.