File: .lake/packages/batteries/Batteries/Logic.lean

full_name: «instDecidablePredComp_.lake»
code: instance {f : α → β} [DecidablePred p] : DecidablePred (p ∘ f) 
goal: DecidablePred (p ∘ f)

full_name: Function.id_def
code: theorem Function.id_def : @id α = fun x => x 
goal: id = fun x => x

full_name: heq_iff_eq
code: theorem heq_iff_eq : HEq a b ↔ a = b 
goal: ∀ {α : Sort u_1} {a b : α}, HEq a b ↔ a = b

full_name: eq_rec_constant
code: @[simp] theorem eq_rec_constant {α : Sort _} {a a' : α} {β : Sort _} (y : β) (h : a = a') :
    (@Eq.rec α a (fun α _ => β) y a' h) = y 
goal: h ▸ y = y

full_name: congrArg₂
code: theorem congrArg₂ (f : α → β → γ) {x x' : α} {y y' : β}
    (hx : x = x') (hy : y = y') : f x y = f x' y' 
goal: f x y = f x' y'

full_name: congrFun₂
code: theorem congrFun₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
    {f g : ∀ a b, γ a b} (h : f = g) (a : α) (b : β a) :
    f a b = g a b 
goal: f a b = g a b

full_name: congrFun₃
code: theorem congrFun₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
      {f g : ∀ a b c, δ a b c} (h : f = g) (a : α) (b : β a) (c : γ a b) :
    f a b c = g a b c 
goal: f a b c = g a b c

full_name: funext₂
code: theorem funext₂ {β : α → Sort _} {γ : ∀ a, β a → Sort _}
    {f g : ∀ a b, γ a b} (h : ∀ a b, f a b = g a b) : f = g 
goal: f = g

full_name: funext₃
code: theorem funext₃ {β : α → Sort _} {γ : ∀ a, β a → Sort _} {δ : ∀ a b, γ a b → Sort _}
    {f g : ∀ a b c, δ a b c} (h : ∀ a b c, f a b c = g a b c) : f = g 
goal: f = g

full_name: Function.funext_iff
code: theorem Function.funext_iff {β : α → Sort u} {f₁ f₂ : ∀ x : α, β x} : f₁ = f₂ ↔ ∀ a, f₁ a = f₂ a 
goal: f₁ = f₂ ↔ ∀ (a : α), f₁ a = f₂ a

full_name: ne_of_apply_ne
code: theorem ne_of_apply_ne {α β : Sort _} (f : α → β) {x y : α} : f x ≠ f y → x ≠ y 
goal: f x ≠ f y → x ≠ y

full_name: Eq.congr
code: protected theorem Eq.congr (h₁ : x₁ = y₁) (h₂ : x₂ = y₂) : x₁ = x₂ ↔ y₁ = y₂ 
goal: ∀ {α : Sort u_1} {x₁ y₁ x₂ y₂ : α}, x₁ = y₁ → x₂ = y₂ → (x₁ = x₂ ↔ y₁ = y₂)

full_name: Eq.congr_left
code: theorem Eq.congr_left {x y z : α} (h : x = y) : x = z ↔ y = z 
goal: x = z ↔ y = z

full_name: Eq.congr_right
code: theorem Eq.congr_right {x y z : α} (h : x = y) : z = x ↔ z = y 
goal: z = x ↔ z = y

full_name: heq_of_cast_eq
code: theorem heq_of_cast_eq : ∀ (e : α = β) (_ : cast e a = a'), HEq a a'
  
goal: cast e a = a' → HEq a a'

full_name: cast_eq_iff_heq
code: theorem cast_eq_iff_heq : cast e a = a' ↔ HEq a a' 
goal: ∀ {a a_1 : Sort u_1} {e : a = a_1} {a_2 : a} {a' : a_1}, cast e a_2 = a' ↔ HEq a_2 a'

full_name: eqRec_eq_cast
code: theorem eqRec_eq_cast {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
    @Eq.rec α a motive x a' e = cast (e ▸ rfl) x 
goal: e ▸ x = cast ⋯ x

full_name: eqRec_heq_self
code: theorem eqRec_heq_self {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') :
    HEq (@Eq.rec α a motive x a' e) x 
goal: HEq (e ▸ x) x

full_name: eqRec_heq_iff_heq
code: @[simp]
theorem eqRec_heq_iff_heq {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') {β : Sort _} (y : β) :
    HEq (@Eq.rec α a motive x a' e) y ↔ HEq x y 
goal: HEq (e ▸ x) y ↔ HEq x y

full_name: heq_eqRec_iff_heq
code: @[simp]
theorem heq_eqRec_iff_heq {α : Sort _} {a : α} {motive : (a' : α) → a = a' → Sort _}
    (x : motive a (rfl : a = a)) {a' : α} (e : a = a') {β : Sort _} (y : β) :
    HEq y (@Eq.rec α a motive x a' e) ↔ HEq y x 
goal: HEq y (e ▸ x) ↔ HEq y x

full_name: ne_of_mem_of_not_mem
code: theorem ne_of_mem_of_not_mem (h : a ∈ s) : b ∉ s → a ≠ b 
goal: ¬b ∈ s → a ≠ b

full_name: ne_of_mem_of_not_mem'
code: theorem ne_of_mem_of_not_mem' (h : a ∈ s) : a ∉ t → s ≠ t 
goal: ¬a ∈ t → s ≠ t

full_name: not_nonempty_empty
code: @[simp] theorem not_nonempty_empty  : ¬Nonempty Empty 
goal: ¬Nonempty Empty

full_name: not_nonempty_pempty
code: @[simp] theorem not_nonempty_pempty : ¬Nonempty PEmpty 
goal: ¬Nonempty PEmpty

full_name: eq_iff_true_of_subsingleton
code: theorem eq_iff_true_of_subsingleton [Subsingleton α] (x y : α) : x = y ↔ True 
goal: x = y ↔ True

full_name: subsingleton_of_forall_eq
code: /-- If all points are equal to a given point `x`, then `α` is a subsingleton. -/
theorem subsingleton_of_forall_eq (x : α) (h : ∀ y, y = x) : Subsingleton α 
goal: Subsingleton α

full_name: subsingleton_iff_forall_eq
code: theorem subsingleton_iff_forall_eq (x : α) : Subsingleton α ↔ ∀ y, y = x 
goal: Subsingleton α ↔ ∀ (y : α), y = x

full_name: congr_eqRec
code: theorem congr_eqRec {β : α → Sort _} (f : (x : α) → β x → γ) (h : x = x') (y : β x) :
  f x' (Eq.rec y h) = f x y 
goal: f x' (h ▸ y) = f x y