l3lab/ntp-mathlib huggingface dataset:
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ ldiff 0 (pos n✝) = bif false && !true then pos n✝ else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ ldiff (pos n✝) 0 = bif true && !false then pos n✝ else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ ldiff (pos n✝) 0 = bif true && !false then pos n✝ else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ ldiff (pos m✝) (pos n✝) = PosNum.ldiff m✝ n✝

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ ldiff (pos m✝) (pos n✝) = PosNum.ldiff m✝ n✝

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case p11
α : Type u_1
⊢ PosNum.ldiff 1 1 = bif true && !true then 1 else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case p11
α : Type u_1
⊢ PosNum.ldiff 1 1 = bif true && !true then 1 else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case p1b
α : Type u_1
b✝ : Bool
n✝ : PosNum
⊢ PosNum.ldiff 1 (PosNum.bit b✝ n✝) = bit (true && !b✝) (bif false && !true then pos n✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case p1b
α : Type u_1
b✝ : Bool
n✝ : PosNum
⊢ PosNum.ldiff 1 (PosNum.bit b✝ n✝) = bit (true && !b✝) (bif false && !true then pos n✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit a✝ m✝) 1 = bit (a✝ && !true) (bif true && !false then pos m✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit a✝ m✝) 1 = bit (a✝ && !true) (bif true && !false then pos m✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝) = bit (a✝ && !b✝) (PosNum.ldiff m✝ n✝)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try 

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝) = bit (a✝ && !b✝) (PosNum.ldiff m✝ n✝)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case gff
α : Type u_1
⊢ (false && !false) = false

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case f00
α : Type u_1
⊢ ldiff 0 0 = 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ ldiff 0 (pos n✝) = bif false && !true then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ ldiff (pos n✝) 0 = bif true && !false then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ ldiff (pos m✝) (pos n✝) = PosNum.ldiff m✝ n✝

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p11
α : Type u_1
⊢ PosNum.ldiff 1 1 = bif true && !true then 1 else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.false
α : Type u_1
n✝ : PosNum
⊢ PosNum.ldiff 1 (PosNum.bit false n✝) = bit (true && !false) (bif false && !true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.true
α : Type u_1
n✝ : PosNum
⊢ PosNum.ldiff 1 (PosNum.bit true n✝) = bit (true && !true) (bif false && !true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.false
α : Type u_1
m✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit false m✝) 1 = bit (false && !true) (bif true && !false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.true
α : Type u_1
m✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit true m✝) 1 = bit (true && !true) (bif true && !false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit false m✝) (PosNum.bit false n✝) = bit (false && !false) (PosNum.ldiff m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit false m✝) (PosNum.bit true n✝) = bit (false && !true) (PosNum.ldiff m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit true m✝) (PosNum.bit false n✝) = bit (true && !false) (PosNum.ldiff m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_ldiff : ∀ m n : Num, (ldiff m n : ℕ) = Nat.ldiff m n := by
  apply castNum_eq_bitwise PosNum.ldiff <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.ldiff (PosNum.bit true m✝) (PosNum.bit true n✝) = bit (true && !true) (PosNum.ldiff m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  

Proof state:
α : Type u_1
⊢ ∀ (m n : Num), ↑(m ^^^ n) = ↑m ^^^ ↑n

Next tactic:
apply castNum_eq_bitwise PosNum.lxor
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case gff
α : Type u_1
⊢ (false != false) = false

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case f00
α : Type u_1
⊢ 0 ^^^ 0 = 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case f0n
α : Type u_1
⊢ ∀ (n : PosNum), 0 ^^^ pos n = bif false != true then pos n else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case fn0
α : Type u_1
⊢ ∀ (n : PosNum), pos n ^^^ 0 = bif true != false then pos n else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case fnn
α : Type u_1
⊢ ∀ (m n : PosNum), pos m ^^^ pos n = PosNum.lxor m n

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case p11
α : Type u_1
⊢ PosNum.lxor 1 1 = bif true != true then 1 else 0

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case p1b
α : Type u_1
⊢ ∀ (b : Bool) (n : PosNum), PosNum.lxor 1 (PosNum.bit b n) = bit (true != b) (bif false != true then pos n else 0)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case pb1
α : Type u_1
⊢ ∀ (a : Bool) (m : PosNum), PosNum.lxor (PosNum.bit a m) 1 = bit (a != true) (bif true != false then pos m else 0)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> 

Proof state:
case pbb
α : Type u_1
⊢ ∀ (a b : Bool) (m n : PosNum), PosNum.lxor (PosNum.bit a m) (PosNum.bit b n) = bit (a != b) (PosNum.lxor m n)

Next tactic:
intros
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case gff
α : Type u_1
⊢ (false != false) = false

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case gff
α : Type u_1
⊢ (false != false) = false

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case f00
α : Type u_1
⊢ 0 ^^^ 0 = 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case f00
α : Type u_1
⊢ 0 ^^^ 0 = 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 ^^^ pos n✝ = bif false != true then pos n✝ else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 ^^^ pos n✝ = bif false != true then pos n✝ else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ ^^^ 0 = bif true != false then pos n✝ else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ ^^^ 0 = bif true != false then pos n✝ else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ ^^^ pos n✝ = PosNum.lxor m✝ n✝

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ ^^^ pos n✝ = PosNum.lxor m✝ n✝

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case p11
α : Type u_1
⊢ PosNum.lxor 1 1 = bif true != true then 1 else 0

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case p11
α : Type u_1
⊢ PosNum.lxor 1 1 = bif true != true then 1 else 0

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case p1b
α : Type u_1
b✝ : Bool
n✝ : PosNum
⊢ PosNum.lxor 1 (PosNum.bit b✝ n✝) = bit (true != b✝) (bif false != true then pos n✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case p1b
α : Type u_1
b✝ : Bool
n✝ : PosNum
⊢ PosNum.lxor 1 (PosNum.bit b✝ n✝) = bit (true != b✝) (bif false != true then pos n✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ PosNum.lxor (PosNum.bit a✝ m✝) 1 = bit (a✝ != true) (bif true != false then pos m✝ else 0)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case pb1
α : Type u_1
a✝ : Bool
m✝ : PosNum
⊢ PosNum.lxor (PosNum.bit a✝ m✝) 1 = bit (a✝ != true) (bif true != false then pos m✝ else 0)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ PosNum.lxor (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝) = bit (a✝ != b✝) (PosNum.lxor m✝ n✝)

Next tactic:
try cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try 

Proof state:
case pbb
α : Type u_1
a✝ b✝ : Bool
m✝ n✝ : PosNum
⊢ PosNum.lxor (PosNum.bit a✝ m✝) (PosNum.bit b✝ n✝) = bit (a✝ != b✝) (PosNum.lxor m✝ n✝)

Next tactic:
cases_type* Bool
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case gff
α : Type u_1
⊢ (false != false) = false

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case f00
α : Type u_1
⊢ 0 ^^^ 0 = 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case f0n
α : Type u_1
n✝ : PosNum
⊢ 0 ^^^ pos n✝ = bif false != true then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case fn0
α : Type u_1
n✝ : PosNum
⊢ pos n✝ ^^^ 0 = bif true != false then pos n✝ else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case fnn
α : Type u_1
m✝ n✝ : PosNum
⊢ pos m✝ ^^^ pos n✝ = PosNum.lxor m✝ n✝

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p11
α : Type u_1
⊢ PosNum.lxor 1 1 = bif true != true then 1 else 0

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.false
α : Type u_1
n✝ : PosNum
⊢ PosNum.lxor 1 (PosNum.bit false n✝) = bit (true != false) (bif false != true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case p1b.true
α : Type u_1
n✝ : PosNum
⊢ PosNum.lxor 1 (PosNum.bit true n✝) = bit (true != true) (bif false != true then pos n✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.false
α : Type u_1
m✝ : PosNum
⊢ PosNum.lxor (PosNum.bit false m✝) 1 = bit (false != true) (bif true != false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pb1.true
α : Type u_1
m✝ : PosNum
⊢ PosNum.lxor (PosNum.bit true m✝) 1 = bit (true != true) (bif true != false then pos m✝ else 0)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.false
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.lxor (PosNum.bit false m✝) (PosNum.bit false n✝) = bit (false != false) (PosNum.lxor m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.false.true
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.lxor (PosNum.bit false m✝) (PosNum.bit true n✝) = bit (false != true) (PosNum.lxor m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.false
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.lxor (PosNum.bit true m✝) (PosNum.bit false n✝) = bit (true != false) (PosNum.lxor m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_xor : ∀ m n : Num, ↑(m ^^^ n) = (↑m ^^^ ↑n : ℕ) := by
  apply castNum_eq_bitwise PosNum.lxor <;> intros <;> (try cases_type* Bool) <;> 

Proof state:
case pbb.true.true
α : Type u_1
m✝ n✝ : PosNum
⊢ PosNum.lxor (PosNum.bit true m✝) (PosNum.bit true n✝) = bit (true != true) (PosNum.lxor m✝ n✝)

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  

Proof state:
α : Type u_1
m : Num
n : ℕ
⊢ ↑(m <<< n) = ↑m <<< n

Next tactic:
cases m
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> 

Proof state:
case zero
α : Type u_1
n : ℕ
⊢ ↑(zero <<< n) = ↑zero <<< n

Next tactic:
dsimp only [← shiftl_eq_shiftLeft, shiftl]
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> 

Proof state:
case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(pos a✝ <<< n) = ↑(pos a✝) <<< n

Next tactic:
dsimp only [← shiftl_eq_shiftLeft, shiftl]
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
  · 

Proof state:
case zero
α : Type u_1
n : ℕ
⊢ ↑0 = ↑zero <<< n

Next tactic:
symm
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
  · symm
    

Proof state:
case zero
α : Type u_1
n : ℕ
⊢ ↑zero <<< n = ↑0

Next tactic:
apply Nat.zero_shiftLeft
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
  · symm
    apply Nat.zero_shiftLeft
  

Proof state:
case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(pos (a✝ <<< n)) = ↑(pos a✝) <<< n

Next tactic:
simp only [cast_pos]
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
  · symm
    apply Nat.zero_shiftLeft
  simp only [cast_pos]
  

Proof state:
case pos
α : Type u_1
n : ℕ
a✝ : PosNum
⊢ ↑(a✝ <<< n) = ↑a✝ <<< n

Next tactic:
induction' n with n IH
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
  · symm
    apply Nat.zero_shiftLeft
  simp only [cast_pos]
  induction' n with n IH
  · 

Proof state:
case pos.zero
α : Type u_1
a✝ : PosNum
⊢ ↑(a✝ <<< Nat.zero) = ↑a✝ <<< Nat.zero

Next tactic:
rfl
@[simp, norm_cast]
theorem castNum_shiftLeft (m : Num) (n : Nat) : ↑(m <<< n) = (m : ℕ) <<< (n : ℕ) := by
  cases m <;> dsimp only [← shiftl_eq_shiftLeft, shiftl]
  · symm
    apply Nat.zero_shiftLeft
  simp only [cast_pos]
  induction' n with n IH
  · rfl
  

Proof state:
case pos.succ
α : Type u_1
a✝ : PosNum
n : ℕ
IH : ↑(a✝ <<< n) = ↑a✝ <<< n
⊢ ↑(a✝ <<< Nat.succ n) = ↑a✝ <<< Nat.succ n

Next tactic:
simp [PosNum.shiftl_succ_eq_bit0_shiftl, Nat.shiftLeft_succ, IH,
        Nat.bit0_val, pow_succ, ← mul_assoc, mul_comm,
        -shiftl_eq_shiftLeft, -PosNum.shiftl_eq_shiftLeft, shiftl]
@[simp, norm_cast]

theorem castNum_shiftRight (m : Num) (n : Nat) : ↑(m >>> n) = (m : ℕ) >>> (n : ℕ)  := by
  

Proof state:
α : Type u_1
m : Num
n : ℕ
⊢ ↑(m >>> n) = ↑m >>> n

Next tactic:
cases' m with m
@[simp, norm_cast]

theorem castNum_shiftRight (m : Num) (n : Nat) : ↑(m >>> n) = (m : ℕ) >>> (n : ℕ)  := by
  cases' m with m <;> 

Proof state:
case zero
α : Type u_1
n : ℕ
⊢ ↑(zero >>> n) = ↑zero >>> n

Next tactic:
dsimp only [← shiftr_eq_shiftRight, shiftr]
@[simp, norm_cast]

theorem castNum_shiftRight (m : Num) (n : Nat) : ↑(m >>> n) = (m : ℕ) >>> (n : ℕ)  := by
  cases' m with m <;> 

Proof state:
case pos
α : Type u_1
n : ℕ
m : PosNum
⊢ ↑(pos m >>> n) = ↑(pos m) >>> n

Next tactic:
dsimp only [← shiftr_eq_shiftRight, shiftr]