ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finset.sumLift₂_nonempty
theorem sumLift₂_nonempty :
    (sumLift₂ f g a b).Nonempty ↔
      (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ (f a₁ b₁).Nonempty) ∨
        ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ (g a₂ b₂).Nonempty 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f : α₁ → β₁ → Finset γ₁} {g : α₂ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂}
Goal: (Finset.sumLift₂ f g a b).Nonempty ↔
  (∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ (f a₁ b₁).Nonempty) ∨
    ∃ a₂ b₂, a = Sum.inr a₂ ∧ b = Sum.inr b₂ ∧ (g a₂ b₂).Nonempty
-- Finset.sumLift₂_mono
theorem sumLift₂_mono (h₁ : ∀ a b, f₁ a b ⊆ g₁ a b) (h₂ : ∀ a b, f₂ a b ⊆ g₂ a b) :
    ∀ a b, sumLift₂ f₁ f₂ a b ⊆ sumLift₂ g₁ g₂ a b
  
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ g₁ : α₁ → β₁ → Finset γ₁} {f₂ g₂ : α₂ → β₂ → Finset γ₂} (h₁ : ∀ (a : α₁) (b : β₁), f₁ a b ⊆ g₁ a b) (h₂ : ∀ (a : α₂) (b : β₂), f₂ a b ⊆ g₂ a b) (a : α₁ ⊕ α₂) (b : β₁ ⊕ β₂)
Goal: Finset.sumLift₂ f₁ f₂ a b ⊆ Finset.sumLift₂ g₁ g₂ a b
-- Finset.sumLexLift_inl_inl
@[simp]
lemma sumLexLift_inl_inl (a : α₁) (b : β₁) :
    sumLexLift f₁ f₂ g₁ g₂ (inl a) (inl b) = (f₁ a b).map Embedding.inl 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} (f₁ : α₁ → β₁ → Finset γ₁) (f₂ : α₂ → β₂ → Finset γ₂) (g₁ : α₁ → β₂ → Finset γ₁) (g₂ : α₁ → β₂ → Finset γ₂) (a : α₁) (b : β₁)
Goal: Finset.sumLexLift f₁ f₂ g₁ g₂ (Sum.inl a) (Sum.inl b) = Finset.map Function.Embedding.inl (f₁ a b)
-- Finset.sumLexLift_inl_inr
@[simp]
lemma sumLexLift_inl_inr (a : α₁) (b : β₂) :
    sumLexLift f₁ f₂ g₁ g₂ (inl a) (inr b) = (g₁ a b).disjSum (g₂ a b) 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} (f₁ : α₁ → β₁ → Finset γ₁) (f₂ : α₂ → β₂ → Finset γ₂) (g₁ : α₁ → β₂ → Finset γ₁) (g₂ : α₁ → β₂ → Finset γ₂) (a : α₁) (b : β₂)
Goal: Finset.sumLexLift f₁ f₂ g₁ g₂ (Sum.inl a) (Sum.inr b) = (g₁ a b).disjSum (g₂ a b)
-- Finset.sumLexLift_inr_inl
@[simp]
lemma sumLexLift_inr_inl (a : α₂) (b : β₁) : sumLexLift f₁ f₂ g₁ g₂ (inr a) (inl b) = ∅ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} (f₁ : α₁ → β₁ → Finset γ₁) (f₂ : α₂ → β₂ → Finset γ₂) (g₁ : α₁ → β₂ → Finset γ₁) (g₂ : α₁ → β₂ → Finset γ₂) (a : α₂) (b : β₁)
Goal: Finset.sumLexLift f₁ f₂ g₁ g₂ (Sum.inr a) (Sum.inl b) = ∅
-- Finset.sumLexLift_inr_inr
@[simp]
lemma sumLexLift_inr_inr (a : α₂) (b : β₂) :
    sumLexLift f₁ f₂ g₁ g₂ (inr a) (inr b) = (f₂ a b).map ⟨_, inr_injective⟩ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} (f₁ : α₁ → β₁ → Finset γ₁) (f₂ : α₂ → β₂ → Finset γ₂) (g₁ : α₁ → β₂ → Finset γ₁) (g₂ : α₁ → β₂ → Finset γ₂) (a : α₂) (b : β₂)
Goal: Finset.sumLexLift f₁ f₂ g₁ g₂ (Sum.inr a) (Sum.inr b) = Finset.map { toFun := Sum.inr, inj' := ⋯ } (f₂ a b)
-- Finset.mem_sumLexLift
lemma mem_sumLexLift :
    c ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₁ c₁, a = inl a₁ ∧ b = inl b₁ ∧ c = inl c₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨
        (∃ a₁ b₂ c₁, a = inl a₁ ∧ b = inr b₂ ∧ c = inl c₁ ∧ c₁ ∈ g₁ a₁ b₂) ∨
          (∃ a₁ b₂ c₂, a = inl a₁ ∧ b = inr b₂ ∧ c = inr c₂ ∧ c₂ ∈ g₂ a₁ b₂) ∨
            ∃ a₂ b₂ c₂, a = inr a₂ ∧ b = inr b₂ ∧ c = inr c₂ ∧ c₂ ∈ f₂ a₂ b₂ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ : α₁ → β₁ → Finset γ₁} {f₂ : α₂ → β₂ → Finset γ₂} {g₁ : α₁ → β₂ → Finset γ₁} {g₂ : α₁ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c : γ₁ ⊕ γ₂}
Goal: c ∈ Finset.sumLexLift f₁ f₂ g₁ g₂ a b ↔
  (∃ a₁ b₁ c₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ c = Sum.inl c₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨
    (∃ a₁ b₂ c₁, a = Sum.inl a₁ ∧ b = Sum.inr b₂ ∧ c = Sum.inl c₁ ∧ c₁ ∈ g₁ a₁ b₂) ∨
      (∃ a₁ b₂ c₂, a = Sum.inl a₁ ∧ b = Sum.inr b₂ ∧ c = Sum.inr c₂ ∧ c₂ ∈ g₂ a₁ b₂) ∨
        ∃ a₂ b₂ c₂, a = Sum.inr a₂ ∧ b = Sum.inr b₂ ∧ c = Sum.inr c₂ ∧ c₂ ∈ f₂ a₂ b₂
-- Finset.inl_mem_sumLexLift
lemma inl_mem_sumLexLift {c₁ : γ₁} :
    inl c₁ ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨
        ∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ c₁ ∈ g₁ a₁ b₂ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ : α₁ → β₁ → Finset γ₁} {f₂ : α₂ → β₂ → Finset γ₂} {g₁ : α₁ → β₂ → Finset γ₁} {g₂ : α₁ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c₁ : γ₁}
Goal: Sum.inl c₁ ∈ Finset.sumLexLift f₁ f₂ g₁ g₂ a b ↔
  (∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨ ∃ a₁ b₂, a = Sum.inl a₁ ∧ b = Sum.inr b₂ ∧ c₁ ∈ g₁ a₁ b₂
-- Finset.inr_mem_sumLexLift
lemma inr_mem_sumLexLift {c₂ : γ₂} :
    inr c₂ ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ c₂ ∈ g₂ a₁ b₂) ∨
        ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ c₂ ∈ f₂ a₂ b₂ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ : α₁ → β₁ → Finset γ₁} {f₂ : α₂ → β₂ → Finset γ₂} {g₁ : α₁ → β₂ → Finset γ₁} {g₂ : α₁ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂} {c₂ : γ₂}
Goal: Sum.inr c₂ ∈ Finset.sumLexLift f₁ f₂ g₁ g₂ a b ↔
  (∃ a₁ b₂, a = Sum.inl a₁ ∧ b = Sum.inr b₂ ∧ c₂ ∈ g₂ a₁ b₂) ∨ ∃ a₂ b₂, a = Sum.inr a₂ ∧ b = Sum.inr b₂ ∧ c₂ ∈ f₂ a₂ b₂
-- Finset.sumLexLift_mono
lemma sumLexLift_mono (hf₁ : ∀ a b, f₁ a b ⊆ f₁' a b) (hf₂ : ∀ a b, f₂ a b ⊆ f₂' a b)
    (hg₁ : ∀ a b, g₁ a b ⊆ g₁' a b) (hg₂ : ∀ a b, g₂ a b ⊆ g₂' a b) (a : α₁ ⊕ α₂)
    (b : β₁ ⊕ β₂) : sumLexLift f₁ f₂ g₁ g₂ a b ⊆ sumLexLift f₁' f₂' g₁' g₂' a b 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ f₁' : α₁ → β₁ → Finset γ₁} {f₂ f₂' : α₂ → β₂ → Finset γ₂} {g₁ g₁' : α₁ → β₂ → Finset γ₁} {g₂ g₂' : α₁ → β₂ → Finset γ₂} (hf₁ : ∀ (a : α₁) (b : β₁), f₁ a b ⊆ f₁' a b) (hf₂ : ∀ (a : α₂) (b : β₂), f₂ a b ⊆ f₂' a b) (hg₁ : ∀ (a : α₁) (b : β₂), g₁ a b ⊆ g₁' a b) (hg₂ : ∀ (a : α₁) (b : β₂), g₂ a b ⊆ g₂' a b) (a : α₁ ⊕ α₂) (b : β₁ ⊕ β₂)
Goal: Finset.sumLexLift f₁ f₂ g₁ g₂ a b ⊆ Finset.sumLexLift f₁' f₂' g₁' g₂' a b
-- Finset.sumLexLift_eq_empty
lemma sumLexLift_eq_empty :
    sumLexLift f₁ f₂ g₁ g₂ a b = ∅ ↔
      (∀ a₁ b₁, a = inl a₁ → b = inl b₁ → f₁ a₁ b₁ = ∅) ∧
        (∀ a₁ b₂, a = inl a₁ → b = inr b₂ → g₁ a₁ b₂ = ∅ ∧ g₂ a₁ b₂ = ∅) ∧
          ∀ a₂ b₂, a = inr a₂ → b = inr b₂ → f₂ a₂ b₂ = ∅ 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ : α₁ → β₁ → Finset γ₁} {f₂ : α₂ → β₂ → Finset γ₂} {g₁ : α₁ → β₂ → Finset γ₁} {g₂ : α₁ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂}
Goal: Finset.sumLexLift f₁ f₂ g₁ g₂ a b = ∅ ↔
  (∀ (a₁ : α₁) (b₁ : β₁), a = Sum.inl a₁ → b = Sum.inl b₁ → f₁ a₁ b₁ = ∅) ∧
    (∀ (a₁ : α₁) (b₂ : β₂), a = Sum.inl a₁ → b = Sum.inr b₂ → g₁ a₁ b₂ = ∅ ∧ g₂ a₁ b₂ = ∅) ∧
      ∀ (a₂ : α₂) (b₂ : β₂), a = Sum.inr a₂ → b = Sum.inr b₂ → f₂ a₂ b₂ = ∅
-- Finset.sumLexLift_nonempty
lemma sumLexLift_nonempty :
    (sumLexLift f₁ f₂ g₁ g₂ a b).Nonempty ↔
      (∃ a₁ b₁, a = inl a₁ ∧ b = inl b₁ ∧ (f₁ a₁ b₁).Nonempty) ∨
        (∃ a₁ b₂, a = inl a₁ ∧ b = inr b₂ ∧ ((g₁ a₁ b₂).Nonempty ∨ (g₂ a₁ b₂).Nonempty)) ∨
          ∃ a₂ b₂, a = inr a₂ ∧ b = inr b₂ ∧ (f₂ a₂ b₂).Nonempty 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {γ₁ : Type u_5} {γ₂ : Type u_6} {f₁ : α₁ → β₁ → Finset γ₁} {f₂ : α₂ → β₂ → Finset γ₂} {g₁ : α₁ → β₂ → Finset γ₁} {g₂ : α₁ → β₂ → Finset γ₂} {a : α₁ ⊕ α₂} {b : β₁ ⊕ β₂}
Goal: (Finset.sumLexLift f₁ f₂ g₁ g₂ a b).Nonempty ↔
  (∃ a₁ b₁, a = Sum.inl a₁ ∧ b = Sum.inl b₁ ∧ (f₁ a₁ b₁).Nonempty) ∨
    (∃ a₁ b₂, a = Sum.inl a₁ ∧ b = Sum.inr b₂ ∧ ((g₁ a₁ b₂).Nonempty ∨ (g₂ a₁ b₂).Nonempty)) ∨
      ∃ a₂ b₂, a = Sum.inr a₂ ∧ b = Sum.inr b₂ ∧ (f₂ a₂ b₂).Nonempty
-- Sum.Icc_inl_inl
theorem Icc_inl_inl : Icc (inl a₁ : α ⊕ β) (inl a₂) = (Icc a₁ a₂).map Embedding.inl 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Icc (Sum.inl a₁) (Sum.inl a₂) = Finset.map Function.Embedding.inl (Finset.Icc a₁ a₂)
-- Sum.Ico_inl_inl
theorem Ico_inl_inl : Ico (inl a₁ : α ⊕ β) (inl a₂) = (Ico a₁ a₂).map Embedding.inl 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Ico (Sum.inl a₁) (Sum.inl a₂) = Finset.map Function.Embedding.inl (Finset.Ico a₁ a₂)
-- Sum.Ioc_inl_inl
theorem Ioc_inl_inl : Ioc (inl a₁ : α ⊕ β) (inl a₂) = (Ioc a₁ a₂).map Embedding.inl 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Ioc (Sum.inl a₁) (Sum.inl a₂) = Finset.map Function.Embedding.inl (Finset.Ioc a₁ a₂)
-- Sum.Ioo_inl_inl
theorem Ioo_inl_inl : Ioo (inl a₁ : α ⊕ β) (inl a₂) = (Ioo a₁ a₂).map Embedding.inl 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Ioo (Sum.inl a₁) (Sum.inl a₂) = Finset.map Function.Embedding.inl (Finset.Ioo a₁ a₂)
-- Sum.Icc_inl_inr
@[simp]
theorem Icc_inl_inr : Icc (inl a₁) (inr b₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ : α) (b₂ : β)
Goal: Finset.Icc (Sum.inl a₁) (Sum.inr b₂) = ∅
-- Sum.Ico_inl_inr
@[simp]
theorem Ico_inl_inr : Ico (inl a₁) (inr b₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ : α) (b₂ : β)
Goal: Finset.Ico (Sum.inl a₁) (Sum.inr b₂) = ∅
-- Sum.Ioc_inl_inr
@[simp]
theorem Ioc_inl_inr : Ioc (inl a₁) (inr b₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ : α) (b₂ : β)
Goal: Finset.Ioc (Sum.inl a₁) (Sum.inr b₂) = ∅
-- Sum.Ioo_inl_inr
@[simp]
theorem Ioo_inl_inr : Ioo (inl a₁) (inr b₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ : α) (b₂ : β)
Goal: Finset.Ioo (Sum.inl a₁) (Sum.inr b₂) = ∅
-- Sum.Icc_inr_inl
@[simp]
theorem Icc_inr_inl : Icc (inr b₁) (inl a₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₂ : α) (b₁ : β)
Goal: Finset.Icc (Sum.inr b₁) (Sum.inl a₂) = ∅
-- Sum.Ico_inr_inl
@[simp]
theorem Ico_inr_inl : Ico (inr b₁) (inl a₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₂ : α) (b₁ : β)
Goal: Finset.Ico (Sum.inr b₁) (Sum.inl a₂) = ∅
-- Sum.Ioc_inr_inl
@[simp]
theorem Ioc_inr_inl : Ioc (inr b₁) (inl a₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₂ : α) (b₁ : β)
Goal: Finset.Ioc (Sum.inr b₁) (Sum.inl a₂) = ∅
-- Sum.Ioo_inr_inl
@[simp]
theorem Ioo_inr_inl : Ioo (inr b₁) (inl a₂) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₂ : α) (b₁ : β)
Goal: Finset.Ioo (Sum.inr b₁) (Sum.inl a₂) = ∅
-- Sum.Icc_inr_inr
theorem Icc_inr_inr : Icc (inr b₁ : α ⊕ β) (inr b₂) = (Icc b₁ b₂).map Embedding.inr 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Icc (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Icc b₁ b₂)
-- Sum.Ico_inr_inr
theorem Ico_inr_inr : Ico (inr b₁ : α ⊕ β) (inr b₂) = (Ico b₁ b₂).map Embedding.inr 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Ico (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ico b₁ b₂)
-- Sum.Ioc_inr_inr
theorem Ioc_inr_inr : Ioc (inr b₁ : α ⊕ β) (inr b₂) = (Ioc b₁ b₂).map Embedding.inr 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Ioc (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioc b₁ b₂)
-- Sum.Ioo_inr_inr
theorem Ioo_inr_inr : Ioo (inr b₁ : α ⊕ β) (inr b₂) = (Ioo b₁ b₂).map Embedding.inr 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Ioo (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioo b₁ b₂)
-- Sum.Lex.Icc_inl_inl
lemma Icc_inl_inl :
    Icc (inlₗ a₁ : α ⊕ₗ β) (inlₗ a₂) = (Icc a₁ a₂).map (Embedding.inl.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Icc (Sum.inlₗ a₁) (Sum.inlₗ a₂) = Finset.map (Function.Embedding.inl.trans toLex.toEmbedding) (Finset.Icc a₁ a₂)
-- Sum.Lex.Ico_inl_inl
lemma Ico_inl_inl :
    Ico (inlₗ a₁ : α ⊕ₗ β) (inlₗ a₂) = (Ico a₁ a₂).map (Embedding.inl.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Ico (Sum.inlₗ a₁) (Sum.inlₗ a₂) = Finset.map (Function.Embedding.inl.trans toLex.toEmbedding) (Finset.Ico a₁ a₂)
-- Sum.Lex.Ioc_inl_inl
lemma Ioc_inl_inl :
    Ioc (inlₗ a₁ : α ⊕ₗ β) (inlₗ a₂) = (Ioc a₁ a₂).map (Embedding.inl.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Ioc (Sum.inlₗ a₁) (Sum.inlₗ a₂) = Finset.map (Function.Embedding.inl.trans toLex.toEmbedding) (Finset.Ioc a₁ a₂)
-- Sum.Lex.Ioo_inl_inl
lemma Ioo_inl_inl :
    Ioo (inlₗ a₁ : α ⊕ₗ β) (inlₗ a₂) = (Ioo a₁ a₂).map (Embedding.inl.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a₁ a₂ : α)
Goal: Finset.Ioo (Sum.inlₗ a₁) (Sum.inlₗ a₂) = Finset.map (Function.Embedding.inl.trans toLex.toEmbedding) (Finset.Ioo a₁ a₂)
-- Sum.Lex.Icc_inl_inr
@[simp]
lemma Icc_inl_inr : Icc (inlₗ a) (inrₗ b) = ((Ici a).disjSum (Iic b)).map toLex.toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Icc (Sum.inlₗ a) (Sum.inrₗ b) = Finset.map toLex.toEmbedding ((Finset.Ici a).disjSum (Finset.Iic b))
-- Sum.Lex.Ico_inl_inr
@[simp]
lemma Ico_inl_inr : Ico (inlₗ a) (inrₗ b) = ((Ici a).disjSum (Iio b)).map toLex.toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Ico (Sum.inlₗ a) (Sum.inrₗ b) = Finset.map toLex.toEmbedding ((Finset.Ici a).disjSum (Finset.Iio b))
-- Sum.Lex.Ioc_inl_inr
@[simp]
lemma Ioc_inl_inr : Ioc (inlₗ a) (inrₗ b) = ((Ioi a).disjSum (Iic b)).map toLex.toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Ioc (Sum.inlₗ a) (Sum.inrₗ b) = Finset.map toLex.toEmbedding ((Finset.Ioi a).disjSum (Finset.Iic b))
-- Sum.Lex.Ioo_inl_inr
@[simp]
lemma Ioo_inl_inr : Ioo (inlₗ a) (inrₗ b) = ((Ioi a).disjSum (Iio b)).map toLex.toEmbedding 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Ioo (Sum.inlₗ a) (Sum.inrₗ b) = Finset.map toLex.toEmbedding ((Finset.Ioi a).disjSum (Finset.Iio b))
-- Sum.Lex.Icc_inr_inl
@[simp]
lemma Icc_inr_inl : Icc (inrₗ b) (inlₗ a) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Icc (Sum.inrₗ b) (Sum.inlₗ a) = ∅
-- Sum.Lex.Ico_inr_inl
@[simp]
lemma Ico_inr_inl : Ico (inrₗ b) (inlₗ a) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Ico (Sum.inrₗ b) (Sum.inlₗ a) = ∅
-- Sum.Lex.Ioc_inr_inl
@[simp]
lemma Ioc_inr_inl : Ioc (inrₗ b) (inlₗ a) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Ioc (Sum.inrₗ b) (Sum.inlₗ a) = ∅
-- Sum.Lex.Ioo_inr_inl
@[simp]
lemma Ioo_inr_inl : Ioo (inrₗ b) (inlₗ a) = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (a : α) (b : β)
Goal: Finset.Ioo (Sum.inrₗ b) (Sum.inlₗ a) = ∅
-- Sum.Lex.Icc_inr_inr
lemma Icc_inr_inr :
    Icc (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Icc b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Icc (Sum.inrₗ b₁) (Sum.inrₗ b₂) = Finset.map (Function.Embedding.inr.trans toLex.toEmbedding) (Finset.Icc b₁ b₂)
-- Sum.Lex.Ico_inr_inr
lemma Ico_inr_inr :
    Ico (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Ico b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Ico (Sum.inrₗ b₁) (Sum.inrₗ b₂) = Finset.map (Function.Embedding.inr.trans toLex.toEmbedding) (Finset.Ico b₁ b₂)
-- Sum.Lex.Ioc_inr_inr
lemma Ioc_inr_inr :
    Ioc (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Ioc b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Ioc (Sum.inrₗ b₁) (Sum.inrₗ b₂) = Finset.map (Function.Embedding.inr.trans toLex.toEmbedding) (Finset.Ioc b₁ b₂)
-- Sum.Lex.Ioo_inr_inr
lemma Ioo_inr_inr :
    Ioo (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Ioo b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding) 
Arguments: {α : Type u_1} {β : Type u_2} [Preorder α] [Preorder β] [OrderTop α] [OrderBot β] [LocallyFiniteOrder α] [LocallyFiniteOrder β] (b₁ b₂ : β)
Goal: Finset.Ioo (Sum.inrₗ b₁) (Sum.inrₗ b₂) = Finset.map (Function.Embedding.inr.trans toLex.toEmbedding) (Finset.Ioo b₁ b₂)
-- Int.bodd_zero
@[simp]
theorem bodd_zero : bodd 0 = false 
Goal: Int.bodd 0 = false
-- Int.bodd_one
@[simp]
theorem bodd_one : bodd 1 = true 
Goal: Int.bodd 1 = true
-- Int.bodd_two
theorem bodd_two : bodd 2 = false 
Goal: Int.bodd 2 = false
-- Int.bodd_coe
@[simp, norm_cast]
theorem bodd_coe (n : ℕ) : Int.bodd n = Nat.bodd n 
Arguments: (n : ℕ)
Goal: (↑n).bodd = n.bodd
-- Int.bodd_subNatNat
@[simp]
theorem bodd_subNatNat (m n : ℕ) : bodd (subNatNat m n) = xor m.bodd n.bodd 
Arguments: (m n : ℕ)
Goal: (Int.subNatNat m n).bodd = xor m.bodd n.bodd
-- Int.bodd_negOfNat
@[simp]
theorem bodd_negOfNat (n : ℕ) : bodd (negOfNat n) = n.bodd 
Arguments: (n : ℕ)
Goal: (Int.negOfNat n).bodd = n.bodd
-- Int.bodd_neg
@[simp]
theorem bodd_neg (n : ℤ) : bodd (-n) = bodd n 
Arguments: (n : ℤ)
Goal: (-n).bodd = n.bodd
-- Int.bodd_add
@[simp]
theorem bodd_add (m n : ℤ) : bodd (m + n) = xor (bodd m) (bodd n) 
Arguments: (m n : ℤ)
Goal: (m + n).bodd = xor m.bodd n.bodd
-- Int.bodd_mul
@[simp]
theorem bodd_mul (m n : ℤ) : bodd (m * n) = (bodd m && bodd n) 
Arguments: (m n : ℤ)
Goal: (m * n).bodd = (m.bodd && n.bodd)
-- Int.bodd_add_div2
theorem bodd_add_div2 : ∀ n, cond (bodd n) 1 0 + 2 * div2 n = n
  
Arguments: (n : ℤ)
Goal: (bif n.bodd then 1 else 0) + 2 * n.div2 = n
-- Int.div2_val
theorem div2_val : ∀ n, div2 n = n / 2
  
Arguments: (n : ℤ)
Goal: n.div2 = n / 2
-- Int.bit_val
theorem bit_val (b n) : bit b n = 2 * n + cond b 1 0 
Arguments: (b : Bool) (n : ℤ)
Goal: Int.bit b n = 2 * n + bif b then 1 else 0
-- Int.bit_decomp
theorem bit_decomp (n : ℤ) : bit (bodd n) (div2 n) = n 
Arguments: (n : ℤ)
Goal: Int.bit n.bodd n.div2 = n
-- Int.bit_zero
@[simp]
theorem bit_zero : bit false 0 = 0 
Goal: Int.bit false 0 = 0
-- Int.bit_coe_nat
@[simp]
theorem bit_coe_nat (b) (n : ℕ) : bit b n = Nat.bit b n 
Arguments: (b : Bool) (n : ℕ)
Goal: Int.bit b ↑n = ↑(Nat.bit b n)
-- Int.bit_negSucc
@[simp]
theorem bit_negSucc (b) (n : ℕ) : bit b -[n+1] = -[Nat.bit (not b) n+1] 
Arguments: (b : Bool) (n : ℕ)
Goal: Int.bit b (Int.negSucc n) = Int.negSucc (Nat.bit (!b) n)
-- Int.bodd_bit
@[simp]
theorem bodd_bit (b n) : bodd (bit b n) = b 
Arguments: (b : Bool) (n : ℤ)
Goal: (Int.bit b n).bodd = b
-- Int.testBit_bit_zero
@[simp]
theorem testBit_bit_zero (b) : ∀ n, testBit (bit b n) 0 = b
  
Arguments: (b : Bool) (n : ℤ)
Goal: (Int.bit b n).testBit 0 = b
-- Int.testBit_bit_succ
@[simp]
theorem testBit_bit_succ (m b) : ∀ n, testBit (bit b n) (Nat.succ m) = testBit n m
  
Arguments: (m : ℕ) (b : Bool) (n : ℤ)
Goal: (Int.bit b n).testBit m.succ = n.testBit m
-- Int.bitwise_or
theorem bitwise_or : bitwise or = lor 
Goal: Int.bitwise or = Int.lor
-- Int.bitwise_and
theorem bitwise_and : bitwise and = land 
Goal: Int.bitwise and = Int.land
-- Int.bitwise_diff
theorem bitwise_diff : (bitwise fun a b => a && not b) = ldiff 
Goal: (Int.bitwise fun a b => a && !b) = Int.ldiff
-- Int.bitwise_xor
theorem bitwise_xor : bitwise xor = Int.xor 
Goal: Int.bitwise xor = Int.xor
-- Int.bitwise_bit
@[simp]
theorem bitwise_bit (f : Bool → Bool → Bool) (a m b n) :
    bitwise f (bit a m) (bit b n) = bit (f a b) (bitwise f m n) 
Arguments: (f : Bool → Bool → Bool) (a : Bool) (m : ℤ) (b : Bool) (n : ℤ)
Goal: Int.bitwise f (Int.bit a m) (Int.bit b n) = Int.bit (f a b) (Int.bitwise f m n)
-- Int.lor_bit
@[simp]
theorem lor_bit (a m b n) : lor (bit a m) (bit b n) = bit (a || b) (lor m n) 
Arguments: (a : Bool) (m : ℤ) (b : Bool) (n : ℤ)
Goal: (Int.bit a m).lor (Int.bit b n) = Int.bit (a || b) (m.lor n)
-- Int.land_bit
@[simp]
theorem land_bit (a m b n) : land (bit a m) (bit b n) = bit (a && b) (land m n) 
Arguments: (a : Bool) (m : ℤ) (b : Bool) (n : ℤ)
Goal: (Int.bit a m).land (Int.bit b n) = Int.bit (a && b) (m.land n)
-- Int.ldiff_bit
@[simp]
theorem ldiff_bit (a m b n) : ldiff (bit a m) (bit b n) = bit (a && not b) (ldiff m n) 
Arguments: (a : Bool) (m : ℤ) (b : Bool) (n : ℤ)
Goal: (Int.bit a m).ldiff (Int.bit b n) = Int.bit (a && !b) (m.ldiff n)
-- Int.lxor_bit
@[simp]
theorem lxor_bit (a m b n) : Int.xor (bit a m) (bit b n) = bit (xor a b) (Int.xor m n) 
Arguments: (a : Bool) (m : ℤ) (b : Bool) (n : ℤ)
Goal: (Int.bit a m).xor (Int.bit b n) = Int.bit (xor a b) (m.xor n)
-- Int.lnot_bit
@[simp]
theorem lnot_bit (b) : ∀ n, lnot (bit b n) = bit (not b) (lnot n)
  
Arguments: (b : Bool) (n : ℤ)
Goal: (Int.bit b n).lnot = Int.bit (!b) n.lnot
-- Int.testBit_bitwise
@[simp]
theorem testBit_bitwise (f : Bool → Bool → Bool) (m n k) :
    testBit (bitwise f m n) k = f (testBit m k) (testBit n k) 
Arguments: (f : Bool → Bool → Bool) (m n : ℤ) (k : ℕ)
Goal: (Int.bitwise f m n).testBit k = f (m.testBit k) (n.testBit k)
-- Int.testBit_lor
@[simp]
theorem testBit_lor (m n k) : testBit (lor m n) k = (testBit m k || testBit n k) 
Arguments: (m n : ℤ) (k : ℕ)
Goal: (m.lor n).testBit k = (m.testBit k || n.testBit k)
-- Int.testBit_land
@[simp]
theorem testBit_land (m n k) : testBit (land m n) k = (testBit m k && testBit n k) 
Arguments: (m n : ℤ) (k : ℕ)
Goal: (m.land n).testBit k = (m.testBit k && n.testBit k)
-- Int.testBit_ldiff
@[simp]
theorem testBit_ldiff (m n k) : testBit (ldiff m n) k = (testBit m k && not (testBit n k)) 
Arguments: (m n : ℤ) (k : ℕ)
Goal: (m.ldiff n).testBit k = (m.testBit k && !n.testBit k)
-- Int.testBit_lxor
@[simp]
theorem testBit_lxor (m n k) : testBit (Int.xor m n) k = xor (testBit m k) (testBit n k) 
Arguments: (m n : ℤ) (k : ℕ)
Goal: (m.xor n).testBit k = xor (m.testBit k) (n.testBit k)
-- Int.testBit_lnot
@[simp]
theorem testBit_lnot : ∀ n k, testBit (lnot n) k = not (testBit n k)
  
Arguments: (n : ℤ) (k : ℕ)
Goal: n.lnot.testBit k = !n.testBit k
-- Int.shiftLeft_neg
@[simp]
theorem shiftLeft_neg (m n : ℤ) : m <<< (-n) = m >>> n 
Arguments: (m n : ℤ)
Goal: m <<< (-n) = m >>> n
-- Int.shiftRight_neg
@[simp]
theorem shiftRight_neg (m n : ℤ) : m >>> (-n) = m <<< n 
Arguments: (m n : ℤ)
Goal: m >>> (-n) = m <<< n