ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.ModEq.sub
@[gcongr]
protected theorem sub (h₁ : a ≡ b [ZMOD n]) (h₂ : c ≡ d [ZMOD n]) : a - c ≡ b - d [ZMOD n] 
Arguments: {n a b c d : ℤ} (h₁ : a ≡ b [ZMOD n]) (h₂ : c ≡ d [ZMOD n])
Goal: a - c ≡ b - d [ZMOD n]
-- Int.ModEq.sub_left
@[gcongr] protected theorem sub_left (c : ℤ) (h : a ≡ b [ZMOD n]) : c - a ≡ c - b [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a ≡ b [ZMOD n])
Goal: c - a ≡ c - b [ZMOD n]
-- Int.ModEq.sub_right
@[gcongr] protected theorem sub_right (c : ℤ) (h : a ≡ b [ZMOD n]) : a - c ≡ b - c [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a ≡ b [ZMOD n])
Goal: a - c ≡ b - c [ZMOD n]
-- Int.ModEq.mul_left
@[gcongr] protected theorem mul_left (c : ℤ) (h : a ≡ b [ZMOD n]) : c * a ≡ c * b [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a ≡ b [ZMOD n])
Goal: c * a ≡ c * b [ZMOD n]
-- Int.ModEq.mul_right
@[gcongr] protected theorem mul_right (c : ℤ) (h : a ≡ b [ZMOD n]) : a * c ≡ b * c [ZMOD n] 
Arguments: {n a b : ℤ} (c : ℤ) (h : a ≡ b [ZMOD n])
Goal: a * c ≡ b * c [ZMOD n]
-- Int.ModEq.mul
@[gcongr]
protected theorem mul (h₁ : a ≡ b [ZMOD n]) (h₂ : c ≡ d [ZMOD n]) : a * c ≡ b * d [ZMOD n] 
Arguments: {n a b c d : ℤ} (h₁ : a ≡ b [ZMOD n]) (h₂ : c ≡ d [ZMOD n])
Goal: a * c ≡ b * d [ZMOD n]
-- Int.ModEq.pow
@[gcongr] protected theorem pow (m : ℕ) (h : a ≡ b [ZMOD n]) : a ^ m ≡ b ^ m [ZMOD n] 
Arguments: {n a b : ℤ} (m : ℕ) (h : a ≡ b [ZMOD n])
Goal: a ^ m ≡ b ^ m [ZMOD n]
-- Int.ModEq.of_mul_left
lemma of_mul_left (m : ℤ) (h : a ≡ b [ZMOD m * n]) : a ≡ b [ZMOD n] 
Arguments: {n a b : ℤ} (m : ℤ) (h : a ≡ b [ZMOD m * n])
Goal: a ≡ b [ZMOD n]
-- Int.ModEq.of_mul_right
lemma of_mul_right (m : ℤ) : a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n] 
Arguments: {n a b : ℤ} (m : ℤ)
Goal: a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n]
-- Int.ModEq.cancel_right_div_gcd
theorem cancel_right_div_gcd (hm : 0 < m) (h : a * c ≡ b * c [ZMOD m]) :
    a ≡ b [ZMOD m / gcd m c] 
Arguments: {m a b c : ℤ} (hm : 0 < m) (h : a * c ≡ b * c [ZMOD m])
Goal: a ≡ b [ZMOD m / ↑(m.gcd c)]
-- Int.ModEq.cancel_left_div_gcd
theorem cancel_left_div_gcd (hm : 0 < m) (h : c * a ≡ c * b [ZMOD m]) : a ≡ b [ZMOD m / gcd m c] 
Arguments: {m a b c : ℤ} (hm : 0 < m) (h : c * a ≡ c * b [ZMOD m])
Goal: a ≡ b [ZMOD m / ↑(m.gcd c)]
-- Int.ModEq.of_div
theorem of_div (h : a / c ≡ b / c [ZMOD m / c]) (ha : c ∣ a) (ha : c ∣ b) (ha : c ∣ m) :
    a ≡ b [ZMOD m] 
Arguments: {m a b c : ℤ} (h : a / c ≡ b / c [ZMOD m / c]) (ha : c ∣ a)
Goal: c ∣ b → c ∣ m → a ≡ b [ZMOD m]
-- Int.modEq_one
theorem modEq_one : a ≡ b [ZMOD 1] 
Arguments: {a b : ℤ}
Goal: a ≡ b [ZMOD 1]
-- Int.modEq_sub
theorem modEq_sub (a b : ℤ) : a ≡ b [ZMOD a - b] 
Arguments: (a b : ℤ)
Goal: a ≡ b [ZMOD a - b]
-- Int.modEq_zero_iff
@[simp]
theorem modEq_zero_iff : a ≡ b [ZMOD 0] ↔ a = b 
Arguments: {a b : ℤ}
Goal: a ≡ b [ZMOD 0] ↔ a = b
-- Int.add_modEq_left
@[simp]
theorem add_modEq_left : n + a ≡ a [ZMOD n] 
Arguments: {n a : ℤ}
Goal: n + a ≡ a [ZMOD n]
-- Int.add_modEq_right
@[simp]
theorem add_modEq_right : a + n ≡ a [ZMOD n] 
Arguments: {n a : ℤ}
Goal: a + n ≡ a [ZMOD n]
-- Int.modEq_and_modEq_iff_modEq_mul
theorem modEq_and_modEq_iff_modEq_mul {a b m n : ℤ} (hmn : m.natAbs.Coprime n.natAbs) :
    a ≡ b [ZMOD m] ∧ a ≡ b [ZMOD n] ↔ a ≡ b [ZMOD m * n] 
Arguments: {a b m n : ℤ} (hmn : m.natAbs.Coprime n.natAbs)
Goal: a ≡ b [ZMOD m] ∧ a ≡ b [ZMOD n] ↔ a ≡ b [ZMOD m * n]
-- Int.gcd_a_modEq
theorem gcd_a_modEq (a b : ℕ) : (a : ℤ) * Nat.gcdA a b ≡ Nat.gcd a b [ZMOD b] 
Arguments: (a b : ℕ)
Goal: ↑a * a.gcdA b ≡ ↑(a.gcd b) [ZMOD ↑b]
-- Int.modEq_add_fac
theorem modEq_add_fac {a b n : ℤ} (c : ℤ) (ha : a ≡ b [ZMOD n]) : a + n * c ≡ b [ZMOD n] 
Arguments: {a b n : ℤ} (c : ℤ) (ha : a ≡ b [ZMOD n])
Goal: a + n * c ≡ b [ZMOD n]
-- Int.modEq_sub_fac
theorem modEq_sub_fac {a b n : ℤ} (c : ℤ) (ha : a ≡ b [ZMOD n]) : a - n * c ≡ b [ZMOD n] 
Arguments: {a b n : ℤ} (c : ℤ) (ha : a ≡ b [ZMOD n])
Goal: a - n * c ≡ b [ZMOD n]
-- Int.modEq_add_fac_self
theorem modEq_add_fac_self {a t n : ℤ} : a + n * t ≡ a [ZMOD n] 
Arguments: {a t n : ℤ}
Goal: a + n * t ≡ a [ZMOD n]
-- Int.mod_coprime
theorem mod_coprime {a b : ℕ} (hab : Nat.Coprime a b) : ∃ y : ℤ, a * y ≡ 1 [ZMOD b] 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: ∃ y, ↑a * y ≡ 1 [ZMOD ↑b]
-- Int.exists_unique_equiv
theorem exists_unique_equiv (a : ℤ) {b : ℤ} (hb : 0 < b) :
    ∃ z : ℤ, 0 ≤ z ∧ z < b ∧ z ≡ a [ZMOD b] 
Arguments: (a : ℤ) {b : ℤ} (hb : 0 < b)
Goal: ∃ z, 0 ≤ z ∧ z < b ∧ z ≡ a [ZMOD b]
-- Int.exists_unique_equiv_nat
theorem exists_unique_equiv_nat (a : ℤ) {b : ℤ} (hb : 0 < b) : ∃ z : ℕ, ↑z < b ∧ ↑z ≡ a [ZMOD b] 
Arguments: (a : ℤ) {b : ℤ} (hb : 0 < b)
Goal: ∃ z, ↑z < b ∧ ↑z ≡ a [ZMOD b]
-- Int.mod_mul_right_mod
theorem mod_mul_right_mod (a b c : ℤ) : a % (b * c) % b = a % b 
Arguments: (a b c : ℤ)
Goal: a % (b * c) % b = a % b
-- Int.mod_mul_left_mod
theorem mod_mul_left_mod (a b c : ℤ) : a % (b * c) % c = a % c 
Arguments: (a b c : ℤ)
Goal: a % (b * c) % c = a % c
-- List.getD_eq_get
theorem getD_eq_get {n : ℕ} (hn : n < l.length) : l.getD n d = l.get ⟨n, hn⟩ 
Arguments: {α : Type u} (l : List α) (d : α) {n : ℕ} (hn : n < l.length)
Goal: l.getD n d = l.get ⟨n, hn⟩
-- List.getD_map
theorem getD_map {n : ℕ} (f : α → β) : (map f l).getD n (f d) = f (l.getD n d) 
Arguments: {α : Type u} {β : Type v} (l : List α) (d : α) {n : ℕ} (f : α → β)
Goal: (List.map f l).getD n (f d) = f (l.getD n d)
-- List.getD_eq_default
theorem getD_eq_default {n : ℕ} (hn : l.length ≤ n) : l.getD n d = d 
Arguments: {α : Type u} (l : List α) (d : α) {n : ℕ} (hn : l.length ≤ n)
Goal: l.getD n d = d
-- List.getElem?_getD_singleton_default_eq
@[simp]
theorem getElem?_getD_singleton_default_eq (n : ℕ) : [d][n]?.getD d = d 
Arguments: {α : Type u} (d : α) (n : ℕ)
Goal: [d][n]?.getD d = d
-- List.getElem?_getD_replicate_default_eq
@[simp]
theorem getElem?_getD_replicate_default_eq (r n : ℕ) : (replicate r d)[n]?.getD d = d 
Arguments: {α : Type u} (d : α) (r n : ℕ)
Goal: (List.replicate r d)[n]?.getD d = d
-- List.getD_append
theorem getD_append (l l' : List α) (d : α) (n : ℕ) (h : n < l.length) :
    (l ++ l').getD n d = l.getD n d 
Arguments: {α : Type u} (l l' : List α) (d : α) (n : ℕ) (h : n < l.length)
Goal: (l ++ l').getD n d = l.getD n d
-- List.getD_append_right
theorem getD_append_right (l l' : List α) (d : α) (n : ℕ) (h : l.length ≤ n) :
    (l ++ l').getD n d = l'.getD (n - l.length) d 
Arguments: {α : Type u} (l l' : List α) (d : α) (n : ℕ) (h : l.length ≤ n)
Goal: (l ++ l').getD n d = l'.getD (n - l.length) d
-- List.getD_eq_getD_get?
theorem getD_eq_getD_get? (n : ℕ) : l.getD n d = (l.get? n).getD d 
Arguments: {α : Type u} (l : List α) (d : α) (n : ℕ)
Goal: l.getD n d = (l.get? n).getD d
-- List.getI_nil
@[simp]
theorem getI_nil : getI ([] : List α) n = default 
Arguments: {α : Type u} (n : ℕ) [Inhabited α]
Goal: [].getI n = default
-- List.getI_cons_zero
@[simp]
theorem getI_cons_zero : getI (x :: xs) 0 = x 
Arguments: {α : Type u} (x : α) (xs : List α) [Inhabited α]
Goal: (x :: xs).getI 0 = x
-- List.getI_cons_succ
@[simp]
theorem getI_cons_succ : getI (x :: xs) (n + 1) = getI xs n 
Arguments: {α : Type u} (x : α) (xs : List α) (n : ℕ) [Inhabited α]
Goal: (x :: xs).getI (n + 1) = xs.getI n
-- List.getI_eq_get
theorem getI_eq_get {n : ℕ} (hn : n < l.length) : l.getI n = l.get ⟨n, hn⟩ 
Arguments: {α : Type u} (l : List α) [Inhabited α] {n : ℕ} (hn : n < l.length)
Goal: l.getI n = l.get ⟨n, hn⟩
-- List.getI_eq_default
theorem getI_eq_default {n : ℕ} (hn : l.length ≤ n) : l.getI n = default 
Arguments: {α : Type u} (l : List α) [Inhabited α] {n : ℕ} (hn : l.length ≤ n)
Goal: l.getI n = default
-- List.getD_default_eq_getI
theorem getD_default_eq_getI {n : ℕ} : l.getD n default = l.getI n 
Arguments: {α : Type u} (l : List α) [Inhabited α] {n : ℕ}
Goal: l.getD n default = l.getI n
-- List.getI_append
theorem getI_append (l l' : List α) (n : ℕ) (h : n < l.length) :
    (l ++ l').getI n = l.getI n 
Arguments: {α : Type u} [Inhabited α] (l l' : List α) (n : ℕ) (h : n < l.length)
Goal: (l ++ l').getI n = l.getI n
-- List.getI_append_right
theorem getI_append_right (l l' : List α) (n : ℕ) (h : l.length ≤ n) :
    (l ++ l').getI n = l'.getI (n - l.length) 
Arguments: {α : Type u} [Inhabited α] (l l' : List α) (n : ℕ) (h : l.length ≤ n)
Goal: (l ++ l').getI n = l'.getI (n - l.length)
-- List.getI_eq_iget_get?
theorem getI_eq_iget_get? (n : ℕ) : l.getI n = (l.get? n).iget 
Arguments: {α : Type u} (l : List α) [Inhabited α] (n : ℕ)
Goal: l.getI n = (l.get? n).iget
-- List.getI_zero_eq_headI
theorem getI_zero_eq_headI : l.getI 0 = l.headI 
Arguments: {α : Type u} (l : List α) [Inhabited α]
Goal: l.getI 0 = l.headI
-- AList.nodupKeys
structure AList (β : α → Type v) : Type max u v where
    entries : List (Sigma β)
    nodupKeys : entries.NodupKeys
Arguments: {α : Type u} {β : α → Type v} (self : AList β)
Goal: self.entries.NodupKeys
-- AList.ext
@[ext]
theorem ext : ∀ {s t : AList β}, s.entries = t.entries → s = t
  
Arguments: {α : Type u} {β : α → Type v} {s t : AList β}
Goal: s.entries = t.entries → s = t
-- AList.ext_iff
protected theorem ext_iff {s t : AList β} : s = t ↔ s.entries = t.entries 
Arguments: {α : Type u} {β : α → Type v} {s t : AList β}
Goal: s = t ↔ s.entries = t.entries
-- AList.keys_nodup
theorem keys_nodup (s : AList β) : s.keys.Nodup 
Arguments: {α : Type u} {β : α → Type v} (s : AList β)
Goal: s.keys.Nodup
-- AList.mem_keys
theorem mem_keys {a : α} {s : AList β} : a ∈ s ↔ a ∈ s.keys 
Arguments: {α : Type u} {β : α → Type v} {a : α} {s : AList β}
Goal: a ∈ s ↔ a ∈ s.keys
-- AList.mem_of_perm
theorem mem_of_perm {a : α} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries) : a ∈ s₁ ↔ a ∈ s₂ 
Arguments: {α : Type u} {β : α → Type v} {a : α} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries)
Goal: a ∈ s₁ ↔ a ∈ s₂
-- AList.not_mem_empty
@[simp]
theorem not_mem_empty (a : α) : a ∉ (∅ : AList β) 
Arguments: {α : Type u} {β : α → Type v} (a : α)
Goal: a ∉ ∅
-- AList.empty_entries
@[simp]
theorem empty_entries : (∅ : AList β).entries = [] 
Arguments: {α : Type u} {β : α → Type v}
Goal: ∅.entries = []
-- AList.keys_empty
@[simp]
theorem keys_empty : (∅ : AList β).keys = [] 
Arguments: {α : Type u} {β : α → Type v}
Goal: ∅.keys = []
-- AList.singleton_entries
@[simp]
theorem singleton_entries (a : α) (b : β a) : (singleton a b).entries = [Sigma.mk a b] 
Arguments: {α : Type u} {β : α → Type v} (a : α) (b : β a)
Goal: (AList.singleton a b).entries = [⟨a, b⟩]
-- AList.keys_singleton
@[simp]
theorem keys_singleton (a : α) (b : β a) : (singleton a b).keys = [a] 
Arguments: {α : Type u} {β : α → Type v} (a : α) (b : β a)
Goal: (AList.singleton a b).keys = [a]
-- AList.lookup_empty
@[simp]
theorem lookup_empty (a) : lookup a (∅ : AList β) = none 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α)
Goal: AList.lookup a ∅ = none
-- AList.lookup_isSome
theorem lookup_isSome {a : α} {s : AList β} : (s.lookup a).isSome ↔ a ∈ s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s : AList β}
Goal: (AList.lookup a s).isSome = true ↔ a ∈ s
-- AList.lookup_eq_none
theorem lookup_eq_none {a : α} {s : AList β} : lookup a s = none ↔ a ∉ s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s : AList β}
Goal: AList.lookup a s = none ↔ a ∉ s
-- AList.mem_lookup_iff
theorem mem_lookup_iff {a : α} {b : β a} {s : AList β} :
    b ∈ lookup a s ↔ Sigma.mk a b ∈ s.entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s : AList β}
Goal: b ∈ AList.lookup a s ↔ ⟨a, b⟩ ∈ s.entries
-- AList.perm_lookup
theorem perm_lookup {a : α} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries) :
    s₁.lookup a = s₂.lookup a 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries)
Goal: AList.lookup a s₁ = AList.lookup a s₂
-- AList.keys_subset_keys_of_entries_subset_entries
theorem keys_subset_keys_of_entries_subset_entries
    {s₁ s₂ : AList β} (h : s₁.entries ⊆ s₂.entries) : s₁.keys ⊆ s₂.keys 
Arguments: {α : Type u} {β : α → Type v} {s₁ s₂ : AList β} (h : s₁.entries ⊆ s₂.entries)
Goal: s₁.keys ⊆ s₂.keys
-- AList.keys_replace
@[simp]
theorem keys_replace (a : α) (b : β a) (s : AList β) : (replace a b s).keys = s.keys 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a) (s : AList β)
Goal: (AList.replace a b s).keys = s.keys
-- AList.mem_replace
@[simp]
theorem mem_replace {a a' : α} {b : β a} {s : AList β} : a' ∈ replace a b s ↔ a' ∈ s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {b : β a} {s : AList β}
Goal: a' ∈ AList.replace a b s ↔ a' ∈ s
-- AList.perm_replace
theorem perm_replace {a : α} {b : β a} {s₁ s₂ : AList β} :
    s₁.entries ~ s₂.entries → (replace a b s₁).entries ~ (replace a b s₂).entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s₁ s₂ : AList β}
Goal: s₁.entries ~ s₂.entries → (AList.replace a b s₁).entries ~ (AList.replace a b s₂).entries
-- AList.keys_erase
@[simp]
theorem keys_erase (a : α) (s : AList β) : (erase a s).keys = s.keys.erase a 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (s : AList β)
Goal: (AList.erase a s).keys = s.keys.erase a
-- AList.mem_erase
@[simp]
theorem mem_erase {a a' : α} {s : AList β} : a' ∈ erase a s ↔ a' ≠ a ∧ a' ∈ s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {s : AList β}
Goal: a' ∈ AList.erase a s ↔ a' ≠ a ∧ a' ∈ s
-- AList.perm_erase
theorem perm_erase {a : α} {s₁ s₂ : AList β} :
    s₁.entries ~ s₂.entries → (erase a s₁).entries ~ (erase a s₂).entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s₁ s₂ : AList β}
Goal: s₁.entries ~ s₂.entries → (AList.erase a s₁).entries ~ (AList.erase a s₂).entries
-- AList.lookup_erase
@[simp]
theorem lookup_erase (a) (s : AList β) : lookup a (erase a s) = none 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (s : AList β)
Goal: AList.lookup a (AList.erase a s) = none
-- AList.lookup_erase_ne
@[simp]
theorem lookup_erase_ne {a a'} {s : AList β} (h : a ≠ a') : lookup a (erase a' s) = lookup a s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {s : AList β} (h : a ≠ a')
Goal: AList.lookup a (AList.erase a' s) = AList.lookup a s
-- AList.erase_erase
theorem erase_erase (a a' : α) (s : AList β) : (s.erase a).erase a' = (s.erase a').erase a 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a a' : α) (s : AList β)
Goal: AList.erase a' (AList.erase a s) = AList.erase a (AList.erase a' s)
-- AList.insert_entries
@[simp]
theorem insert_entries {a} {b : β a} {s : AList β} :
    (insert a b s).entries = Sigma.mk a b :: kerase a s.entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s : AList β}
Goal: (AList.insert a b s).entries = ⟨a, b⟩ :: List.kerase a s.entries
-- AList.insert_entries_of_neg
theorem insert_entries_of_neg {a} {b : β a} {s : AList β} (h : a ∉ s) :
    (insert a b s).entries = ⟨a, b⟩ :: s.entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s : AList β} (h : a ∉ s)
Goal: (AList.insert a b s).entries = ⟨a, b⟩ :: s.entries
-- AList.insert_of_neg
theorem insert_of_neg {a} {b : β a} {s : AList β} (h : a ∉ s) :
    insert a b s = ⟨⟨a, b⟩ :: s.entries, nodupKeys_cons.2 ⟨h, s.2⟩⟩ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s : AList β} (h : a ∉ s)
Goal: AList.insert a b s = { entries := ⟨a, b⟩ :: s.entries, nodupKeys := ⋯ }
-- AList.insert_empty
@[simp]
theorem insert_empty (a) (b : β a) : insert a b ∅ = singleton a b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a)
Goal: AList.insert a b ∅ = AList.singleton a b
-- AList.mem_insert
@[simp]
theorem mem_insert {a a'} {b' : β a'} (s : AList β) : a ∈ insert a' b' s ↔ a = a' ∨ a ∈ s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {b' : β a'} (s : AList β)
Goal: a ∈ AList.insert a' b' s ↔ a = a' ∨ a ∈ s
-- AList.keys_insert
@[simp]
theorem keys_insert {a} {b : β a} (s : AList β) : (insert a b s).keys = a :: s.keys.erase a 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} (s : AList β)
Goal: (AList.insert a b s).keys = a :: s.keys.erase a
-- AList.perm_insert
theorem perm_insert {a} {b : β a} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries) :
    (insert a b s₁).entries ~ (insert a b s₂).entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries)
Goal: (AList.insert a b s₁).entries ~ (AList.insert a b s₂).entries
-- AList.lookup_insert
@[simp]
theorem lookup_insert {a} {b : β a} (s : AList β) : lookup a (insert a b s) = some b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} (s : AList β)
Goal: AList.lookup a (AList.insert a b s) = some b
-- AList.lookup_insert_ne
@[simp]
theorem lookup_insert_ne {a a'} {b' : β a'} {s : AList β} (h : a ≠ a') :
    lookup a (insert a' b' s) = lookup a s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {b' : β a'} {s : AList β} (h : a ≠ a')
Goal: AList.lookup a (AList.insert a' b' s) = AList.lookup a s
-- AList.lookup_insert_eq_none
@[simp] theorem lookup_insert_eq_none {l : AList β} {k k' : α} {v : β k} :
    (l.insert k v).lookup k' = none ↔ (k' ≠ k) ∧ l.lookup k' = none 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {l : AList β} {k k' : α} {v : β k}
Goal: AList.lookup k' (AList.insert k v l) = none ↔ k' ≠ k ∧ AList.lookup k' l = none
-- AList.lookup_to_alist
@[simp]
theorem lookup_to_alist {a} (s : List (Sigma β)) : lookup a s.toAList = s.dlookup a 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} (s : List (Sigma β))
Goal: AList.lookup a s.toAList = List.dlookup a s
-- AList.insert_insert
@[simp]
theorem insert_insert {a} {b b' : β a} (s : AList β) :
    (s.insert a b).insert a b' = s.insert a b' 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b b' : β a} (s : AList β)
Goal: AList.insert a b' (AList.insert a b s) = AList.insert a b' s
-- AList.insert_insert_of_ne
theorem insert_insert_of_ne {a a'} {b : β a} {b' : β a'} (s : AList β) (h : a ≠ a') :
    ((s.insert a b).insert a' b').entries ~ ((s.insert a' b').insert a b).entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a a' : α} {b : β a} {b' : β a'} (s : AList β) (h : a ≠ a')
Goal: (AList.insert a' b' (AList.insert a b s)).entries ~ (AList.insert a b (AList.insert a' b' s)).entries
-- AList.insert_singleton_eq
@[simp]
theorem insert_singleton_eq {a : α} {b b' : β a} : insert a b (singleton a b') = singleton a b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b b' : β a}
Goal: AList.insert a b (AList.singleton a b') = AList.singleton a b
-- AList.entries_toAList
@[simp]
theorem entries_toAList (xs : List (Sigma β)) : (List.toAList xs).entries = dedupKeys xs 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (xs : List (Sigma β))
Goal: xs.toAList.entries = xs.dedupKeys
-- AList.toAList_cons
theorem toAList_cons (a : α) (b : β a) (xs : List (Sigma β)) :
    List.toAList (⟨a, b⟩ :: xs) = insert a b xs.toAList 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (b : β a) (xs : List (Sigma β))
Goal: (⟨a, b⟩ :: xs).toAList = AList.insert a b xs.toAList
-- AList.mk_cons_eq_insert
theorem mk_cons_eq_insert (c : Sigma β) (l : List (Sigma β)) (h : (c :: l).NodupKeys) :
    (⟨c :: l, h⟩ : AList β) = insert c.1 c.2 ⟨l, nodupKeys_of_nodupKeys_cons h⟩ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (c : Sigma β) (l : List (Sigma β)) (h : (c :: l).NodupKeys)
Goal: { entries := c :: l, nodupKeys := h } = AList.insert c.fst c.snd { entries := l, nodupKeys := ⋯ }
-- AList.insertRec_empty
@[simp]
theorem insertRec_empty {C : AList β → Sort*} (H0 : C ∅)
    (IH : ∀ (a : α) (b : β a) (l : AList β), a ∉ l → C l → C (l.insert a b)) :
    @insertRec α β _ C H0 IH ∅ = H0 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {C : AList β → Sort u_1} (H0 : C ∅) (IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (AList.insert a b l))
Goal: AList.insertRec H0 IH ∅ = H0
-- AList.insertRec_insert
theorem insertRec_insert {C : AList β → Sort*} (H0 : C ∅)
    (IH : ∀ (a : α) (b : β a) (l : AList β), a ∉ l → C l → C (l.insert a b)) {c : Sigma β}
    {l : AList β} (h : c.1 ∉ l) :
    @insertRec α β _ C H0 IH (l.insert c.1 c.2) = IH c.1 c.2 l h (@insertRec α β _ C H0 IH l) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {C : AList β → Sort u_1} (H0 : C ∅) (IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (AList.insert a b l)) {c : Sigma β} {l : AList β} (h : c.fst ∉ l)
Goal: AList.insertRec H0 IH (AList.insert c.fst c.snd l) = IH c.fst c.snd l h (AList.insertRec H0 IH l)
-- AList.insertRec_insert_mk
theorem insertRec_insert_mk {C : AList β → Sort*} (H0 : C ∅)
    (IH : ∀ (a : α) (b : β a) (l : AList β), a ∉ l → C l → C (l.insert a b)) {a : α} (b : β a)
    {l : AList β} (h : a ∉ l) :
    @insertRec α β _ C H0 IH (l.insert a b) = IH a b l h (@insertRec α β _ C H0 IH l) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {C : AList β → Sort u_1} (H0 : C ∅) (IH : (a : α) → (b : β a) → (l : AList β) → a ∉ l → C l → C (AList.insert a b l)) {a : α} (b : β a) {l : AList β} (h : a ∉ l)
Goal: AList.insertRec H0 IH (AList.insert a b l) = IH a b l h (AList.insertRec H0 IH l)
-- AList.extract_eq_lookup_erase
@[simp]
theorem extract_eq_lookup_erase (a : α) (s : AList β) : extract a s = (lookup a s, erase a s) 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (s : AList β)
Goal: AList.extract a s = (AList.lookup a s, AList.erase a s)
-- AList.union_entries
@[simp]
theorem union_entries {s₁ s₂ : AList β} : (s₁ ∪ s₂).entries = kunion s₁.entries s₂.entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {s₁ s₂ : AList β}
Goal: (s₁ ∪ s₂).entries = s₁.entries.kunion s₂.entries
-- AList.empty_union
@[simp]
theorem empty_union {s : AList β} : (∅ : AList β) ∪ s = s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {s : AList β}
Goal: ∅ ∪ s = s
-- AList.union_empty
@[simp]
theorem union_empty {s : AList β} : s ∪ (∅ : AList β) = s 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {s : AList β}
Goal: s ∪ ∅ = s
-- AList.mem_union
@[simp]
theorem mem_union {a} {s₁ s₂ : AList β} : a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ ∨ a ∈ s₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s₁ s₂ : AList β}
Goal: a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ ∨ a ∈ s₂
-- AList.perm_union
theorem perm_union {s₁ s₂ s₃ s₄ : AList β} (p₁₂ : s₁.entries ~ s₂.entries)
    (p₃₄ : s₃.entries ~ s₄.entries) : (s₁ ∪ s₃).entries ~ (s₂ ∪ s₄).entries 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {s₁ s₂ s₃ s₄ : AList β} (p₁₂ : s₁.entries ~ s₂.entries) (p₃₄ : s₃.entries ~ s₄.entries)
Goal: (s₁ ∪ s₃).entries ~ (s₂ ∪ s₄).entries
-- AList.union_erase
theorem union_erase (a : α) (s₁ s₂ : AList β) : erase a (s₁ ∪ s₂) = erase a s₁ ∪ erase a s₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] (a : α) (s₁ s₂ : AList β)
Goal: AList.erase a (s₁ ∪ s₂) = AList.erase a s₁ ∪ AList.erase a s₂
-- AList.lookup_union_left
@[simp]
theorem lookup_union_left {a} {s₁ s₂ : AList β} : a ∈ s₁ → lookup a (s₁ ∪ s₂) = lookup a s₁ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s₁ s₂ : AList β}
Goal: a ∈ s₁ → AList.lookup a (s₁ ∪ s₂) = AList.lookup a s₁
-- AList.lookup_union_right
@[simp]
theorem lookup_union_right {a} {s₁ s₂ : AList β} : a ∉ s₁ → lookup a (s₁ ∪ s₂) = lookup a s₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {s₁ s₂ : AList β}
Goal: a ∉ s₁ → AList.lookup a (s₁ ∪ s₂) = AList.lookup a s₂
-- AList.mem_lookup_union
theorem mem_lookup_union {a} {b : β a} {s₁ s₂ : AList β} :
    b ∈ lookup a (s₁ ∪ s₂) ↔ b ∈ lookup a s₁ ∨ a ∉ s₁ ∧ b ∈ lookup a s₂ 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s₁ s₂ : AList β}
Goal: b ∈ AList.lookup a (s₁ ∪ s₂) ↔ b ∈ AList.lookup a s₁ ∨ a ∉ s₁ ∧ b ∈ AList.lookup a s₂
-- AList.lookup_union_eq_some
@[simp]
theorem lookup_union_eq_some {a} {b : β a} {s₁ s₂ : AList β} :
    lookup a (s₁ ∪ s₂) = some b ↔ lookup a s₁ = some b ∨ a ∉ s₁ ∧ lookup a s₂ = some b 
Arguments: {α : Type u} {β : α → Type v} [DecidableEq α] {a : α} {b : β a} {s₁ s₂ : AList β}
Goal: AList.lookup a (s₁ ∪ s₂) = some b ↔ AList.lookup a s₁ = some b ∨ a ∉ s₁ ∧ AList.lookup a s₂ = some b