ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Rat.divInt_add_divInt
theorem divInt_add_divInt (n₁ n₂ : Int) {d₁ d₂} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    n₁ /. d₁ + n₂ /. d₂ = (n₁ * d₂ + n₂ * d₁) /. (d₁ * d₂) 
Arguments: (n₁ n₂ : Int) {d₁ d₂ : Int} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0)
Goal: n₁ /. d₁ + n₂ /. d₂ = (n₁ * d₂ + n₂ * d₁) /. (d₁ * d₂)
-- Rat.neg_num
@[simp] theorem neg_num (a : Rat) : (-a).num = -a.num 
Arguments: (a : Rat)
Goal: (-a).num = -a.num
-- Rat.neg_den
@[simp] theorem neg_den (a : Rat) : (-a).den = a.den 
Arguments: (a : Rat)
Goal: (-a).den = a.den
-- Rat.neg_normalize
theorem neg_normalize (n d z) : -normalize n d z = normalize (-n) d z 
Arguments: (n : Int) (d : Nat) (z : d ≠ 0)
Goal: -Rat.normalize n d z = Rat.normalize (-n) d z
-- Rat.neg_mkRat
theorem neg_mkRat (n d) : -mkRat n d = mkRat (-n) d 
Arguments: (n : Int) (d : Nat)
Goal: -mkRat n d = mkRat (-n) d
-- Rat.neg_divInt
theorem neg_divInt (n d) : -(n /. d) = -n /. d 
Arguments: (n d : Int)
Goal: -(n /. d) = -n /. d
-- Rat.sub_def
theorem sub_def (a b : Rat) :
    a - b = normalize (a.num * b.den - b.num * a.den) (a.den * b.den)
      (Nat.mul_ne_zero a.den_nz b.den_nz) 
Arguments: (a b : Rat)
Goal: a - b = Rat.normalize (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den) ⋯
-- Rat.sub_def'
theorem sub_def' (a b : Rat) : a - b = mkRat (a.num * b.den - b.num * a.den) (a.den * b.den) 
Arguments: (a b : Rat)
Goal: a - b = mkRat (a.num * ↑b.den - b.num * ↑a.den) (a.den * b.den)
-- Rat.sub_eq_add_neg
protected theorem sub_eq_add_neg (a b : Rat) : a - b = a + -b 
Arguments: (a b : Rat)
Goal: a - b = a + -b
-- Rat.divInt_sub_divInt
theorem divInt_sub_divInt (n₁ n₂ : Int) {d₁ d₂} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    n₁ /. d₁ - n₂ /. d₂ = (n₁ * d₂ - n₂ * d₁) /. (d₁ * d₂) 
Arguments: (n₁ n₂ : Int) {d₁ d₂ : Int} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0)
Goal: n₁ /. d₁ - n₂ /. d₂ = (n₁ * d₂ - n₂ * d₁) /. (d₁ * d₂)
-- Rat.mul_def
theorem mul_def (a b : Rat) :
    a * b = normalize (a.num * b.num) (a.den * b.den) (Nat.mul_ne_zero a.den_nz b.den_nz) 
Arguments: (a b : Rat)
Goal: a * b = Rat.normalize (a.num * b.num) (a.den * b.den) ⋯
-- Rat.mul_comm
protected theorem mul_comm (a b : Rat) : a * b = b * a 
Arguments: (a b : Rat)
Goal: a * b = b * a
-- Rat.zero_mul
@[simp] protected theorem zero_mul (a : Rat) : 0 * a = 0 
Arguments: (a : Rat)
Goal: 0 * a = 0
-- Rat.mul_zero
@[simp] protected theorem mul_zero (a : Rat) : a * 0 = 0 
Arguments: (a : Rat)
Goal: a * 0 = 0
-- Rat.one_mul
@[simp] protected theorem one_mul (a : Rat) : 1 * a = a 
Arguments: (a : Rat)
Goal: 1 * a = a
-- Rat.mul_one
@[simp] protected theorem mul_one (a : Rat) : a * 1 = a 
Arguments: (a : Rat)
Goal: a * 1 = a
-- Rat.normalize_mul_normalize
theorem normalize_mul_normalize (n₁ n₂) {d₁ d₂} (z₁ z₂) :
    normalize n₁ d₁ z₁ * normalize n₂ d₂ z₂ =
    normalize (n₁ * n₂) (d₁ * d₂) (Nat.mul_ne_zero z₁ z₂) 
Arguments: (n₁ n₂ : Int) {d₁ d₂ : Nat} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0)
Goal: Rat.normalize n₁ d₁ z₁ * Rat.normalize n₂ d₂ z₂ = Rat.normalize (n₁ * n₂) (d₁ * d₂) ⋯
-- Rat.mkRat_mul_mkRat
theorem mkRat_mul_mkRat (n₁ n₂ : Int) (d₁ d₂) :
    mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂) 
Arguments: (n₁ n₂ : Int) (d₁ d₂ : Nat)
Goal: mkRat n₁ d₁ * mkRat n₂ d₂ = mkRat (n₁ * n₂) (d₁ * d₂)
-- Rat.divInt_mul_divInt
theorem divInt_mul_divInt (n₁ n₂ : Int) {d₁ d₂} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    (n₁ /. d₁) * (n₂ /. d₂) = (n₁ * n₂) /. (d₁ * d₂) 
Arguments: (n₁ n₂ : Int) {d₁ d₂ : Int} (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0)
Goal: n₁ /. d₁ * (n₂ /. d₂) = n₁ * n₂ /. (d₁ * d₂)
-- Rat.inv_def
theorem inv_def (a : Rat) : a.inv = a.den /. a.num 
Arguments: (a : Rat)
Goal: a.inv = ↑a.den /. a.num
-- Rat.inv_zero
@[simp] protected theorem inv_zero : (0 : Rat).inv = 0 
Goal: Rat.inv 0 = 0
-- Rat.inv_divInt
@[simp] theorem inv_divInt (n d : Int) : (n /. d).inv = d /. n 
Arguments: (n d : Int)
Goal: (n /. d).inv = d /. n
-- Rat.div_def
theorem div_def (a b : Rat) : a / b = a * b.inv 
Arguments: (a b : Rat)
Goal: a / b = a * b.inv
-- Rat.ofScientific_true_def
theorem ofScientific_true_def : Rat.ofScientific m true e = mkRat m (10 ^ e) 
Arguments: {m e : Nat}
Goal: Rat.ofScientific m true e = mkRat (↑m) (10 ^ e)
-- Rat.ofScientific_false_def
theorem ofScientific_false_def : Rat.ofScientific m false e = (m * 10 ^ e : Nat) 
Arguments: {m e : Nat}
Goal: Rat.ofScientific m false e = ↑(m * 10 ^ e)
-- Rat.ofScientific_def
theorem ofScientific_def : Rat.ofScientific m s e =
    if s then mkRat m (10 ^ e) else (m * 10 ^ e : Nat) 
Arguments: {m : Nat} {s : Bool} {e : Nat}
Goal: Rat.ofScientific m s e = if s = true then mkRat (↑m) (10 ^ e) else ↑(m * 10 ^ e)
-- Rat.intCast_den
@[simp] theorem intCast_den (a : Int) : (a : Rat).den = 1 
Arguments: (a : Int)
Goal: (↑a).den = 1
-- Rat.intCast_num
@[simp] theorem intCast_num (a : Int) : (a : Rat).num = a 
Arguments: (a : Int)
Goal: (↑a).num = a
-- Rat.intCast_inj
@[simp, norm_cast] theorem intCast_inj {a b : Int} : (a : Rat) = (b : Rat) ↔ a = b 
Arguments: {a b : Int}
Goal: ↑a = ↑b ↔ a = b
-- Rat.intCast_zero
theorem intCast_zero : ((0 : Int) : Rat) = (0 : Rat) 
Goal: ↑0 = 0
-- Rat.intCast_one
theorem intCast_one : ((1 : Int) : Rat) = (1 : Rat) 
Goal: ↑1 = 1
-- Rat.intCast_add
@[simp, norm_cast] theorem intCast_add (a b : Int) :
    ((a + b : Int) : Rat) = (a : Rat) + (b : Rat) 
Arguments: (a b : Int)
Goal: ↑(a + b) = ↑a + ↑b
-- Rat.intCast_neg
@[simp, norm_cast] theorem intCast_neg (a : Int) : ((-a : Int) : Rat) = -(a : Rat) 
Arguments: (a : Int)
Goal: ↑(-a) = -↑a
-- Rat.intCast_sub
@[simp, norm_cast] theorem intCast_sub (a b : Int) :
    ((a - b : Int) : Rat) = (a : Rat) - (b : Rat) 
Arguments: (a b : Int)
Goal: ↑(a - b) = ↑a - ↑b
-- Rat.intCast_mul
@[simp, norm_cast] theorem intCast_mul (a b : Int) :
    ((a * b : Int) : Rat) = (a : Rat) * (b : Rat) 
Arguments: (a b : Int)
Goal: ↑(a * b) = ↑a * ↑b
-- List.Perm.refl
@[simp, refl] protected theorem Perm.refl : ∀ l : List α, l ~ l
  
Arguments: {α : Type u_1} (l : List α)
Goal: l ~ l
-- List.Perm.rfl
protected theorem Perm.rfl {l : List α} : l ~ l 
Arguments: {α : Type u_1} {l : List α}
Goal: l ~ l
-- List.Perm.of_eq
theorem Perm.of_eq (h : l₁ = l₂) : l₁ ~ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ = l₂ → l₁ ~ l₂
-- List.Perm.symm
protected theorem Perm.symm {l₁ l₂ : List α} (h : l₁ ~ l₂) : l₂ ~ l₁ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (h : l₁ ~ l₂)
Goal: l₂ ~ l₁
-- List.perm_comm
theorem perm_comm {l₁ l₂ : List α} : l₁ ~ l₂ ↔ l₂ ~ l₁ 
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ ~ l₂ ↔ l₂ ~ l₁
-- List.Perm.swap'
theorem Perm.swap' (x y : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) : y :: x :: l₁ ~ x :: y :: l₂ 
Arguments: {α : Type u_1} (x y : α) {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: y :: x :: l₁ ~ x :: y :: l₂
-- List.Perm.recOnSwap'
@[elab_as_elim] theorem Perm.recOnSwap'
    {motive : (l₁ : List α) → (l₂ : List α) → l₁ ~ l₂ → Prop} {l₁ l₂ : List α} (p : l₁ ~ l₂)
    (nil : motive [] [] .nil)
    (cons : ∀ x {l₁ l₂}, (h : l₁ ~ l₂) → motive l₁ l₂ h → motive (x :: l₁) (x :: l₂) (.cons x h))
    (swap' : ∀ x y {l₁ l₂}, (h : l₁ ~ l₂) → motive l₁ l₂ h →
      motive (y :: x :: l₁) (x :: y :: l₂) (.swap' _ _ h))
    (trans : ∀ {l₁ l₂ l₃}, (h₁ : l₁ ~ l₂) → (h₂ : l₂ ~ l₃) → motive l₁ l₂ h₁ → motive l₂ l₃ h₂ →
      motive l₁ l₃ (.trans h₁ h₂)) : motive l₁ l₂ p 
Arguments: {α : Type u_1} {motive : (l₁ l₂ : List α) → l₁ ~ l₂ → Prop} {l₁ l₂ : List α} (p : l₁ ~ l₂) (nil : motive [] [] ⋯) (cons : ∀ (x : α) {l₁ l₂ : List α} (h : l₁ ~ l₂), motive l₁ l₂ h → motive (x :: l₁) (x :: l₂) ⋯) (swap' : ∀ (x y : α) {l₁ l₂ : List α} (h : l₁ ~ l₂), motive l₁ l₂ h → motive (y :: x :: l₁) (x :: y :: l₂) ⋯) (trans : ∀ {l₁ l₂ l₃ : List α} (h₁ : l₁ ~ l₂) (h₂ : l₂ ~ l₃), motive l₁ l₂ h₁ → motive l₂ l₃ h₂ → motive l₁ l₃ ⋯)
Goal: motive l₁ l₂ p
-- List.Perm.eqv
theorem Perm.eqv (α) : Equivalence (@Perm α) 
Arguments: (α : Type u_1)
Goal: Equivalence List.Perm
-- List.Perm.mem_iff
theorem Perm.mem_iff {a : α} {l₁ l₂ : List α} (p : l₁ ~ l₂) : a ∈ l₁ ↔ a ∈ l₂ 
Arguments: {α : Type u_1} {a : α} {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: a ∈ l₁ ↔ a ∈ l₂
-- List.Perm.subset
theorem Perm.subset {l₁ l₂ : List α} (p : l₁ ~ l₂) : l₁ ⊆ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: l₁ ⊆ l₂
-- List.Perm.append_right
theorem Perm.append_right {l₁ l₂ : List α} (t₁ : List α) (p : l₁ ~ l₂) : l₁ ++ t₁ ~ l₂ ++ t₁ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (t₁ : List α) (p : l₁ ~ l₂)
Goal: l₁ ++ t₁ ~ l₂ ++ t₁
-- List.Perm.append_left
theorem Perm.append_left {t₁ t₂ : List α} : ∀ l : List α, t₁ ~ t₂ → l ++ t₁ ~ l ++ t₂
  
Arguments: {α : Type u_1} {t₁ t₂ : List α} (l : List α)
Goal: t₁ ~ t₂ → l ++ t₁ ~ l ++ t₂
-- List.Perm.append
theorem Perm.append {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂) : l₁ ++ t₁ ~ l₂ ++ t₂ 
Arguments: {α : Type u_1} {l₁ l₂ t₁ t₂ : List α} (p₁ : l₁ ~ l₂) (p₂ : t₁ ~ t₂)
Goal: l₁ ++ t₁ ~ l₂ ++ t₂
-- List.Perm.append_cons
theorem Perm.append_cons (a : α) {h₁ h₂ t₁ t₂ : List α} (p₁ : h₁ ~ h₂) (p₂ : t₁ ~ t₂) :
    h₁ ++ a :: t₁ ~ h₂ ++ a :: t₂ 
Arguments: {α : Type u_1} (a : α) {h₁ h₂ t₁ t₂ : List α} (p₁ : h₁ ~ h₂) (p₂ : t₁ ~ t₂)
Goal: h₁ ++ a :: t₁ ~ h₂ ++ a :: t₂
-- List.perm_middle
@[simp] theorem perm_middle {a : α} : ∀ {l₁ l₂ : List α}, l₁ ++ a :: l₂ ~ a :: (l₁ ++ l₂)
  
Arguments: {α : Type u_1} {a : α} {l₁ l₂ : List α}
Goal: l₁ ++ a :: l₂ ~ a :: (l₁ ++ l₂)
-- List.perm_append_singleton
@[simp] theorem perm_append_singleton (a : α) (l : List α) : l ++ [a] ~ a :: l 
Arguments: {α : Type u_1} (a : α) (l : List α)
Goal: l ++ [a] ~ a :: l
-- List.perm_append_comm
theorem perm_append_comm : ∀ {l₁ l₂ : List α}, l₁ ++ l₂ ~ l₂ ++ l₁
  
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ ++ l₂ ~ l₂ ++ l₁
-- List.concat_perm
theorem concat_perm (l : List α) (a : α) : concat l a ~ a :: l 
Arguments: {α : Type u_1} (l : List α) (a : α)
Goal: l.concat a ~ a :: l
-- List.Perm.length_eq
theorem Perm.length_eq {l₁ l₂ : List α} (p : l₁ ~ l₂) : length l₁ = length l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: l₁.length = l₂.length
-- List.Perm.eq_nil
theorem Perm.eq_nil {l : List α} (p : l ~ []) : l = [] 
Arguments: {α : Type u_1} {l : List α} (p : l ~ [])
Goal: l = []
-- List.Perm.nil_eq
theorem Perm.nil_eq {l : List α} (p : [] ~ l) : [] = l 
Arguments: {α : Type u_1} {l : List α} (p : [] ~ l)
Goal: [] = l
-- List.perm_nil
@[simp] theorem perm_nil {l₁ : List α} : l₁ ~ [] ↔ l₁ = [] 
Arguments: {α : Type u_1} {l₁ : List α}
Goal: l₁ ~ [] ↔ l₁ = []
-- List.nil_perm
@[simp] theorem nil_perm {l₁ : List α} : [] ~ l₁ ↔ l₁ = [] 
Arguments: {α : Type u_1} {l₁ : List α}
Goal: [] ~ l₁ ↔ l₁ = []
-- List.not_perm_nil_cons
theorem not_perm_nil_cons (x : α) (l : List α) : ¬[] ~ x :: l 
Arguments: {α : Type u_1} (x : α) (l : List α)
Goal: ¬[] ~ x :: l
-- List.reverse_perm
@[simp] theorem reverse_perm : ∀ l : List α, reverse l ~ l
  
Arguments: {α : Type u_1} (l : List α)
Goal: l.reverse ~ l
-- List.perm_cons_append_cons
theorem perm_cons_append_cons {l l₁ l₂ : List α} (a : α) (p : l ~ l₁ ++ l₂) :
    a :: l ~ l₁ ++ a :: l₂ 
Arguments: {α : Type u_1} {l l₁ l₂ : List α} (a : α) (p : l ~ l₁ ++ l₂)
Goal: a :: l ~ l₁ ++ a :: l₂
-- List.perm_replicate
@[simp] theorem perm_replicate {n : Nat} {a : α} {l : List α} :
    l ~ replicate n a ↔ l = replicate n a 
Arguments: {α : Type u_1} {n : Nat} {a : α} {l : List α}
Goal: l ~ List.replicate n a ↔ l = List.replicate n a
-- List.replicate_perm
@[simp] theorem replicate_perm {n : Nat} {a : α} {l : List α} :
    replicate n a ~ l ↔ replicate n a = l 
Arguments: {α : Type u_1} {n : Nat} {a : α} {l : List α}
Goal: List.replicate n a ~ l ↔ List.replicate n a = l
-- List.perm_singleton
@[simp] theorem perm_singleton {a : α} {l : List α} : l ~ [a] ↔ l = [a] 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: l ~ [a] ↔ l = [a]
-- List.singleton_perm
@[simp] theorem singleton_perm {a : α} {l : List α} : [a] ~ l ↔ [a] = l 
Arguments: {α : Type u_1} {a : α} {l : List α}
Goal: [a] ~ l ↔ [a] = l
-- List.singleton_perm_singleton
theorem singleton_perm_singleton {a b : α} : [a] ~ [b] ↔ a = b 
Arguments: {α : Type u_1} {a b : α}
Goal: [a] ~ [b] ↔ a = b
-- List.perm_cons_erase
theorem perm_cons_erase [DecidableEq α] {a : α} {l : List α} (h : a ∈ l) : l ~ a :: l.erase a 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {l : List α} (h : a ∈ l)
Goal: l ~ a :: l.erase a
-- List.Perm.filterMap
theorem Perm.filterMap (f : α → Option β) {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    filterMap f l₁ ~ filterMap f l₂ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → Option β) {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: List.filterMap f l₁ ~ List.filterMap f l₂
-- List.Perm.map
theorem Perm.map (f : α → β) {l₁ l₂ : List α} (p : l₁ ~ l₂) : map f l₁ ~ map f l₂ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: List.map f l₁ ~ List.map f l₂
-- List.Perm.pmap
theorem Perm.pmap {p : α → Prop} (f : ∀ a, p a → β) {l₁ l₂ : List α} (p : l₁ ~ l₂) {H₁ H₂} :
    pmap f l₁ H₁ ~ pmap f l₂ H₂ 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) {l₁ l₂ : List α}
Goal: l₁ ~ l₂ → ∀ {H₁ : ∀ (a : α), a ∈ l₁ → p a} {H₂ : ∀ (a : α), a ∈ l₂ → p a}, List.pmap f l₁ H₁ ~ List.pmap f l₂ H₂
-- List.Perm.filter
theorem Perm.filter (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂) :
    filter p l₁ ~ filter p l₂ 
Arguments: {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂)
Goal: List.filter p l₁ ~ List.filter p l₂
-- List.filter_append_perm
theorem filter_append_perm (p : α → Bool) (l : List α) :
    filter p l ++ filter (fun x => !p x) l ~ l 
Arguments: {α : Type u_1} (p : α → Bool) (l : List α)
Goal: List.filter p l ++ List.filter (fun x => !p x) l ~ l
-- List.exists_perm_sublist
theorem exists_perm_sublist {l₁ l₂ l₂' : List α} (s : l₁ <+ l₂) (p : l₂ ~ l₂') :
    ∃ l₁', l₁' ~ l₁ ∧ l₁' <+ l₂' 
Arguments: {α : Type u_1} {l₁ l₂ l₂' : List α} (s : l₁ <+ l₂) (p : l₂ ~ l₂')
Goal: ∃ l₁', l₁' ~ l₁ ∧ l₁' <+ l₂'
-- List.Perm.sizeOf_eq_sizeOf
theorem Perm.sizeOf_eq_sizeOf [SizeOf α] {l₁ l₂ : List α} (h : l₁ ~ l₂) :
    sizeOf l₁ = sizeOf l₂ 
Arguments: {α : Type u_1} [SizeOf α] {l₁ l₂ : List α} (h : l₁ ~ l₂)
Goal: sizeOf l₁ = sizeOf l₂
-- List.nil_subperm
theorem nil_subperm {l : List α} : [] <+~ l 
Arguments: {α : Type u_1} {l : List α}
Goal: [] <+~ l
-- List.Perm.subperm_left
theorem Perm.subperm_left {l l₁ l₂ : List α} (p : l₁ ~ l₂) : l <+~ l₁ ↔ l <+~ l₂ 
Arguments: {α : Type u_1} {l l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: l <+~ l₁ ↔ l <+~ l₂
-- List.Perm.subperm_right
theorem Perm.subperm_right {l₁ l₂ l : List α} (p : l₁ ~ l₂) : l₁ <+~ l ↔ l₂ <+~ l 
Arguments: {α : Type u_1} {l₁ l₂ l : List α} (p : l₁ ~ l₂)
Goal: l₁ <+~ l ↔ l₂ <+~ l
-- List.Sublist.subperm
theorem Sublist.subperm {l₁ l₂ : List α} (s : l₁ <+ l₂) : l₁ <+~ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (s : l₁ <+ l₂)
Goal: l₁ <+~ l₂
-- List.Perm.subperm
theorem Perm.subperm {l₁ l₂ : List α} (p : l₁ ~ l₂) : l₁ <+~ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: l₁ <+~ l₂
-- List.Subperm.refl
@[refl] theorem Subperm.refl (l : List α) : l <+~ l 
Arguments: {α : Type u_1} (l : List α)
Goal: l <+~ l
-- List.Subperm.trans
theorem Subperm.trans {l₁ l₂ l₃ : List α} (s₁₂ : l₁ <+~ l₂) (s₂₃ : l₂ <+~ l₃) : l₁ <+~ l₃ 
Arguments: {α : Type u_1} {l₁ l₂ l₃ : List α} (s₁₂ : l₁ <+~ l₂) (s₂₃ : l₂ <+~ l₃)
Goal: l₁ <+~ l₃
-- List.Subperm.cons_right
theorem Subperm.cons_right {α : Type _} {l l' : List α} (x : α) (h : l <+~ l') : l <+~ x :: l' 
Arguments: {α : Type u_1} {l l' : List α} (x : α) (h : l <+~ l')
Goal: l <+~ x :: l'
-- List.Subperm.length_le
theorem Subperm.length_le {l₁ l₂ : List α} : l₁ <+~ l₂ → length l₁ ≤ length l₂
  
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <+~ l₂ → l₁.length ≤ l₂.length
-- List.Subperm.perm_of_length_le
theorem Subperm.perm_of_length_le {l₁ l₂ : List α} : l₁ <+~ l₂ → length l₂ ≤ length l₁ → l₁ ~ l₂
  
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <+~ l₂ → l₂.length ≤ l₁.length → l₁ ~ l₂
-- List.Subperm.antisymm
theorem Subperm.antisymm {l₁ l₂ : List α} (h₁ : l₁ <+~ l₂) (h₂ : l₂ <+~ l₁) : l₁ ~ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (h₁ : l₁ <+~ l₂) (h₂ : l₂ <+~ l₁)
Goal: l₁ ~ l₂
-- List.Subperm.subset
theorem Subperm.subset {l₁ l₂ : List α} : l₁ <+~ l₂ → l₁ ⊆ l₂
  
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <+~ l₂ → l₁ ⊆ l₂
-- List.Subperm.filter
theorem Subperm.filter (p : α → Bool) ⦃l l' : List α⦄ (h : l <+~ l') :
    filter p l <+~ filter p l' 
Arguments: {α : Type u_1} (p : α → Bool) ⦃l l' : List α⦄ (h : l <+~ l')
Goal: List.filter p l <+~ List.filter p l'
-- List.singleton_subperm_iff
@[simp] theorem singleton_subperm_iff {α} {l : List α} {a : α} : [a] <+~ l ↔ a ∈ l 
Arguments: {α : Type u_1} {l : List α} {a : α}
Goal: [a] <+~ l ↔ a ∈ l
-- List.Sublist.exists_perm_append
theorem Sublist.exists_perm_append {l₁ l₂ : List α} : l₁ <+ l₂ → ∃ l, l₂ ~ l₁ ++ l
  
Arguments: {α : Type u_1} {l₁ l₂ : List α}
Goal: l₁ <+ l₂ → ∃ l, l₂ ~ l₁ ++ l
-- List.Perm.countP_eq
theorem Perm.countP_eq (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂) :
    countP p l₁ = countP p l₂ 
Arguments: {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α} (s : l₁ ~ l₂)
Goal: List.countP p l₁ = List.countP p l₂
-- List.Subperm.countP_le
theorem Subperm.countP_le (p : α → Bool) {l₁ l₂ : List α} : l₁ <+~ l₂ → countP p l₁ ≤ countP p l₂
  
Arguments: {α : Type u_1} (p : α → Bool) {l₁ l₂ : List α}
Goal: l₁ <+~ l₂ → List.countP p l₁ ≤ List.countP p l₂
-- List.Perm.countP_congr
theorem Perm.countP_congr {l₁ l₂ : List α} (s : l₁ ~ l₂) {p p' : α → Bool}
    (hp : ∀ x ∈ l₁, p x = p' x) : l₁.countP p = l₂.countP p' 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (s : l₁ ~ l₂) {p p' : α → Bool} (hp : ∀ (x : α), x ∈ l₁ → p x = p' x)
Goal: List.countP p l₁ = List.countP p' l₂
-- List.countP_eq_countP_filter_add
theorem countP_eq_countP_filter_add (l : List α) (p q : α → Bool) :
    l.countP p = (l.filter q).countP p + (l.filter fun a => !q a).countP p 
Arguments: {α : Type u_1} (l : List α) (p q : α → Bool)
Goal: List.countP p l = List.countP p (List.filter q l) + List.countP p (List.filter (fun a => !q a) l)
-- List.Perm.count_eq
theorem Perm.count_eq [DecidableEq α] {l₁ l₂ : List α} (p : l₁ ~ l₂) (a) :
    count a l₁ = count a l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (p : l₁ ~ l₂) (a : α)
Goal: List.count a l₁ = List.count a l₂
-- List.Subperm.count_le
theorem Subperm.count_le [DecidableEq α] {l₁ l₂ : List α} (s : l₁ <+~ l₂) (a) :
    count a l₁ ≤ count a l₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (s : l₁ <+~ l₂) (a : α)
Goal: List.count a l₁ ≤ List.count a l₂
-- List.Perm.foldl_eq'
theorem Perm.foldl_eq' {f : β → α → β} {l₁ l₂ : List α} (p : l₁ ~ l₂)
    (comm : ∀ x ∈ l₁, ∀ y ∈ l₁, ∀ (z), f (f z x) y = f (f z y) x)
    (init) : foldl f init l₁ = foldl f init l₂ 
Arguments: {β : Type u_1} {α : Type u_2} {f : β → α → β} {l₁ l₂ : List α} (p : l₁ ~ l₂) (comm : ∀ (x : α), x ∈ l₁ → ∀ (y : α), y ∈ l₁ → ∀ (z : β), f (f z x) y = f (f z y) x) (init : β)
Goal: List.foldl f init l₁ = List.foldl f init l₂
-- List.Perm.rec_heq
theorem Perm.rec_heq {β : List α → Sort _} {f : ∀ a l, β l → β (a :: l)} {b : β []} {l l' : List α}
    (hl : l ~ l') (f_congr : ∀ {a l l' b b'}, l ~ l' → HEq b b' → HEq (f a l b) (f a l' b'))
    (f_swap : ∀ {a a' l b}, HEq (f a (a' :: l) (f a' l b)) (f a' (a :: l) (f a l b))) :
    HEq (@List.rec α β b f l) (@List.rec α β b f l') 
Arguments: {α : Type u_1} {β : List α → Sort u_2} {f : (a : α) → (l : List α) → β l → β (a :: l)} {b : β []} {l l' : List α} (hl : l ~ l') (f_congr : ∀ {a : α} {l l' : List α} {b : β l} {b' : β l'}, l ~ l' → HEq b b' → HEq (f a l b) (f a l' b')) (f_swap : ∀ {a a' : α} {l : List α} {b : β l}, HEq (f a (a' :: l) (f a' l b)) (f a' (a :: l) (f a l b)))
Goal: HEq (List.rec b f l) (List.rec b f l')
-- List.perm_inv_core
theorem perm_inv_core {a : α} {l₁ l₂ r₁ r₂ : List α} :
    l₁ ++ a :: r₁ ~ l₂ ++ a :: r₂ → l₁ ++ r₁ ~ l₂ ++ r₂ 
Arguments: {α : Type u_1} {a : α} {l₁ l₂ r₁ r₂ : List α}
Goal: l₁ ++ a :: r₁ ~ l₂ ++ a :: r₂ → l₁ ++ r₁ ~ l₂ ++ r₂
-- List.Perm.cons_inv
theorem Perm.cons_inv {a : α} {l₁ l₂ : List α} : a :: l₁ ~ a :: l₂ → l₁ ~ l₂ 
Arguments: {α : Type u_1} {a : α} {l₁ l₂ : List α}
Goal: a :: l₁ ~ a :: l₂ → l₁ ~ l₂
-- List.perm_cons
@[simp] theorem perm_cons (a : α) {l₁ l₂ : List α} : a :: l₁ ~ a :: l₂ ↔ l₁ ~ l₂ 
Arguments: {α : Type u_1} (a : α) {l₁ l₂ : List α}
Goal: a :: l₁ ~ a :: l₂ ↔ l₁ ~ l₂
-- List.perm_append_left_iff
theorem perm_append_left_iff {l₁ l₂ : List α} : ∀ l, l ++ l₁ ~ l ++ l₂ ↔ l₁ ~ l₂
  
Arguments: {α : Type u_1} {l₁ l₂ : List α} (l : List α)
Goal: l ++ l₁ ~ l ++ l₂ ↔ l₁ ~ l₂
-- List.perm_append_right_iff
theorem perm_append_right_iff {l₁ l₂ : List α} (l) : l₁ ++ l ~ l₂ ++ l ↔ l₁ ~ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (l : List α)
Goal: l₁ ++ l ~ l₂ ++ l ↔ l₁ ~ l₂
-- List.subperm_cons
theorem subperm_cons (a : α) {l₁ l₂ : List α} : a :: l₁ <+~ a :: l₂ ↔ l₁ <+~ l₂ 
Arguments: {α : Type u_1} (a : α) {l₁ l₂ : List α}
Goal: a :: l₁ <+~ a :: l₂ ↔ l₁ <+~ l₂
-- List.cons_subperm_of_not_mem_of_mem
theorem cons_subperm_of_not_mem_of_mem {a : α} {l₁ l₂ : List α} (h₁ : a ∉ l₁) (h₂ : a ∈ l₂)
    (s : l₁ <+~ l₂) : a :: l₁ <+~ l₂ 
Arguments: {α : Type u_1} {a : α} {l₁ l₂ : List α} (h₁ : ¬a ∈ l₁) (h₂ : a ∈ l₂) (s : l₁ <+~ l₂)
Goal: a :: l₁ <+~ l₂
-- List.subperm_append_left
theorem subperm_append_left {l₁ l₂ : List α} : ∀ l, l ++ l₁ <+~ l ++ l₂ ↔ l₁ <+~ l₂
  
Arguments: {α : Type u_1} {l₁ l₂ : List α} (l : List α)
Goal: l ++ l₁ <+~ l ++ l₂ ↔ l₁ <+~ l₂
-- List.subperm_append_right
theorem subperm_append_right {l₁ l₂ : List α} (l) : l₁ ++ l <+~ l₂ ++ l ↔ l₁ <+~ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (l : List α)
Goal: l₁ ++ l <+~ l₂ ++ l ↔ l₁ <+~ l₂
-- List.Subperm.exists_of_length_lt
theorem Subperm.exists_of_length_lt {l₁ l₂ : List α} (s : l₁ <+~ l₂) (h : length l₁ < length l₂) :
    ∃ a, a :: l₁ <+~ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (s : l₁ <+~ l₂) (h : l₁.length < l₂.length)
Goal: ∃ a, a :: l₁ <+~ l₂
-- List.subperm_of_subset
theorem subperm_of_subset (d : Nodup l₁) (H : l₁ ⊆ l₂) : l₁ <+~ l₂ 
Goal: ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Nodup → l₁ ⊆ l₂ → l₁ <+~ l₂
-- List.perm_ext_iff_of_nodup
theorem perm_ext_iff_of_nodup {l₁ l₂ : List α} (d₁ : Nodup l₁) (d₂ : Nodup l₂) :
    l₁ ~ l₂ ↔ ∀ a, a ∈ l₁ ↔ a ∈ l₂ 
Arguments: {α : Type u_1} {l₁ l₂ : List α} (d₁ : l₁.Nodup) (d₂ : l₂.Nodup)
Goal: l₁ ~ l₂ ↔ ∀ (a : α), a ∈ l₁ ↔ a ∈ l₂
-- List.Nodup.perm_iff_eq_of_sublist
theorem Nodup.perm_iff_eq_of_sublist {l₁ l₂ l : List α} (d : Nodup l)
    (s₁ : l₁ <+ l) (s₂ : l₂ <+ l) : l₁ ~ l₂ ↔ l₁ = l₂ 
Arguments: {α : Type u_1} {l₁ l₂ l : List α} (d : l.Nodup) (s₁ : l₁ <+ l) (s₂ : l₂ <+ l)
Goal: l₁ ~ l₂ ↔ l₁ = l₂
-- List.Perm.erase
theorem Perm.erase (a : α) {l₁ l₂ : List α} (p : l₁ ~ l₂) : l₁.erase a ~ l₂.erase a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) {l₁ l₂ : List α} (p : l₁ ~ l₂)
Goal: l₁.erase a ~ l₂.erase a
-- List.subperm_cons_erase
theorem subperm_cons_erase (a : α) (l : List α) : l <+~ a :: l.erase a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: l <+~ a :: l.erase a
-- List.erase_subperm
theorem erase_subperm (a : α) (l : List α) : l.erase a <+~ l 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (l : List α)
Goal: l.erase a <+~ l
-- List.Subperm.erase
theorem Subperm.erase {l₁ l₂ : List α} (a : α) (h : l₁ <+~ l₂) : l₁.erase a <+~ l₂.erase a 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (a : α) (h : l₁ <+~ l₂)
Goal: l₁.erase a <+~ l₂.erase a
-- List.Perm.diff_right
theorem Perm.diff_right {l₁ l₂ : List α} (t : List α) (h : l₁ ~ l₂) : l₁.diff t ~ l₂.diff t 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (t : List α) (h : l₁ ~ l₂)
Goal: l₁.diff t ~ l₂.diff t
-- List.Perm.diff_left
theorem Perm.diff_left (l : List α) {t₁ t₂ : List α} (h : t₁ ~ t₂) : l.diff t₁ = l.diff t₂ 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) {t₁ t₂ : List α} (h : t₁ ~ t₂)
Goal: l.diff t₁ = l.diff t₂
-- List.Perm.diff
theorem Perm.diff {l₁ l₂ t₁ t₂ : List α} (hl : l₁ ~ l₂) (ht : t₁ ~ t₂) : l₁.diff t₁ ~ l₂.diff t₂ 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ t₁ t₂ : List α} (hl : l₁ ~ l₂) (ht : t₁ ~ t₂)
Goal: l₁.diff t₁ ~ l₂.diff t₂
-- List.Subperm.diff_right
theorem Subperm.diff_right {l₁ l₂ : List α} (h : l₁ <+~ l₂) (t : List α) :
    l₁.diff t <+~ l₂.diff t 
Arguments: {α : Type u_1} [DecidableEq α] {l₁ l₂ : List α} (h : l₁ <+~ l₂) (t : List α)
Goal: l₁.diff t <+~ l₂.diff t