File: .lake/packages/lean4/src/lean/Init/SimpLemmas.lean

full_name: of_eq_true
code: theorem of_eq_true (h : p = True) : p 
goal: p

full_name: of_eq_false
code: theorem of_eq_false (h : p = False) : ¬ p 
goal: ¬p

full_name: eq_true
code: theorem eq_true (h : p) : p = True 
goal: p = True

full_name: eq_false
code: theorem eq_false (h : ¬ p) : p = False 
goal: p = False

full_name: eq_false'
code: theorem eq_false' (h : p → False) : p = False 
goal: p = False

full_name: eq_true_of_decide
code: theorem eq_true_of_decide {p : Prop} [Decidable p] (h : decide p = true) : p = True 
goal: p = True

full_name: eq_false_of_decide
code: theorem eq_false_of_decide {p : Prop} {_ : Decidable p} (h : decide p = false) : p = False 
goal: ∀ {x : Decidable p}, decide p = false → p = False

full_name: eq_self
code: @[simp] theorem eq_self (a : α) : (a = a) = True 
goal: (a = a) = True

full_name: implies_congr
code: theorem implies_congr {p₁ p₂ : Sort u} {q₁ q₂ : Sort v} (h₁ : p₁ = p₂) (h₂ : q₁ = q₂) : (p₁ → q₁) = (p₂ → q₂) 
goal: (p₁ → q₁) = (p₂ → q₂)

full_name: iff_congr
code: theorem iff_congr {p₁ p₂ q₁ q₂ : Prop} (h₁ : p₁ ↔ p₂) (h₂ : q₁ ↔ q₂) : (p₁ ↔ q₁) ↔ (p₂ ↔ q₂) 
goal: (p₁ ↔ q₁) ↔ (p₂ ↔ q₂)

full_name: implies_dep_congr_ctx
code: theorem implies_dep_congr_ctx {p₁ p₂ q₁ : Prop} (h₁ : p₁ = p₂) {q₂ : p₂ → Prop} (h₂ : (h : p₂) → q₁ = q₂ h) : (p₁ → q₁) = ((h : p₂) → q₂ h) 
goal: (p₁ → q₁) = ∀ (h : p₂), q₂ h

full_name: implies_congr_ctx
code: theorem implies_congr_ctx {p₁ p₂ q₁ q₂ : Prop} (h₁ : p₁ = p₂) (h₂ : p₂ → q₁ = q₂) : (p₁ → q₁) = (p₂ → q₂) 
goal: (p₁ → q₁) = (p₂ → q₂)

full_name: forall_congr
code: theorem forall_congr {α : Sort u} {p q : α → Prop} (h : ∀ a, p a = q a) : (∀ a, p a) = (∀ a, q a) 
goal: (∀ (a : α), p a) = ∀ (a : α), q a

full_name: forall_prop_domain_congr
code: theorem forall_prop_domain_congr {p₁ p₂ : Prop} {q₁ : p₁ → Prop} {q₂ : p₂ → Prop}
    (h₁ : p₁ = p₂)
    (h₂ : ∀ a : p₂, q₁ (h₁.substr a) = q₂ a)
    : (∀ a : p₁, q₁ a) = (∀ a : p₂, q₂ a) 
goal: (∀ (a : p₁), q₁ a) = ∀ (a : p₂), q₂ a

full_name: let_congr
code: theorem let_congr {α : Sort u} {β : Sort v} {a a' : α} {b b' : α → β}
    (h₁ : a = a') (h₂ : ∀ x, b x = b' x) : (let x := a; b x) = (let x := a'; b' x) 
goal: (let x := a;
  b x) =
  let x := a';
  b' x

full_name: let_val_congr
code: theorem let_val_congr {α : Sort u} {β : Sort v} {a a' : α}
    (b : α → β) (h : a = a') : (let x := a; b x) = (let x := a'; b x) 
goal: (let x := a;
  b x) =
  let x := a';
  b x

full_name: let_body_congr
code: theorem let_body_congr {α : Sort u} {β : α → Sort v} {b b' : (a : α) → β a}
    (a : α) (h : ∀ x, b x = b' x) : (let x := a; b x) = (let x := a; b' x) 
goal: (let x := a;
  b x) =
  let x := a;
  b' x

full_name: ite_congr
code: @[congr]
theorem ite_congr {x y u v : α} {s : Decidable b} [Decidable c]
    (h₁ : b = c) (h₂ : c → x = u) (h₃ : ¬ c → y = v) : ite b x y = ite c u v 
goal: ite b x y = ite c u v

full_name: Eq.mpr_prop
code: theorem Eq.mpr_prop {p q : Prop} (h₁ : p = q) (h₂ : q)  : p  
goal: p

full_name: Eq.mpr_not
code: theorem Eq.mpr_not  {p q : Prop} (h₁ : p = q) (h₂ : ¬q) : ¬p 
goal: ¬p

full_name: dite_congr
code: @[congr]
theorem dite_congr {_ : Decidable b} [Decidable c]
    {x : b → α} {u : c → α} {y : ¬b → α} {v : ¬c → α}
    (h₁ : b = c)
    (h₂ : (h : c)  → x (h₁.mpr_prop h) = u h)
    (h₃ : (h : ¬c) → y (h₁.mpr_not h)  = v h) :
    dite b x y = dite c u v 
goal: ∀ {x : Decidable b} [inst : Decidable c] {x_1 : b → α} {u : c → α} {y : ¬b → α} {v : ¬c → α} (h₁ : b = c),
  (∀ (h : c), x_1 ⋯ = u h) → (∀ (h : ¬c), y ⋯ = v h) → dite b x_1 y = dite c u v

full_name: ne_eq
code: @[simp] theorem ne_eq (a b : α) : (a ≠ b) = ¬(a = b) 
goal: (a ≠ b) = ¬a = b

full_name: ite_true
code: @[simp] theorem ite_true (a b : α) : (if True then a else b) = a 
goal: ite True a b = a

full_name: ite_false
code: @[simp] theorem ite_false (a b : α) : (if False then a else b) = b 
goal: ite False a b = b

full_name: dite_true
code: @[simp] theorem dite_true {α : Sort u} {t : True → α} {e : ¬ True → α} : (dite True t e) = t True.intro 
goal: dite True t e = t True.intro

full_name: dite_false
code: @[simp] theorem dite_false {α : Sort u} {t : False → α} {e : ¬ False → α} : (dite False t e) = e not_false 
goal: dite False t e = e not_false

full_name: ite_cond_eq_true
code: theorem ite_cond_eq_true {α : Sort u} {c : Prop} {_ : Decidable c} (a b : α) (h : c = True) : (if c then a else b) = a 
goal: ∀ {x : Decidable c} (a b : α), c = True → ite c a b = a

full_name: ite_cond_eq_false
code: theorem ite_cond_eq_false {α : Sort u} {c : Prop} {_ : Decidable c} (a b : α) (h : c = False) : (if c then a else b) = b 
goal: ∀ {x : Decidable c} (a b : α), c = False → ite c a b = b

full_name: dite_cond_eq_true
code: theorem dite_cond_eq_true {α : Sort u} {c : Prop} {_ : Decidable c} {t : c → α} {e : ¬ c → α} (h : c = True) : (dite c t e) = t (of_eq_true h) 
goal: ∀ {x : Decidable c} {t : c → α} {e : ¬c → α} (h : c = True), dite c t e = t ⋯

full_name: dite_cond_eq_false
code: theorem dite_cond_eq_false {α : Sort u} {c : Prop} {_ : Decidable c} {t : c → α} {e : ¬ c → α} (h : c = False) : (dite c t e) = e (of_eq_false h) 
goal: ∀ {x : Decidable c} {t : c → α} {e : ¬c → α} (h : c = False), dite c t e = e ⋯

full_name: ite_self
code: @[simp] theorem ite_self {α : Sort u} {c : Prop} {d : Decidable c} (a : α) : ite c a a = a 
goal: ite c a a = a

full_name: and_true
code: @[simp] theorem and_true (p : Prop) : (p ∧ True) = p 
goal: (p ∧ True) = p

full_name: true_and
code: @[simp] theorem true_and (p : Prop) : (True ∧ p) = p 
goal: (True ∧ p) = p

full_name: «instLawfulIdentityAndTrue_.lake»
code: instance : Std.LawfulIdentity And True 
goal: Std.LawfulIdentity And True

full_name: and_false
code: @[simp] theorem and_false (p : Prop) : (p ∧ False) = False 
goal: (p ∧ False) = False

full_name: false_and
code: @[simp] theorem false_and (p : Prop) : (False ∧ p) = False 
goal: (False ∧ p) = False

full_name: and_self
code: @[simp] theorem and_self (p : Prop) : (p ∧ p) = p 
goal: (p ∧ p) = p

full_name: «instIdempotentOpAnd_.lake»
code: instance : Std.IdempotentOp And 
goal: Std.IdempotentOp And

full_name: and_not_self
code: @[simp] theorem and_not_self : ¬(a ∧ ¬a) 
goal: ¬(a ∧ ¬a)

full_name: not_and_self
code: @[simp] theorem not_and_self : ¬(¬a ∧ a) 
goal: ¬(¬a ∧ a)

full_name: and_imp
code: @[simp] theorem and_imp : (a ∧ b → c) ↔ (a → b → c) 
goal: a ∧ b → c ↔ a → b → c

full_name: not_and
code: @[simp] theorem not_and : ¬(a ∧ b) ↔ (a → ¬b) 
goal: ¬(a ∧ b) ↔ a → ¬b

full_name: or_self
code: @[simp] theorem or_self (p : Prop) : (p ∨ p) = p 
goal: (p ∨ p) = p

full_name: «instIdempotentOpOr_.lake»
code: instance : Std.IdempotentOp Or 
goal: Std.IdempotentOp Or

full_name: or_true
code: @[simp] theorem or_true (p : Prop) : (p ∨ True) = True 
goal: (p ∨ True) = True

full_name: true_or
code: @[simp] theorem true_or (p : Prop) : (True ∨ p) = True 
goal: (True ∨ p) = True

full_name: or_false
code: @[simp] theorem or_false (p : Prop) : (p ∨ False) = p 
goal: (p ∨ False) = p

full_name: false_or
code: @[simp] theorem false_or (p : Prop) : (False ∨ p) = p 
goal: (False ∨ p) = p

full_name: «instLawfulIdentityOrFalse_.lake»
code: instance : Std.LawfulIdentity Or False 
goal: Std.LawfulIdentity Or False

full_name: iff_self
code: @[simp] theorem iff_self (p : Prop) : (p ↔ p) = True 
goal: (p ↔ p) = True

full_name: iff_true
code: @[simp] theorem iff_true (p : Prop) : (p ↔ True) = p 
goal: (p ↔ True) = p

full_name: true_iff
code: @[simp] theorem true_iff (p : Prop) : (True ↔ p) = p 
goal: (True ↔ p) = p

full_name: iff_false
code: @[simp] theorem iff_false (p : Prop) : (p ↔ False) = ¬p 
goal: (p ↔ False) = ¬p

full_name: false_iff
code: @[simp] theorem false_iff (p : Prop) : (False ↔ p) = ¬p 
goal: (False ↔ p) = ¬p

full_name: false_implies
code: @[simp] theorem false_implies (p : Prop) : (False → p) = True 
goal: (False → p) = True

full_name: implies_true
code: @[simp] theorem implies_true (α : Sort u) : (α → True) = True 
goal: (α → True) = True

full_name: true_implies
code: @[simp] theorem true_implies (p : Prop) : (True → p) = p 
goal: (True → p) = p

full_name: not_false_eq_true
code: @[simp] theorem not_false_eq_true : (¬ False) = True 
goal: (¬False) = True

full_name: not_true_eq_false
code: @[simp] theorem not_true_eq_false : (¬ True) = False 
goal: (¬True) = False

full_name: not_iff_self
code: @[simp] theorem not_iff_self : ¬(¬a ↔ a) 
goal: ¬(¬a ↔ a)

full_name: and_congr_right
code: theorem and_congr_right (h : a → (b ↔ c)) : a ∧ b ↔ a ∧ c 
goal: a ∧ b ↔ a ∧ c

full_name: and_congr_left
code: theorem and_congr_left (h : c → (a ↔ b)) : a ∧ c ↔ b ∧ c 
goal: a ∧ c ↔ b ∧ c

full_name: and_assoc
code: theorem and_assoc : (a ∧ b) ∧ c ↔ a ∧ (b ∧ c) 
goal: (a ∧ b) ∧ c ↔ a ∧ b ∧ c

full_name: «instAssociativeAnd_.lake»
code: instance : Std.Associative And 
goal: Std.Associative And

full_name: and_self_left
code: @[simp] theorem and_self_left  : a ∧ (a ∧ b) ↔ a ∧ b 
goal: a ∧ a ∧ b ↔ a ∧ b

full_name: and_self_right
code: @[simp] theorem and_self_right : (a ∧ b) ∧ b ↔ a ∧ b 
goal: (a ∧ b) ∧ b ↔ a ∧ b

full_name: and_congr_right_iff
code: @[simp] theorem and_congr_right_iff : (a ∧ b ↔ a ∧ c) ↔ (a → (b ↔ c)) 
goal: (a ∧ b ↔ a ∧ c) ↔ a → (b ↔ c)

full_name: and_congr_left_iff
code: @[simp] theorem and_congr_left_iff : (a ∧ c ↔ b ∧ c) ↔ c → (a ↔ b) 
goal: (a ∧ c ↔ b ∧ c) ↔ c → (a ↔ b)

full_name: and_iff_left_of_imp
code: theorem and_iff_left_of_imp  (h : a → b) : (a ∧ b) ↔ a 
goal: a ∧ b ↔ a

full_name: and_iff_right_of_imp
code: theorem and_iff_right_of_imp (h : b → a) : (a ∧ b) ↔ b 
goal: a ∧ b ↔ b

full_name: and_iff_left_iff_imp
code: @[simp] theorem and_iff_left_iff_imp  : ((a ∧ b) ↔ a) ↔ (a → b) 
goal: (a ∧ b ↔ a) ↔ a → b

full_name: and_iff_right_iff_imp
code: @[simp] theorem and_iff_right_iff_imp : ((a ∧ b) ↔ b) ↔ (b → a) 
goal: (a ∧ b ↔ b) ↔ b → a

full_name: iff_self_and
code: @[simp] theorem iff_self_and : (p ↔ p ∧ q) ↔ (p → q) 
goal: (p ↔ p ∧ q) ↔ p → q

full_name: iff_and_self
code: @[simp] theorem iff_and_self : (p ↔ q ∧ p) ↔ (p → q) 
goal: (p ↔ q ∧ p) ↔ p → q

full_name: Or.imp
code: theorem Or.imp (f : a → c) (g : b → d) (h : a ∨ b) : c ∨ d 
goal: c ∨ d

full_name: Or.imp_left
code: theorem Or.imp_left (f : a → b) : a ∨ c → b ∨ c 
goal: a ∨ c → b ∨ c

full_name: Or.imp_right
code: theorem Or.imp_right (f : b → c) : a ∨ b → a ∨ c 
goal: a ∨ b → a ∨ c

full_name: or_assoc
code: theorem or_assoc : (a ∨ b) ∨ c ↔ a ∨ (b ∨ c) 
goal: (a ∨ b) ∨ c ↔ a ∨ b ∨ c

full_name: «instAssociativeOr_.lake»
code: instance : Std.Associative Or 
goal: Std.Associative Or

full_name: or_self_left
code: @[simp] theorem or_self_left  : a ∨ (a ∨ b) ↔ a ∨ b 
goal: a ∨ a ∨ b ↔ a ∨ b

full_name: or_self_right
code: @[simp] theorem or_self_right : (a ∨ b) ∨ b ↔ a ∨ b 
goal: (a ∨ b) ∨ b ↔ a ∨ b

full_name: or_iff_right_of_imp
code: theorem or_iff_right_of_imp (ha : a → b) : (a ∨ b) ↔ b 
goal: a ∨ b ↔ b

full_name: or_iff_left_of_imp
code: theorem or_iff_left_of_imp  (hb : b → a) : (a ∨ b) ↔ a  
goal: a ∨ b ↔ a

full_name: or_iff_left_iff_imp
code: @[simp] theorem or_iff_left_iff_imp  : (a ∨ b ↔ a) ↔ (b → a) 
goal: (a ∨ b ↔ a) ↔ b → a

full_name: or_iff_right_iff_imp
code: @[simp] theorem or_iff_right_iff_imp : (a ∨ b ↔ b) ↔ (a → b) 
goal: (a ∨ b ↔ b) ↔ a → b

full_name: iff_self_or
code: @[simp] theorem iff_self_or (a b : Prop) : (a ↔ a ∨ b) ↔ (b → a) 
goal: (a ↔ a ∨ b) ↔ b → a

full_name: iff_or_self
code: @[simp] theorem iff_or_self (a b : Prop) : (b ↔ a ∨ b) ↔ (a → b) 
goal: (b ↔ a ∨ b) ↔ a → b

full_name: Bool.or_false
code: @[simp] theorem Bool.or_false (b : Bool) : (b || false) = b  
goal: (b || false) = b

full_name: Bool.or_true
code: @[simp] theorem Bool.or_true (b : Bool) : (b || true) = true 
goal: (b || true) = true

full_name: Bool.false_or
code: @[simp] theorem Bool.false_or (b : Bool) : (false || b) = b  
goal: (false || b) = b

full_name: «instLawfulIdentityBoolOrFalse_.lake»
code: instance : Std.LawfulIdentity (· || ·) false 
goal: Std.LawfulIdentity (fun x x_1 => x || x_1) false

full_name: Bool.true_or
code: @[simp] theorem Bool.true_or (b : Bool) : (true || b) = true 
goal: (true || b) = true

full_name: Bool.or_self
code: @[simp] theorem Bool.or_self (b : Bool) : (b || b) = b       
goal: (b || b) = b

full_name: «instIdempotentOpBoolOr_.lake»
code: instance : Std.IdempotentOp (· || ·) 
goal: Std.IdempotentOp fun x x_1 => x || x_1

full_name: Bool.or_eq_true
code: @[simp] theorem Bool.or_eq_true (a b : Bool) : ((a || b) = true) = (a = true ∨ b = true) 
goal: ((a || b) = true) = (a = true ∨ b = true)

full_name: Bool.and_false
code: @[simp] theorem Bool.and_false (b : Bool) : (b && false) = false 
goal: (b && false) = false

full_name: Bool.and_true
code: @[simp] theorem Bool.and_true (b : Bool) : (b && true) = b       
goal: (b && true) = b

full_name: Bool.false_and
code: @[simp] theorem Bool.false_and (b : Bool) : (false && b) = false 
goal: (false && b) = false

full_name: Bool.true_and
code: @[simp] theorem Bool.true_and (b : Bool) : (true && b) = b       
goal: (true && b) = b

full_name: «instLawfulIdentityBoolAndTrue_.lake»
code: instance : Std.LawfulIdentity (· && ·) true 
goal: Std.LawfulIdentity (fun x x_1 => x && x_1) true

full_name: Bool.and_self
code: @[simp] theorem Bool.and_self (b : Bool) : (b && b) = b          
goal: (b && b) = b

full_name: «instIdempotentOpBoolAnd_.lake»
code: instance : Std.IdempotentOp (· && ·) 
goal: Std.IdempotentOp fun x x_1 => x && x_1

full_name: Bool.and_eq_true
code: @[simp] theorem Bool.and_eq_true (a b : Bool) : ((a && b) = true) = (a = true ∧ b = true) 
goal: ((a && b) = true) = (a = true ∧ b = true)

full_name: Bool.and_assoc
code: theorem Bool.and_assoc (a b c : Bool) : (a && b && c) = (a && (b && c)) 
goal: (a && b && c) = (a && (b && c))

full_name: «instAssociativeBoolAnd_.lake»
code: instance : Std.Associative (· && ·) 
goal: Std.Associative fun x x_1 => x && x_1

full_name: Bool.or_assoc
code: theorem Bool.or_assoc (a b c : Bool) : (a || b || c) = (a || (b || c)) 
goal: (a || b || c) = (a || (b || c))

full_name: «instAssociativeBoolOr_.lake»
code: instance : Std.Associative (· || ·) 
goal: Std.Associative fun x x_1 => x || x_1

full_name: Bool.not_not
code: @[simp] theorem Bool.not_not (b : Bool) : (!!b) = b 
goal: (!!b) = b

full_name: Bool.not_true
code: @[simp] theorem Bool.not_true  : (!true) = false 
goal: (!true) = false

full_name: Bool.not_false
code: @[simp] theorem Bool.not_false : (!false) = true 
goal: (!false) = true

full_name: Bool.not_beq_true
code: @[simp] theorem Bool.not_beq_true  (b : Bool) : (!(b == true)) = (b == false) 
goal: (!b == true) = (b == false)

full_name: Bool.not_beq_false
code: @[simp] theorem Bool.not_beq_false (b : Bool) : (!(b == false)) = (b == true) 
goal: (!b == false) = (b == true)

full_name: Bool.not_eq_true'
code: @[simp] theorem Bool.not_eq_true'  (b : Bool) : ((!b) = true) = (b = false) 
goal: ((!b) = true) = (b = false)

full_name: Bool.not_eq_false'
code: @[simp] theorem Bool.not_eq_false' (b : Bool) : ((!b) = false) = (b = true) 
goal: ((!b) = false) = (b = true)

full_name: Bool.beq_to_eq
code: @[simp] theorem Bool.beq_to_eq (a b : Bool) :
  (a == b) = (a = b) 
goal: ((a == b) = true) = (a = b)

full_name: Bool.not_beq_to_not_eq
code: @[simp] theorem Bool.not_beq_to_not_eq (a b : Bool) :
  (!(a == b)) = ¬(a = b) 
goal: ((!a == b) = true) = ¬a = b

full_name: Bool.not_eq_true
code: @[simp] theorem Bool.not_eq_true (b : Bool) : (¬(b = true)) = (b = false) 
goal: (¬b = true) = (b = false)

full_name: Bool.not_eq_false
code: @[simp] theorem Bool.not_eq_false (b : Bool) : (¬(b = false)) = (b = true) 
goal: (¬b = false) = (b = true)

full_name: decide_eq_true_eq
code: @[simp] theorem decide_eq_true_eq [Decidable p] : (decide p = true) = p 
goal: (decide p = true) = p

full_name: decide_not
code: @[simp] theorem decide_not [g : Decidable p] [h : Decidable (Not p)] : decide (Not p) = !(decide p) 
goal: (decide ¬p) = !decide p

full_name: not_decide_eq_true
code: @[simp] theorem not_decide_eq_true [h : Decidable p] : ((!decide p) = true) = ¬ p 
goal: ((!decide p) = true) = ¬p

full_name: heq_eq_eq
code: @[simp] theorem heq_eq_eq (a b : α) : HEq a b = (a = b) 
goal: HEq a b = (a = b)

full_name: cond_true
code: @[simp] theorem cond_true (a b : α) : cond true a b = a 
goal: (bif true then a else b) = a

full_name: cond_false
code: @[simp] theorem cond_false (a b : α) : cond false a b = b 
goal: (bif false then a else b) = b

full_name: beq_self_eq_true
code: @[simp] theorem beq_self_eq_true [BEq α] [LawfulBEq α] (a : α) : (a == a) = true 
goal: (a == a) = true

full_name: beq_self_eq_true'
code: @[simp] theorem beq_self_eq_true' [DecidableEq α] (a : α) : (a == a) = true 
goal: (a == a) = true

full_name: bne_self_eq_false
code: @[simp] theorem bne_self_eq_false [BEq α] [LawfulBEq α] (a : α) : (a != a) = false 
goal: (a != a) = false

full_name: bne_self_eq_false'
code: @[simp] theorem bne_self_eq_false' [DecidableEq α] (a : α) : (a != a) = false 
goal: (a != a) = false

full_name: decide_False
code: @[simp] theorem decide_False : decide False = false 
goal: decide False = false

full_name: decide_True
code: @[simp] theorem decide_True  : decide True  = true 
goal: decide True = true

full_name: bne_iff_ne
code: @[simp] theorem bne_iff_ne [BEq α] [LawfulBEq α] (a b : α) : a != b ↔ a ≠ b 
goal: (a != b) = true ↔ a ≠ b

full_name: beq_eq_false_iff_ne
code: @[simp] theorem beq_eq_false_iff_ne [BEq α] [LawfulBEq α]
    (a b : α) : (a == b) = false ↔ a ≠ b 
goal: (a == b) = false ↔ a ≠ b

full_name: bne_eq_false_iff_eq
code: @[simp] theorem bne_eq_false_iff_eq [BEq α] [LawfulBEq α] (a b : α) :
    (a != b) = false ↔ a = b 
goal: (a != b) = false ↔ a = b

full_name: Nat.le_zero_eq
code: @[simp] theorem Nat.le_zero_eq (a : Nat) : (a ≤ 0) = (a = 0) 
goal: (a ≤ 0) = (a = 0)