ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Matrix.blockDiagonal'RingHom_apply
@[simps]
def blockDiagonal'RingHom [∀ i, DecidableEq (m' i)] [Fintype o] [∀ i, Fintype (m' i)]
    [NonAssocSemiring α] : (∀ i, Matrix (m' i) (m' i) α) →+* Matrix (Σi, m' i) (Σi, m' i) α 
Arguments: {o : Type u_4} (m' : o → Type u_7) (α : Type u_12) [DecidableEq o] [(i : o) → DecidableEq (m' i)] [Fintype o] [(i : o) → Fintype (m' i)] [NonAssocSemiring α] (M : (i : o) → Matrix (m' i) (m' i) α)
Goal: (Matrix.blockDiagonal'RingHom m' α) M = Matrix.blockDiagonal' M
-- Matrix.blockDiagonal'_pow
@[simp]
theorem blockDiagonal'_pow [∀ i, DecidableEq (m' i)] [Fintype o] [∀ i, Fintype (m' i)] [Semiring α]
    (M : ∀ i, Matrix (m' i) (m' i) α) (n : ℕ) : blockDiagonal' (M ^ n) = blockDiagonal' M ^ n 
Arguments: {o : Type u_4} {m' : o → Type u_7} {α : Type u_12} [DecidableEq o] [(i : o) → DecidableEq (m' i)] [Fintype o] [(i : o) → Fintype (m' i)] [Semiring α] (M : (i : o) → Matrix (m' i) (m' i) α) (n : ℕ)
Goal: Matrix.blockDiagonal' (M ^ n) = Matrix.blockDiagonal' M ^ n
-- Matrix.blockDiagonal'_smul
@[simp]
theorem blockDiagonal'_smul {R : Type*} [Semiring R] [AddCommMonoid α] [Module R α] (x : R)
    (M : ∀ i, Matrix (m' i) (n' i) α) : blockDiagonal' (x • M) = x • blockDiagonal' M 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [DecidableEq o] {R : Type u_14} [Semiring R] [AddCommMonoid α] [Module R α] (x : R) (M : (i : o) → Matrix (m' i) (n' i) α)
Goal: Matrix.blockDiagonal' (x • M) = x • Matrix.blockDiagonal' M
-- Matrix.blockDiag'_apply
theorem blockDiag'_apply (M : Matrix (Σi, m' i) (Σi, n' i) α) (k : o) (i j) :
    blockDiag' M k i j = M ⟨k, i⟩ ⟨k, j⟩ 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o) (i : m' k) (j : n' k)
Goal: M.blockDiag' k i j = M ⟨k, i⟩ ⟨k, j⟩
-- Matrix.blockDiag'_map
theorem blockDiag'_map (M : Matrix (Σi, m' i) (Σi, n' i) α) (f : α → β) :
    blockDiag' (M.map f) = fun k => (blockDiag' M k).map f 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} {β : Type u_13} (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (f : α → β)
Goal: (M.map f).blockDiag' = fun k => (M.blockDiag' k).map f
-- Matrix.blockDiag'_transpose
@[simp]
theorem blockDiag'_transpose (M : Matrix (Σi, m' i) (Σi, n' i) α) (k : o) :
    blockDiag' Mᵀ k = (blockDiag' M k)ᵀ 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o)
Goal: Mᵀ.blockDiag' k = (M.blockDiag' k)ᵀ
-- Matrix.blockDiag'_conjTranspose
@[simp]
theorem blockDiag'_conjTranspose {α : Type*} [AddMonoid α] [StarAddMonoid α]
    (M : Matrix (Σi, m' i) (Σi, n' i) α) (k : o) : blockDiag' Mᴴ k = (blockDiag' M k)ᴴ 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_14} [AddMonoid α] [StarAddMonoid α] (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o)
Goal: Mᴴ.blockDiag' k = (M.blockDiag' k)ᴴ
-- Matrix.blockDiag'_zero
@[simp]
theorem blockDiag'_zero : blockDiag' (0 : Matrix (Σi, m' i) (Σi, n' i) α) = 0 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [Zero α]
Goal: Matrix.blockDiag' 0 = 0
-- Matrix.blockDiag'_diagonal
@[simp]
theorem blockDiag'_diagonal [DecidableEq o] [∀ i, DecidableEq (m' i)] (d : (Σi, m' i) → α) (k : o) :
    blockDiag' (diagonal d) k = diagonal fun i => d ⟨k, i⟩ 
Arguments: {o : Type u_4} {m' : o → Type u_7} {α : Type u_12} [Zero α] [DecidableEq o] [(i : o) → DecidableEq (m' i)] (d : (i : o) × m' i → α) (k : o)
Goal: (Matrix.diagonal d).blockDiag' k = Matrix.diagonal fun i => d ⟨k, i⟩
-- Matrix.blockDiag'_blockDiagonal'
@[simp]
theorem blockDiag'_blockDiagonal' [DecidableEq o] (M : ∀ i, Matrix (m' i) (n' i) α) :
    blockDiag' (blockDiagonal' M) = M 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [Zero α] [DecidableEq o] (M : (i : o) → Matrix (m' i) (n' i) α)
Goal: (Matrix.blockDiagonal' M).blockDiag' = M
-- Matrix.blockDiagonal'_injective
theorem blockDiagonal'_injective [DecidableEq o] :
    Function.Injective (blockDiagonal' : (∀ i, Matrix (m' i) (n' i) α) → Matrix _ _ α) 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [Zero α] [DecidableEq o]
Goal: Function.Injective Matrix.blockDiagonal'
-- Matrix.blockDiagonal'_inj
@[simp]
theorem blockDiagonal'_inj [DecidableEq o] {M N : ∀ i, Matrix (m' i) (n' i) α} :
    blockDiagonal' M = blockDiagonal' N ↔ M = N 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [Zero α] [DecidableEq o] {M N : (i : o) → Matrix (m' i) (n' i) α}
Goal: Matrix.blockDiagonal' M = Matrix.blockDiagonal' N ↔ M = N
-- Matrix.blockDiag'_one
@[simp]
theorem blockDiag'_one [DecidableEq o] [∀ i, DecidableEq (m' i)] [One α] :
    blockDiag' (1 : Matrix (Σi, m' i) (Σi, m' i) α) = 1 
Arguments: {o : Type u_4} {m' : o → Type u_7} {α : Type u_12} [Zero α] [DecidableEq o] [(i : o) → DecidableEq (m' i)] [One α]
Goal: Matrix.blockDiag' 1 = 1
-- Matrix.blockDiag'_add
@[simp]
theorem blockDiag'_add [AddZeroClass α] (M N : Matrix (Σi, m' i) (Σi, n' i) α) :
    blockDiag' (M + N) = blockDiag' M + blockDiag' N 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [AddZeroClass α] (M N : Matrix ((i : o) × m' i) ((i : o) × n' i) α)
Goal: (M + N).blockDiag' = M.blockDiag' + N.blockDiag'
-- Matrix.blockDiag'AddMonoidHom_apply
@[simps]
def blockDiag'AddMonoidHom [AddZeroClass α] :
    Matrix (Σi, m' i) (Σi, n' i) α →+ ∀ i, Matrix (m' i) (n' i) α 
Arguments: {o : Type u_4} (m' : o → Type u_7) (n' : o → Type u_8) (α : Type u_12) [AddZeroClass α] (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α) (k : o)
Goal: (Matrix.blockDiag'AddMonoidHom m' n' α) M k = M.blockDiag' k
-- Matrix.blockDiag'_neg
@[simp]
theorem blockDiag'_neg [AddGroup α] (M : Matrix (Σi, m' i) (Σi, n' i) α) :
    blockDiag' (-M) = -blockDiag' M 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [AddGroup α] (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α)
Goal: (-M).blockDiag' = -M.blockDiag'
-- Matrix.blockDiag'_sub
@[simp]
theorem blockDiag'_sub [AddGroup α] (M N : Matrix (Σi, m' i) (Σi, n' i) α) :
    blockDiag' (M - N) = blockDiag' M - blockDiag' N 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [AddGroup α] (M N : Matrix ((i : o) × m' i) ((i : o) × n' i) α)
Goal: (M - N).blockDiag' = M.blockDiag' - N.blockDiag'
-- Matrix.blockDiag'_smul
@[simp]
theorem blockDiag'_smul {R : Type*} [Monoid R] [AddMonoid α] [DistribMulAction R α] (x : R)
    (M : Matrix (Σi, m' i) (Σi, n' i) α) : blockDiag' (x • M) = x • blockDiag' M 
Arguments: {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} {R : Type u_14} [Monoid R] [AddMonoid α] [DistribMulAction R α] (x : R) (M : Matrix ((i : o) × m' i) ((i : o) × n' i) α)
Goal: (x • M).blockDiag' = x • M.blockDiag'
-- Matrix.toBlock_mul_eq_mul
theorem toBlock_mul_eq_mul {m n k : Type*} [Fintype n] (p : m → Prop) (q : k → Prop)
    (A : Matrix m n R) (B : Matrix n k R) :
    (A * B).toBlock p q = A.toBlock p ⊤ * B.toBlock ⊤ q 
Arguments: {R : Type u_10} [CommRing R] {m : Type u_14} {n : Type u_15} {k : Type u_16} [Fintype n] (p : m → Prop) (q : k → Prop) (A : Matrix m n R) (B : Matrix n k R)
Goal: (A * B).toBlock p q = A.toBlock p ⊤ * B.toBlock ⊤ q
-- Matrix.toBlock_mul_eq_add
theorem toBlock_mul_eq_add {m n k : Type*} [Fintype n] (p : m → Prop) (q : n → Prop)
    [DecidablePred q] (r : k → Prop) (A : Matrix m n R) (B : Matrix n k R) : (A * B).toBlock p r =
    A.toBlock p q * B.toBlock q r + (A.toBlock p fun i => ¬q i) * B.toBlock (fun i => ¬q i) r 
Arguments: {R : Type u_10} [CommRing R] {m : Type u_14} {n : Type u_15} {k : Type u_16} [Fintype n] (p : m → Prop) (q : n → Prop) [DecidablePred q] (r : k → Prop) (A : Matrix m n R) (B : Matrix n k R)
Goal: (A * B).toBlock p r = A.toBlock p q * B.toBlock q r + (A.toBlock p fun i => ¬q i) * B.toBlock (fun i => ¬q i) r
-- Fintype.card_shrink
@[simp] lemma Fintype.card_shrink [Fintype (Shrink.{v} α)] : card (Shrink.{v} α) = card α 
Arguments: {α : Type u} [Fintype α] [Fintype (Shrink.{v, u} α)]
Goal: Fintype.card (Shrink.{v, u} α) = Fintype.card α
-- univ_option
theorem univ_option (α : Type*) [Fintype α] : (univ : Finset (Option α)) = insertNone univ 
Arguments: (α : Type u_4) [Fintype α]
Goal: Finset.univ = Finset.insertNone Finset.univ
-- Fintype.card_option
@[simp]
theorem Fintype.card_option {α : Type*} [Fintype α] :
    Fintype.card (Option α) = Fintype.card α + 1 
Arguments: {α : Type u_4} [Fintype α]
Goal: Fintype.card (Option α) = Fintype.card α + 1
-- Fintype.induction_empty_option
@[elab_as_elim]
theorem induction_empty_option {P : ∀ (α : Type u) [Fintype α], Prop}
    (of_equiv : ∀ (α β) [Fintype β] (e : α ≃ β), @P α (@Fintype.ofEquiv α β ‹_› e.symm) → @P β ‹_›)
    (h_empty : P PEmpty) (h_option : ∀ (α) [Fintype α], P α → P (Option α)) (α : Type u)
    [h_fintype : Fintype α] : P α 
Arguments: {P : (α : Type u) → [inst : Fintype α] → Prop} (of_equiv : ∀ (α β : Type u) [inst : Fintype β] (e : α ≃ β), P α → P β) (h_empty : P PEmpty.{u + 1}) (h_option : ∀ (α : Type u) [inst : Fintype α], P α → P (Option α)) (α : Type u) [h_fintype : Fintype α]
Goal: P α
-- Finite.induction_empty_option
theorem Finite.induction_empty_option {P : Type u → Prop} (of_equiv : ∀ {α β}, α ≃ β → P α → P β)
    (h_empty : P PEmpty) (h_option : ∀ {α} [Fintype α], P α → P (Option α)) (α : Type u)
    [Finite α] : P α 
Arguments: {P : Type u → Prop} (of_equiv : ∀ {α β : Type u}, α ≃ β → P α → P β) (h_empty : P PEmpty.{u + 1}) (h_option : ∀ {α : Type u} [inst : Fintype α], P α → P (Option α)) (α : Type u) [Finite α]
Goal: P α
-- Option.elim'_none
@[simp]
theorem elim'_none (b : β) (f : α → β) : Option.elim' b f none = b 
Arguments: {α : Type u_1} {β : Type u_2} (b : β) (f : α → β)
Goal: Option.elim' b f none = b
-- Option.elim'_some
@[simp]
theorem elim'_some {a : α} (b : β) (f : α → β) : Option.elim' b f (some a) = f a 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} (b : β) (f : α → β)
Goal: Option.elim' b f (some a) = f a
-- Option.elim'_eq_elim
lemma elim'_eq_elim {α β : Type*} (b : β) (f : α → β) (a : Option α) :
    Option.elim' b f a = Option.elim a b f 
Arguments: {α : Type u_3} {β : Type u_4} (b : β) (f : α → β) (a : Option α)
Goal: Option.elim' b f a = a.elim b f
-- Option.mem_some_iff
theorem mem_some_iff {α : Type*} {a b : α} : a ∈ some b ↔ b = a 
Arguments: {α : Type u_3} {a b : α}
Goal: a ∈ some b ↔ b = a
-- Option.iget_some
theorem iget_some [Inhabited α] {a : α} : (some a).iget = a 
Arguments: {α : Type u_1} [Inhabited α] {a : α}
Goal: (some a).iget = a
-- Option.mem_toList
@[simp]
theorem mem_toList {a : α} {o : Option α} : a ∈ toList o ↔ a ∈ o 
Arguments: {α : Type u_1} {a : α} {o : Option α}
Goal: a ∈ o.toList ↔ a ∈ o
-- MvQPF.recF_eq
theorem recF_eq {α : TypeVec n} {β : Type u} (g : F (α.append1 β) → β) (a : q.P.A)
    (f' : q.P.drop.B a ⟹ α) (f : q.P.last.B a → q.P.W α) :
    recF g (q.P.wMk a f' f) = g (abs ⟨a, splitFun f' (recF g ∘ f)⟩) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : F (α ::: β) → β) (a : (MvQPF.P F).A) (f' : ((MvQPF.P F).drop.B a).Arrow α) (f : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
Goal: MvQPF.recF g ((MvQPF.P F).wMk a f' f) = g (MvQPF.abs ⟨a, TypeVec.splitFun f' (MvQPF.recF g ∘ f)⟩)
-- MvQPF.recF_eq'
theorem recF_eq' {α : TypeVec n} {β : Type u} (g : F (α.append1 β) → β) (x : q.P.W α) :
    recF g x = g (abs (appendFun id (recF g) <$$> q.P.wDest' x)) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : F (α ::: β) → β) (x : (MvQPF.P F).W α)
Goal: MvQPF.recF g x = g (MvQPF.abs (MvFunctor.map (TypeVec.id ::: MvQPF.recF g) ((MvQPF.P F).wDest' x)))
-- MvQPF.recF_eq_of_wEquiv
theorem recF_eq_of_wEquiv (α : TypeVec n) {β : Type u} (u : F (α.append1 β) → β) (x y : q.P.W α) :
    WEquiv x y → recF u x = recF u y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] (α : TypeVec.{u} n) {β : Type u} (u : F (α ::: β) → β) (x y : (MvQPF.P F).W α)
Goal: MvQPF.WEquiv x y → MvQPF.recF u x = MvQPF.recF u y
-- MvQPF.wEquiv.abs'
theorem wEquiv.abs' {α : TypeVec n} (x y : q.P.W α)
    (h : MvQPF.abs (q.P.wDest' x) = MvQPF.abs (q.P.wDest' y)) :
    WEquiv x y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x y : (MvQPF.P F).W α) (h : MvQPF.abs ((MvQPF.P F).wDest' x) = MvQPF.abs ((MvQPF.P F).wDest' y))
Goal: MvQPF.WEquiv x y
-- MvQPF.wEquiv.refl
theorem wEquiv.refl {α : TypeVec n} (x : q.P.W α) : WEquiv x x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : (MvQPF.P F).W α)
Goal: MvQPF.WEquiv x x
-- MvQPF.wEquiv.symm
theorem wEquiv.symm {α : TypeVec n} (x y : q.P.W α) : WEquiv x y → WEquiv y x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x y : (MvQPF.P F).W α)
Goal: MvQPF.WEquiv x y → MvQPF.WEquiv y x
-- MvQPF.wrepr_wMk
theorem wrepr_wMk {α : TypeVec n} (a : q.P.A) (f' : q.P.drop.B a ⟹ α)
    (f : q.P.last.B a → q.P.W α) :
    wrepr (q.P.wMk a f' f) =
      q.P.wMk' (repr (abs (appendFun id wrepr <$$> ⟨a, q.P.appendContents f' f⟩))) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (a : (MvQPF.P F).A) (f' : ((MvQPF.P F).drop.B a).Arrow α) (f : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
Goal: MvQPF.wrepr ((MvQPF.P F).wMk a f' f) =
  (MvQPF.P F).wMk'
    (MvQPF.repr (MvQPF.abs (MvFunctor.map (TypeVec.id ::: MvQPF.wrepr) ⟨a, (MvQPF.P F).appendContents f' f⟩)))
-- MvQPF.wrepr_equiv
theorem wrepr_equiv {α : TypeVec n} (x : q.P.W α) : WEquiv (wrepr x) x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : (MvQPF.P F).W α)
Goal: MvQPF.WEquiv (MvQPF.wrepr x) x
-- MvQPF.wEquiv_map
theorem wEquiv_map {α β : TypeVec n} (g : α ⟹ β) (x y : q.P.W α) :
    WEquiv x y → WEquiv (g <$$> x) (g <$$> y) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α β : TypeVec.{u} n} (g : α.Arrow β) (x y : (MvQPF.P F).W α)
Goal: MvQPF.WEquiv x y → MvQPF.WEquiv (MvFunctor.map g x) (MvFunctor.map g y)
-- MvQPF.Fix.rec_eq
theorem Fix.rec_eq {β : Type u} (g : F (append1 α β) → β) (x : F (append1 α (Fix F α))) :
    Fix.rec g (Fix.mk x) = g (appendFun id (Fix.rec g) <$$> x) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : F (α ::: β) → β) (x : F (α ::: MvQPF.Fix F α))
Goal: MvQPF.Fix.rec g (MvQPF.Fix.mk x) = g (MvFunctor.map (TypeVec.id ::: MvQPF.Fix.rec g) x)
-- MvQPF.Fix.ind_aux
theorem Fix.ind_aux (a : q.P.A) (f' : q.P.drop.B a ⟹ α) (f : q.P.last.B a → q.P.W α) :
    Fix.mk (abs ⟨a, q.P.appendContents f' fun x => ⟦f x⟧⟩) = ⟦q.P.wMk a f' f⟧ 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (a : (MvQPF.P F).A) (f' : ((MvQPF.P F).drop.B a).Arrow α) (f : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
Goal: MvQPF.Fix.mk (MvQPF.abs ⟨a, (MvQPF.P F).appendContents f' fun x => ⟦f x⟧⟩) = ⟦(MvQPF.P F).wMk a f' f⟧
-- MvQPF.Fix.ind_rec
theorem Fix.ind_rec {β : Type u} (g₁ g₂ : Fix F α → β)
    (h :
      ∀ x : F (append1 α (Fix F α)),
        appendFun id g₁ <$$> x = appendFun id g₂ <$$> x → g₁ (Fix.mk x) = g₂ (Fix.mk x)) :
    ∀ x, g₁ x = g₂ x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g₁ g₂ : MvQPF.Fix F α → β) (h :
  ∀ (x : F (α ::: MvQPF.Fix F α)),
    MvFunctor.map (TypeVec.id ::: g₁) x = MvFunctor.map (TypeVec.id ::: g₂) x →
      g₁ (MvQPF.Fix.mk x) = g₂ (MvQPF.Fix.mk x)) (x : MvQPF.Fix F α)
Goal: g₁ x = g₂ x
-- MvQPF.Fix.rec_unique
theorem Fix.rec_unique {β : Type u} (g : F (append1 α β) → β) (h : Fix F α → β)
    (hyp : ∀ x, h (Fix.mk x) = g (appendFun id h <$$> x)) : Fix.rec g = h 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : F (α ::: β) → β) (h : MvQPF.Fix F α → β) (hyp : ∀ (x : F (α ::: MvQPF.Fix F α)), h (MvQPF.Fix.mk x) = g (MvFunctor.map (TypeVec.id ::: h) x))
Goal: MvQPF.Fix.rec g = h
-- MvQPF.Fix.mk_dest
theorem Fix.mk_dest (x : Fix F α) : Fix.mk (Fix.dest x) = x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : MvQPF.Fix F α)
Goal: MvQPF.Fix.mk x.dest = x
-- MvQPF.Fix.dest_mk
theorem Fix.dest_mk (x : F (append1 α (Fix F α))) : Fix.dest (Fix.mk x) = x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : F (α ::: MvQPF.Fix F α))
Goal: (MvQPF.Fix.mk x).dest = x
-- MvQPF.Fix.ind
theorem Fix.ind {α : TypeVec n} (p : Fix F α → Prop)
    (h : ∀ x : F (α.append1 (Fix F α)), LiftP (PredLast α p) x → p (Fix.mk x)) : ∀ x, p x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (p : MvQPF.Fix F α → Prop) (h : ∀ (x : F (α ::: MvQPF.Fix F α)), MvFunctor.LiftP (α.PredLast p) x → p (MvQPF.Fix.mk x)) (x : MvQPF.Fix F α)
Goal: p x
-- Fintype.complete
class Fintype (α : Type*) where
    elems : Finset α
    complete : ∀ x : α, x ∈ elems
Arguments: {α : Type u_4} [self : Fintype α] (x : α)
Goal: x ∈ Fintype.elems
-- Finset.mem_univ
@[simp]
theorem mem_univ (x : α) : x ∈ (univ : Finset α) 
Arguments: {α : Type u_1} [Fintype α] (x : α)
Goal: x ∈ Finset.univ
-- Finset.mem_univ_val
theorem mem_univ_val : ∀ x, x ∈ (univ : Finset α).1 
Arguments: {α : Type u_1} [Fintype α] (x : α)
Goal: x ∈ Finset.univ.val
-- Finset.eq_univ_iff_forall
theorem eq_univ_iff_forall : s = univ ↔ ∀ x, x ∈ s 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α}
Goal: s = Finset.univ ↔ ∀ (x : α), x ∈ s
-- Finset.eq_univ_of_forall
theorem eq_univ_of_forall : (∀ x, x ∈ s) → s = univ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α}
Goal: (∀ (x : α), x ∈ s) → s = Finset.univ
-- Finset.coe_univ
@[simp, norm_cast]
theorem coe_univ : ↑(univ : Finset α) = (Set.univ : Set α) 
Arguments: {α : Type u_1} [Fintype α]
Goal: ↑Finset.univ = Set.univ
-- Finset.coe_eq_univ
@[simp, norm_cast]
theorem coe_eq_univ : (s : Set α) = Set.univ ↔ s = univ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α}
Goal: ↑s = Set.univ ↔ s = Finset.univ
-- Finset.Nonempty.eq_univ
theorem Nonempty.eq_univ [Subsingleton α] : s.Nonempty → s = univ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [Subsingleton α]
Goal: s.Nonempty → s = Finset.univ
-- Finset.univ_nonempty_iff
theorem univ_nonempty_iff : (univ : Finset α).Nonempty ↔ Nonempty α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Finset.univ.Nonempty ↔ Nonempty α
-- Finset.univ_nonempty
@[aesop unsafe apply (rule_sets := [finsetNonempty])]
theorem univ_nonempty [Nonempty α] : (univ : Finset α).Nonempty 
Arguments: {α : Type u_1} [Fintype α] [Nonempty α]
Goal: Finset.univ.Nonempty
-- Finset.univ_eq_empty_iff
theorem univ_eq_empty_iff : (univ : Finset α) = ∅ ↔ IsEmpty α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Finset.univ = ∅ ↔ IsEmpty α
-- Finset.univ_nontrivial_iff
theorem univ_nontrivial_iff :
    (Finset.univ : Finset α).Nontrivial ↔ Nontrivial α 
Arguments: {α : Type u_1} [Fintype α]
Goal: Finset.univ.Nontrivial ↔ Nontrivial α
-- Finset.univ_nontrivial
theorem univ_nontrivial [h : Nontrivial α] :
    (Finset.univ : Finset α).Nontrivial 
Arguments: {α : Type u_1} [Fintype α] [h : Nontrivial α]
Goal: Finset.univ.Nontrivial
-- Finset.univ_eq_empty
@[simp]
theorem univ_eq_empty [IsEmpty α] : (univ : Finset α) = ∅ 
Arguments: {α : Type u_1} [Fintype α] [IsEmpty α]
Goal: Finset.univ = ∅
-- Finset.univ_unique
@[simp]
theorem univ_unique [Unique α] : (univ : Finset α) = {default} 
Arguments: {α : Type u_1} [Fintype α] [Unique α]
Goal: Finset.univ = {default}
-- Finset.subset_univ
@[simp]
theorem subset_univ (s : Finset α) : s ⊆ univ 
Arguments: {α : Type u_1} [Fintype α] (s : Finset α)
Goal: s ⊆ Finset.univ
-- Finset.top_eq_univ
@[simp]
theorem top_eq_univ : (⊤ : Finset α) = univ 
Arguments: {α : Type u_1} [Fintype α]
Goal: ⊤ = Finset.univ
-- Finset.ssubset_univ_iff
theorem ssubset_univ_iff {s : Finset α} : s ⊂ univ ↔ s ≠ univ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α}
Goal: s ⊂ Finset.univ ↔ s ≠ Finset.univ
-- Finset.univ_subset_iff
@[simp]
theorem univ_subset_iff {s : Finset α} : univ ⊆ s ↔ s = univ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α}
Goal: Finset.univ ⊆ s ↔ s = Finset.univ
-- Finset.codisjoint_left
theorem codisjoint_left : Codisjoint s t ↔ ∀ ⦃a⦄, a ∉ s → a ∈ t 
Arguments: {α : Type u_1} [Fintype α] {s t : Finset α}
Goal: Codisjoint s t ↔ ∀ ⦃a : α⦄, a ∉ s → a ∈ t
-- Finset.codisjoint_right
theorem codisjoint_right : Codisjoint s t ↔ ∀ ⦃a⦄, a ∉ t → a ∈ s 
Arguments: {α : Type u_1} [Fintype α] {s t : Finset α}
Goal: Codisjoint s t ↔ ∀ ⦃a : α⦄, a ∉ t → a ∈ s
-- Finset.sdiff_eq_inter_compl
theorem sdiff_eq_inter_compl (s t : Finset α) : s \ t = s ∩ tᶜ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: s \ t = s ∩ tᶜ
-- Finset.compl_eq_univ_sdiff
theorem compl_eq_univ_sdiff (s : Finset α) : sᶜ = univ \ s 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: sᶜ = Finset.univ \ s
-- Finset.mem_compl
@[simp]
theorem mem_compl : a ∈ sᶜ ↔ a ∉ s 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [DecidableEq α] {a : α}
Goal: a ∈ sᶜ ↔ a ∉ s
-- Finset.not_mem_compl
theorem not_mem_compl : a ∉ sᶜ ↔ a ∈ s 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [DecidableEq α] {a : α}
Goal: a ∉ sᶜ ↔ a ∈ s
-- Finset.coe_compl
@[simp, norm_cast]
theorem coe_compl (s : Finset α) : ↑sᶜ = (↑s : Set α)ᶜ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: ↑sᶜ = (↑s)ᶜ
-- Finset.compl_subset_compl
@[simp] lemma compl_subset_compl : sᶜ ⊆ tᶜ ↔ t ⊆ s 
Arguments: {α : Type u_1} [Fintype α] {s t : Finset α} [DecidableEq α]
Goal: sᶜ ⊆ tᶜ ↔ t ⊆ s
-- Finset.compl_ssubset_compl
@[simp] lemma compl_ssubset_compl : sᶜ ⊂ tᶜ ↔ t ⊂ s 
Arguments: {α : Type u_1} [Fintype α] {s t : Finset α} [DecidableEq α]
Goal: sᶜ ⊂ tᶜ ↔ t ⊂ s
-- Finset.subset_compl_comm
lemma subset_compl_comm : s ⊆ tᶜ ↔ t ⊆ sᶜ 
Arguments: {α : Type u_1} [Fintype α] {s t : Finset α} [DecidableEq α]
Goal: s ⊆ tᶜ ↔ t ⊆ sᶜ
-- Finset.subset_compl_singleton
@[simp] lemma subset_compl_singleton : s ⊆ {a}ᶜ ↔ a ∉ s 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [DecidableEq α] {a : α}
Goal: s ⊆ {a}ᶜ ↔ a ∉ s
-- Finset.compl_empty
@[simp]
theorem compl_empty : (∅ : Finset α)ᶜ = univ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α]
Goal: ∅ᶜ = Finset.univ
-- Finset.compl_univ
@[simp]
theorem compl_univ : (univ : Finset α)ᶜ = ∅ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α]
Goal: Finset.univᶜ = ∅
-- Finset.compl_eq_empty_iff
@[simp]
theorem compl_eq_empty_iff (s : Finset α) : sᶜ = ∅ ↔ s = univ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: sᶜ = ∅ ↔ s = Finset.univ
-- Finset.compl_eq_univ_iff
@[simp]
theorem compl_eq_univ_iff (s : Finset α) : sᶜ = univ ↔ s = ∅ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: sᶜ = Finset.univ ↔ s = ∅
-- Finset.union_compl
@[simp]
theorem union_compl (s : Finset α) : s ∪ sᶜ = univ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: s ∪ sᶜ = Finset.univ
-- Finset.inter_compl
@[simp]
theorem inter_compl (s : Finset α) : s ∩ sᶜ = ∅ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s : Finset α)
Goal: s ∩ sᶜ = ∅
-- Finset.compl_union
@[simp]
theorem compl_union (s t : Finset α) : (s ∪ t)ᶜ = sᶜ ∩ tᶜ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s ∪ t)ᶜ = sᶜ ∩ tᶜ
-- Finset.compl_inter
@[simp]
theorem compl_inter (s t : Finset α) : (s ∩ t)ᶜ = sᶜ ∪ tᶜ 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (s t : Finset α)
Goal: (s ∩ t)ᶜ = sᶜ ∪ tᶜ
-- Finset.compl_erase
@[simp]
theorem compl_erase : (s.erase a)ᶜ = insert a sᶜ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [DecidableEq α] {a : α}
Goal: (s.erase a)ᶜ = insert a sᶜ
-- Finset.compl_insert
@[simp]
theorem compl_insert : (insert a s)ᶜ = sᶜ.erase a 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [DecidableEq α] {a : α}
Goal: (insert a s)ᶜ = sᶜ.erase a
-- Finset.insert_compl_insert
theorem insert_compl_insert (ha : a ∉ s) : insert a (insert a s)ᶜ = sᶜ 
Arguments: {α : Type u_1} [Fintype α] {s : Finset α} [DecidableEq α] {a : α} (ha : a ∉ s)
Goal: insert a (insert a s)ᶜ = sᶜ