l3lab/ntp-mathlib huggingface dataset:
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise or -[m+1] -[n+1] = lor -[m+1] -[n+1]

Next tactic:
try {rfl}
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise or -[m+1] -[n+1] = lor -[m+1] -[n+1]

Next tactic:
{rfl}
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise or -[m+1] -[n+1] = lor -[m+1] -[n+1]

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> 

Proof state:
case h.h.ofNat.negSucc
m n : ℕ
⊢ bitwise or (ofNat m) -[n+1] = lor (ofNat m) -[n+1]

Next tactic:
simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> 

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ bitwise or -[m+1] (ofNat n) = lor -[m+1] (ofNat n)

Next tactic:
simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise or -[m+1] -[n+1] = lor -[m+1] -[n+1]

Next tactic:
simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · 

Proof state:
case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(x || !y)) m n = Nat.bitwise (fun a b => a && !b) n m

Next tactic:
rw [Nat.bitwise_swap, Function.swap]
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    

Proof state:
case h.h.ofNat.negSucc
m n : ℕ
⊢ Nat.bitwise (fun y x => !(x || !y)) n m = Nat.bitwise (fun a b => a && !b) n m

Next tactic:
congr
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    

Proof state:
case h.h.ofNat.negSucc.e_f
m n : ℕ
⊢ (fun y x => !(x || !y)) = fun a b => a && !b

Next tactic:
funext x y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    

Proof state:
case h.h.ofNat.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(y || !x)) = (x && !y)

Next tactic:
cases x
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> 

Proof state:
case h.h.ofNat.negSucc.e_f.h.h.false
m n : ℕ
y : Bool
⊢ (!(y || !false)) = (false && !y)

Next tactic:
cases y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> 

Proof state:
case h.h.ofNat.negSucc.e_f.h.h.true
m n : ℕ
y : Bool
⊢ (!(y || !true)) = (true && !y)

Next tactic:
cases y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.ofNat.negSucc.e_f.h.h.false.false
m n : ℕ
⊢ (!(false || !false)) = (false && !false)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.ofNat.negSucc.e_f.h.h.false.true
m n : ℕ
⊢ (!(true || !false)) = (false && !true)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.ofNat.negSucc.e_f.h.h.true.false
m n : ℕ
⊢ (!(false || !true)) = (true && !false)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.ofNat.negSucc.e_f.h.h.true.true
m n : ℕ
⊢ (!(true || !true)) = (true && !true)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · 

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || y)) m n = Nat.bitwise (fun a b => a && !b) m n

Next tactic:
congr
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    

Proof state:
case h.h.negSucc.ofNat.e_f
m n : ℕ
⊢ (fun x y => !(!x || y)) = fun a b => a && !b

Next tactic:
funext x y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    

Proof state:
case h.h.negSucc.ofNat.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || y)) = (x && !y)

Next tactic:
cases x
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> 

Proof state:
case h.h.negSucc.ofNat.e_f.h.h.false
m n : ℕ
y : Bool
⊢ (!(!false || y)) = (false && !y)

Next tactic:
cases y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> 

Proof state:
case h.h.negSucc.ofNat.e_f.h.h.true
m n : ℕ
y : Bool
⊢ (!(!true || y)) = (true && !y)

Next tactic:
cases y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.ofNat.e_f.h.h.false.false
m n : ℕ
⊢ (!(!false || false)) = (false && !false)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.ofNat.e_f.h.h.false.true
m n : ℕ
⊢ (!(!false || true)) = (false && !true)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.ofNat.e_f.h.h.true.false
m n : ℕ
⊢ (!(!true || false)) = (true && !false)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.ofNat.e_f.h.h.true.true
m n : ℕ
⊢ (!(!true || true)) = (true && !true)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ Nat.bitwise (fun x y => !(!x || !y)) m n = m &&& n

Next tactic:
congr
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    

Proof state:
case h.h.negSucc.negSucc.e_f
m n : ℕ
⊢ (fun x y => !(!x || !y)) = and

Next tactic:
funext x y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    

Proof state:
case h.h.negSucc.negSucc.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!(!x || !y)) = (x && y)

Next tactic:
cases x
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> 

Proof state:
case h.h.negSucc.negSucc.e_f.h.h.false
m n : ℕ
y : Bool
⊢ (!(!false || !y)) = (false && y)

Next tactic:
cases y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> 

Proof state:
case h.h.negSucc.negSucc.e_f.h.h.true
m n : ℕ
y : Bool
⊢ (!(!true || !y)) = (true && y)

Next tactic:
cases y
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.negSucc.e_f.h.h.false.false
m n : ℕ
⊢ (!(!false || !false)) = (false && false)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.negSucc.e_f.h.h.false.true
m n : ℕ
⊢ (!(!false || !true)) = (false && true)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.negSucc.e_f.h.h.true.false
m n : ℕ
⊢ (!(!true || !false)) = (true && false)

Next tactic:
rfl
theorem bitwise_or : bitwise or = lor := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true, cond_true, lor, Nat.ldiff,
      negSucc.injEq, Bool.true_or, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> rfl
  · congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.negSucc.e_f.h.h.true.true
m n : ℕ
⊢ (!(!true || !true)) = (true && true)

Next tactic:
rfl
theorem bitwise_and : bitwise and = land := by
  

Proof state:
⊢ bitwise and = land

Next tactic:
funext m n
theorem bitwise_and : bitwise and = land := by
  funext m n
  

Proof state:
case h.h
m n : ℤ
⊢ bitwise and m n = land m n

Next tactic:
cases' m with m m
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> 

Proof state:
case h.h.ofNat
n : ℤ
m : ℕ
⊢ bitwise and (ofNat m) n = land (ofNat m) n

Next tactic:
cases' n with n n
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> 

Proof state:
case h.h.negSucc
n : ℤ
m : ℕ
⊢ bitwise and -[m+1] n = land -[m+1] n

Next tactic:
cases' n with n n
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> 

Proof state:
case h.h.ofNat.ofNat
m n : ℕ
⊢ bitwise and (ofNat m) (ofNat n) = land (ofNat m) (ofNat n)

Next tactic:
try {rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try 

Proof state:
case h.h.ofNat.ofNat
m n : ℕ
⊢ bitwise and (ofNat m) (ofNat n) = land (ofNat m) (ofNat n)

Next tactic:
{rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {

Proof state:
case h.h.ofNat.ofNat
m n : ℕ
⊢ bitwise and (ofNat m) (ofNat n) = land (ofNat m) (ofNat n)

Next tactic:
rfl
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> 

Proof state:
case h.h.ofNat.negSucc
m n : ℕ
⊢ bitwise and (ofNat m) -[n+1] = land (ofNat m) -[n+1]

Next tactic:
try {rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try 

Proof state:
case h.h.ofNat.negSucc
m n : ℕ
⊢ bitwise and (ofNat m) -[n+1] = land (ofNat m) -[n+1]

Next tactic:
{rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {

Proof state:
case h.h.ofNat.negSucc
m n : ℕ
⊢ bitwise and (ofNat m) -[n+1] = land (ofNat m) -[n+1]

Next tactic:
rfl
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> 

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ bitwise and -[m+1] (ofNat n) = land -[m+1] (ofNat n)

Next tactic:
try {rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try 

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ bitwise and -[m+1] (ofNat n) = land -[m+1] (ofNat n)

Next tactic:
{rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ bitwise and -[m+1] (ofNat n) = land -[m+1] (ofNat n)

Next tactic:
rfl
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise and -[m+1] -[n+1] = land -[m+1] -[n+1]

Next tactic:
try {rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise and -[m+1] -[n+1] = land -[m+1] -[n+1]

Next tactic:
{rfl}
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise and -[m+1] -[n+1] = land -[m+1] -[n+1]

Next tactic:
rfl
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> 

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ bitwise and -[m+1] (ofNat n) = land -[m+1] (ofNat n)

Next tactic:
simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> 

Proof state:
case h.h.negSucc.negSucc
m n : ℕ
⊢ bitwise and -[m+1] -[n+1] = land -[m+1] -[n+1]

Next tactic:
simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · 

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise (fun x y => !x && y) m n) = land -[m+1] (ofNat n)

Next tactic:
rw [Nat.bitwise_swap, Function.swap]
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    

Proof state:
case h.h.negSucc.ofNat
m n : ℕ
⊢ ↑(Nat.bitwise (fun y x => !x && y) n m) = land -[m+1] (ofNat n)

Next tactic:
congr
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    

Proof state:
case h.h.negSucc.ofNat.e_a.e_f
m n : ℕ
⊢ (fun y x => !x && y) = fun a b => a && !b

Next tactic:
funext x y
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    

Proof state:
case h.h.negSucc.ofNat.e_a.e_f.h.h
m n : ℕ
x y : Bool
⊢ (!y && x) = (x && !y)

Next tactic:
cases x
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> 

Proof state:
case h.h.negSucc.ofNat.e_a.e_f.h.h.false
m n : ℕ
y : Bool
⊢ (!y && false) = (false && !y)

Next tactic:
cases y
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> 

Proof state:
case h.h.negSucc.ofNat.e_a.e_f.h.h.true
m n : ℕ
y : Bool
⊢ (!y && true) = (true && !y)

Next tactic:
cases y
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.ofNat.e_a.e_f.h.h.false.false
m n : ℕ
⊢ (!false && false) = (false && !false)

Next tactic:
rfl
theorem bitwise_and : bitwise and = land := by
  funext m n
  cases' m with m m <;> cases' n with n n <;> try {rfl}
    <;> simp only [bitwise, natBitwise, Bool.not_false, Bool.or_true,
      cond_false, cond_true, lor, Nat.ldiff, Bool.and_true, negSucc.injEq,
      Bool.and_false, Nat.land]
  · rw [Nat.bitwise_swap, Function.swap]
    congr
    funext x y
    cases x <;> cases y <;> 

Proof state:
case h.h.negSucc.ofNat.e_a.e_f.h.h.false.true
m n : ℕ
⊢ (!true && false) = (false && !true)

Next tactic:
rfl