url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
---|---|---|---|---|---|---|---|---|
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply congrArg _ (Nat.div_eq_of_lt hc) | case a.hβ.a.h.a.hβ
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ n + c / b = n
case a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b n + 1 β€ log b (b * n + c) | case a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b n + 1 β€ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply le_trans | case a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b n + 1 β€ log b (b * n + c) | case a.a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b n + 1 β€ ?a.bβ
case a.a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ ?a.bβ β€ log b (b * n + c)
case a.b
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ β |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | rw [β Nat.log_mul hb hn] | case a.a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b n + 1 β€ ?a.bβ
case a.a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ ?a.bβ β€ log b (b * n + c)
case a.b
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ β | case a.a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b (b * n) β€ log b (b * n + c) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply Nat.log_mono_right | case a.a
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ log b (b * n) β€ log b (b * n + c) | case a.a.h
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ b * n β€ b * n + c |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.log_mul_add | [206, 1] | [223, 21] | apply le_add_right | case a.a.h
b n c : β
hb : 1 < b
hn : 1 β€ n
hc : c < b
β’ b * n β€ b * n + c | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | refine binaryRec' (n := n) ?hz ?hi | n : β
β’ size n β€ log 2 n + 1 | case hz
n : β
β’ size 0 β€ log 2 0 + 1
case hi
n : β
β’ β (b : Bool) (n : β), (n = 0 β b = true) β size n β€ log 2 n + 1 β size (bit b n) β€ log 2 (bit b n) + 1 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | exact zero_le _ | case hz
n : β
β’ size 0 β€ log 2 0 + 1
case hi
n : β
β’ β (b : Bool) (n : β), (n = 0 β b = true) β size n β€ log 2 n + 1 β size (bit b n) β€ log 2 (bit b n) + 1 | case hi
n : β
β’ β (b : Bool) (n : β), (n = 0 β b = true) β size n β€ log 2 n + 1 β size (bit b n) β€ log 2 (bit b n) + 1 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | intro b n hb ih | case hi
n : β
β’ β (b : Bool) (n : β), (n = 0 β b = true) β size n β€ log 2 n + 1 β size (bit b n) β€ log 2 (bit b n) + 1 | case hi
nβ : β
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ log 2 n + 1
β’ size (bit b n) β€ log 2 (bit b n) + 1 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | cases n | case hi
nβ : β
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ log 2 n + 1
β’ size (bit b n) β€ log 2 (bit b n) + 1 | case hi.zero
n : β
b : Bool
hb : zero = 0 β b = true
ih : size zero β€ log 2 zero + 1
β’ size (bit b zero) β€ log 2 (bit b zero) + 1
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ size (bit b (succ nβ)) β€ log 2 (bit b (succ nβ)) + 1 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | cases b <;> simp | case hi.zero
n : β
b : Bool
hb : zero = 0 β b = true
ih : size zero β€ log 2 zero + 1
β’ size (bit b zero) β€ log 2 (bit b zero) + 1
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ size (bit b (succ nβ)) β€ log 2 (bit b (succ nβ)) + 1 | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ size (bit b (succ nβ)) β€ log 2 (bit b (succ nβ)) + 1 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | rw [size_bit, bit_val, Nat.log_mul_add] | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ size (bit b (succ nβ)) β€ log 2 (bit b (succ nβ)) + 1 | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ succ (size (succ nβ)) β€ log 2 (succ nβ) + 1 + 1
case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | apply Nat.succ_le_succ ih | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ succ (size (succ nβ)) β€ log 2 (succ nβ) + 1 + 1
case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 | case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | apply one_lt_two | case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 | case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | apply Nat.succ_le_succ (zero_le _) | case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 | case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | cases b <;> simp | case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_succ_log | [225, 1] | [236, 19] | cases b <;> simp | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) β€ log 2 (succ nβ) + 1
β’ bit b (succ nβ) β 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | refine binaryRec' (n := n) rfl ?hi | n : β
β’ size n - 1 = log 2 n | case hi
n : β
β’ β (b : Bool) (n : β), (n = 0 β b = true) β size n - 1 = log 2 n β size (bit b n) - 1 = log 2 (bit b n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | intro b n hb ih | case hi
n : β
β’ β (b : Bool) (n : β), (n = 0 β b = true) β size n - 1 = log 2 n β size (bit b n) - 1 = log 2 (bit b n) | case hi
nβ : β
b : Bool
n : β
hb : n = 0 β b = true
ih : size n - 1 = log 2 n
β’ size (bit b n) - 1 = log 2 (bit b n) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | cases n | case hi
nβ : β
b : Bool
n : β
hb : n = 0 β b = true
ih : size n - 1 = log 2 n
β’ size (bit b n) - 1 = log 2 (bit b n) | case hi.zero
n : β
b : Bool
hb : zero = 0 β b = true
ih : size zero - 1 = log 2 zero
β’ size (bit b zero) - 1 = log 2 (bit b zero)
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ size (bit b (succ nβ)) - 1 = log 2 (bit b (succ nβ)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | cases b <;> rfl | case hi.zero
n : β
b : Bool
hb : zero = 0 β b = true
ih : size zero - 1 = log 2 zero
β’ size (bit b zero) - 1 = log 2 (bit b zero)
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ size (bit b (succ nβ)) - 1 = log 2 (bit b (succ nβ)) | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ size (bit b (succ nβ)) - 1 = log 2 (bit b (succ nβ)) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | rw [size_bit, bit_val, Nat.log_mul_add, Nat.succ_eq_add_one, Nat.add_sub_cancel, β ih, Nat.sub_add_cancel] | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ size (bit b (succ nβ)) - 1 = log 2 (bit b (succ nβ)) | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ size (succ nβ)
case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | exact tsub_add_cancel_iff_le.mp rfl | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ size (succ nβ)
case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 | case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | exact one_lt_two | case hi.succ.hb
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 < 2
case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 | case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | exact Nat.succ_le_succ (Nat.zero_le _) | case hi.succ.hn
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ 1 β€ succ nβ
case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 | case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | { cases b <;> simp } | case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2
case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | { simp } | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | cases b <;> simp | case hi.succ.hc
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ (bif b then 1 else 0) < 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.pred_size_eq_log | [238, 1] | [248, 11] | simp | case hi.succ
n : β
b : Bool
nβ : β
hb : succ nβ = 0 β b = true
ih : size (succ nβ) - 1 = log 2 (succ nβ)
β’ bit b (succ nβ) β 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_succ_eq_succ_log_succ | [250, 1] | [252, 38] | rw [β Nat.pred_size_eq_log, Nat.sub_add_cancel] | n : β
β’ size (n + 1) = log 2 (n + 1) + 1 | n : β
β’ 1 β€ size (n + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_succ_eq_succ_log_succ | [250, 1] | [252, 38] | exact tsub_add_cancel_iff_le.mp rfl | n : β
β’ 1 β€ size (n + 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod2_succ_eq_one | [254, 9] | [257, 65] | cases n using binaryRec with
| z => simp
| f b _ _ => cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | n : β
β’ (n + 1) % 2 = 1 β n % 2 = 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod2_succ_eq_one | [254, 9] | [257, 65] | simp | case z
β’ (0 + 1) % 2 = 1 β 0 % 2 = 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod2_succ_eq_one | [254, 9] | [257, 65] | cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | case f
b : Bool
nβ : β
aβ : bit b nβ = nβ β ((bit b nβ + 1) % 2 = 1 β bit b nβ % 2 = 0)
β’ (bit b nβ + 1) % 2 = 1 β bit b nβ % 2 = 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod2_succ_eq_zero | [259, 9] | [262, 65] | cases n using binaryRec with
| z => simp
| f b _ _ => cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | n : β
β’ (n + 1) % 2 = 0 β n % 2 = 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod2_succ_eq_zero | [259, 9] | [262, 65] | simp | case z
β’ (0 + 1) % 2 = 0 β 0 % 2 = 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.mod2_succ_eq_zero | [259, 9] | [262, 65] | cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | case f
b : Bool
nβ : β
aβ : bit b nβ = nβ β ((bit b nβ + 1) % 2 = 0 β bit b nβ % 2 = 1)
β’ (bit b nβ + 1) % 2 = 0 β bit b nβ % 2 = 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.bnot_mod2_eq_zero | [264, 9] | [267, 65] | cases n using binaryRec with
| z => simp
| f b _ _ => cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | n : β
β’ (!decide (n % 2 = 0)) = decide (n % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.bnot_mod2_eq_zero | [264, 9] | [267, 65] | simp | case z
β’ (!decide (0 % 2 = 0)) = decide (0 % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.bnot_mod2_eq_zero | [264, 9] | [267, 65] | cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | case f
b : Bool
nβ : β
aβ : bit b nβ = nβ β (!decide (bit b nβ % 2 = 0)) = decide (bit b nβ % 2 = 1)
β’ (!decide (bit b nβ % 2 = 0)) = decide (bit b nβ % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.toNat_decide_mod2 | [269, 9] | [272, 65] | cases n using binaryRec with
| z => simp
| f b _ _ => cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | n : β
β’ Bool.toNat (decide (n % 2 = 0)) = (n + 1) % 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.toNat_decide_mod2 | [269, 9] | [272, 65] | simp | case z
β’ Bool.toNat (decide (0 % 2 = 0)) = (0 + 1) % 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.toNat_decide_mod2 | [269, 9] | [272, 65] | cases b <;> simp [β Nat.two_mul, Nat.mul_add_mod] | case f
b : Bool
nβ : β
aβ : bit b nβ = nβ β Bool.toNat (decide (bit b nβ % 2 = 0)) = (bit b nβ + 1) % 2
β’ Bool.toNat (decide (bit b nβ % 2 = 0)) = (bit b nβ + 1) % 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [274, 9] | [281, 85] | cases n using binaryRec with
| z => simp
| f b _ _ =>
cases m using binaryRec with
| z => cases b <;> simp [β Nat.two_mul]
| f c _ _ =>
cases b <;> cases c <;> simp [β Nat.two_mul, Nat.mul_add_mod, β Nat.add_assoc] | n m : β
β’ Bool.xor (decide (n % 2 = 0)) (decide (m % 2 = 0)) = decide ((n + m) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [274, 9] | [281, 85] | simp | case z
m : β
β’ Bool.xor (decide (0 % 2 = 0)) (decide (m % 2 = 0)) = decide ((0 + m) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [274, 9] | [281, 85] | cases m using binaryRec with
| z => cases b <;> simp [β Nat.two_mul]
| f c _ _ =>
cases b <;> cases c <;> simp [β Nat.two_mul, Nat.mul_add_mod, β Nat.add_assoc] | case f
m : β
b : Bool
nβ : β
aβ : bit b nβ = nβ β Bool.xor (decide (bit b nβ % 2 = 0)) (decide (m % 2 = 0)) = decide ((bit b nβ + m) % 2 = 1)
β’ Bool.xor (decide (bit b nβ % 2 = 0)) (decide (m % 2 = 0)) = decide ((bit b nβ + m) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [274, 9] | [281, 85] | cases b <;> simp [β Nat.two_mul] | case f.z
b : Bool
nβ : β
aβ : bit b nβ = nβ β Bool.xor (decide (bit b nβ % 2 = 0)) (decide (0 % 2 = 0)) = decide ((bit b nβ + 0) % 2 = 1)
β’ Bool.xor (decide (bit b nβ % 2 = 0)) (decide (0 % 2 = 0)) = decide ((bit b nβ + 0) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [274, 9] | [281, 85] | cases b <;> cases c <;> simp [β Nat.two_mul, Nat.mul_add_mod, β Nat.add_assoc] | case f.f
b : Bool
nβΒΉ : β
c : Bool
nβ : β
aβΒΉ :
bit b nβΒΉ = nβΒΉ β
Bool.xor (decide (bit b nβΒΉ % 2 = 0)) (decide (bit c nβ % 2 = 0)) = decide ((bit b nβΒΉ + bit c nβ) % 2 = 1)
aβ :
bit c nβ = nβ β
Bool.xor (decide (bit b nβΒΉ % 2 = 0)) (decide (bit c nβ % 2 = 0)) = decide ((bit b nβΒΉ + bit c nβ) % 2 = 1)
β’ Bool.xor (decide (bit b nβΒΉ % 2 = 0)) (decide (bit c nβ % 2 = 0)) = decide ((bit b nβΒΉ + bit c nβ) % 2 = 1) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [283, 9] | [290, 85] | cases m using binaryRec with
| z => simp
| f b _ _ =>
cases n using binaryRec with
| z => cases b <;> simp [β Nat.two_mul]
| f c _ _ =>
cases b <;> cases c <;> simp [β Nat.two_mul, Nat.mul_add_mod, β Nat.add_assoc] | n m : β
β’ Bool.xor (decide (n % 2 = 0)) (decide (m % 2 = 1)) = decide ((n + m) % 2 = 0) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [283, 9] | [290, 85] | simp | case z
n : β
β’ Bool.xor (decide (n % 2 = 0)) (decide (0 % 2 = 1)) = decide ((n + 0) % 2 = 0) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [283, 9] | [290, 85] | cases n using binaryRec with
| z => cases b <;> simp [β Nat.two_mul]
| f c _ _ =>
cases b <;> cases c <;> simp [β Nat.two_mul, Nat.mul_add_mod, β Nat.add_assoc] | case f
n : β
b : Bool
nβ : β
aβ : bit b nβ = nβ β Bool.xor (decide (n % 2 = 0)) (decide (bit b nβ % 2 = 1)) = decide ((n + bit b nβ) % 2 = 0)
β’ Bool.xor (decide (n % 2 = 0)) (decide (bit b nβ % 2 = 1)) = decide ((n + bit b nβ) % 2 = 0) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [283, 9] | [290, 85] | cases b <;> simp [β Nat.two_mul] | case f.z
b : Bool
nβ : β
aβ : bit b nβ = nβ β Bool.xor (decide (0 % 2 = 0)) (decide (bit b nβ % 2 = 1)) = decide ((0 + bit b nβ) % 2 = 0)
β’ Bool.xor (decide (0 % 2 = 0)) (decide (bit b nβ % 2 = 1)) = decide ((0 + bit b nβ) % 2 = 0) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.xor_mod2ββ | [283, 9] | [290, 85] | cases b <;> cases c <;> simp [β Nat.two_mul, Nat.mul_add_mod, β Nat.add_assoc] | case f.f
b : Bool
nβΒΉ : β
c : Bool
nβ : β
aβΒΉ :
bit b nβΒΉ = nβΒΉ β
Bool.xor (decide (bit c nβ % 2 = 0)) (decide (bit b nβΒΉ % 2 = 1)) = decide ((bit c nβ + bit b nβΒΉ) % 2 = 0)
aβ :
bit c nβ = nβ β
Bool.xor (decide (bit c nβ % 2 = 0)) (decide (bit b nβΒΉ % 2 = 1)) = decide ((bit c nβ + bit b nβΒΉ) % 2 = 0)
β’ Bool.xor (decide (bit c nβ % 2 = 0)) (decide (bit b nβΒΉ % 2 = 1)) = decide ((bit c nβ + bit b nβΒΉ) % 2 = 0) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.div_mod2 | [292, 9] | [295, 70] | induction n using Nat.binaryRec' with
| z => rfl
| f b _ _ _ => cases b <;> simp [bit_val, mul_add_div, mul_add_mod] | n : β
β’ n / 2 + n % 2 = (n + 1) / 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.div_mod2 | [292, 9] | [295, 70] | rfl | case z
β’ 0 / 2 + 0 % 2 = (0 + 1) / 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.div_mod2 | [292, 9] | [295, 70] | cases b <;> simp [bit_val, mul_add_div, mul_add_mod] | case f
b : Bool
nβ : β
aβΒΉ : nβ = 0 β b = true
aβ : nβ / 2 + nβ % 2 = (nβ + 1) / 2
β’ bit b nβ / 2 + bit b nβ % 2 = (bit b nβ + 1) / 2 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | intro n | C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
β’ (n : β) β C n | C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
n : β
β’ C n |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | cases n using Nat.binaryRec' with
| z => exact z
| f b n hb =>
cases b with
| true => simpa [β Nat.two_mul] using o _
| false =>
match n with
| 0 => exact absurd (hb rfl) Bool.noConfusion
| n+1 => simpa [β Nat.add_assoc, Nat.add_right_comm _ 1, β Nat.two_mul] using e _ | C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
n : β
β’ C n | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | exact z | case z
C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
β’ C 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | cases b with
| true => simpa [β Nat.two_mul] using o _
| false =>
match n with
| 0 => exact absurd (hb rfl) Bool.noConfusion
| n+1 => simpa [β Nat.add_assoc, Nat.add_right_comm _ 1, β Nat.two_mul] using e _ | case f
C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
b : Bool
n : β
hb : n = 0 β b = true
aβ : bit b n = n β C (bit b n)
β’ C (bit b n) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | simpa [β Nat.two_mul] using o _ | case f.true
C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
n : β
hb : n = 0 β true = true
aβ : bit true n = n β C (bit true n)
β’ C (bit true n) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | match n with
| 0 => exact absurd (hb rfl) Bool.noConfusion
| n+1 => simpa [β Nat.add_assoc, Nat.add_right_comm _ 1, β Nat.two_mul] using e _ | case f.false
C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
n : β
hb : n = 0 β false = true
aβ : bit false n = n β C (bit false n)
β’ C (bit false n) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | exact absurd (hb rfl) Bool.noConfusion | C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
n : β
hb : 0 = 0 β false = true
aβ : bit false 0 = 0 β C (bit false 0)
β’ C (bit false 0) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.parityZeroCases | [298, 1] | [308, 88] | simpa [β Nat.add_assoc, Nat.add_right_comm _ 1, β Nat.two_mul] using e _ | C : β β Sort u
z : C 0
o : (n : β) β C (2 * n + 1)
e : (n : β) β C (2 * n + 2)
nβ n : β
hb : n + 1 = 0 β false = true
aβ : bit false (n + 1) = n + 1 β C (bit false (n + 1))
β’ C (bit false (n + 1)) | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | induction n using Nat.binaryRec' with
| z => exact le_refl _
| f b n hb ih =>
rw [size_bit]
cases b
simp
apply Nat.add_le_add (c := 1) ih
{ cases n
exact absurd (hb rfl) Bool.noConfusion
exact Nat.succ_le_succ (Nat.zero_le _) }
simp
apply Nat.succ_le_succ
apply le_trans
apply ih
apply le_add_left
cases b
simpa using Ξ» h β¦ absurd (hb h) Bool.noConfusion
simp | n : β
β’ size n β€ n | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | exact le_refl _ | case z
β’ size 0 β€ 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | rw [size_bit] | case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ size (bit b n) β€ bit b n | case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ succ (size n) β€ bit b n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | cases b | case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ succ (size n) β€ bit b n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ succ (size n) β€ bit false n
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | simp | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ succ (size n) β€ bit false n
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ succ (size n) β€ n + n
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | apply Nat.add_le_add (c := 1) ih | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ succ (size n) β€ n + n
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ 1 β€ n
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | { cases n
exact absurd (hb rfl) Bool.noConfusion
exact Nat.succ_le_succ (Nat.zero_le _) } | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ 1 β€ n
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | simp | case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ bit true n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ n + n + 1
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | apply Nat.succ_le_succ | case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ succ (size n) β€ n + n + 1
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.true.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ size n β€ n + n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | apply le_trans | case f.true.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ size n β€ n + n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.true.a.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ size n β€ ?f.true.a.b
case f.true.a.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ ?f.true.a.b β€ n + n
case f.true.a.b
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ β
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | apply ih | case f.true.a.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ size n β€ ?f.true.a.b
case f.true.a.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ ?f.true.a.b β€ n + n
case f.true.a.b
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ β
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.true.a.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ n β€ n + n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | apply le_add_left | case f.true.a.a
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ n β€ n + n
case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | cases b | case f
b : Bool
n : β
hb : n = 0 β b = true
ih : size n β€ n
β’ bit b n β 0 | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ bit false n β 0
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ bit true n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | simpa using Ξ» h β¦ absurd (hb h) Bool.noConfusion | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ bit false n β 0
case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ bit true n β 0 | case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ bit true n β 0 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | simp | case f.true
n : β
ih : size n β€ n
hb : n = 0 β true = true
β’ bit true n β 0 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | cases n | case f.false
n : β
ih : size n β€ n
hb : n = 0 β false = true
β’ 1 β€ n | case f.false.zero
ih : size zero β€ zero
hb : zero = 0 β false = true
β’ 1 β€ zero
case f.false.succ
nβ : β
ih : size (succ nβ) β€ succ nβ
hb : succ nβ = 0 β false = true
β’ 1 β€ succ nβ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | exact absurd (hb rfl) Bool.noConfusion | case f.false.zero
ih : size zero β€ zero
hb : zero = 0 β false = true
β’ 1 β€ zero
case f.false.succ
nβ : β
ih : size (succ nβ) β€ succ nβ
hb : succ nβ = 0 β false = true
β’ 1 β€ succ nβ | case f.false.succ
nβ : β
ih : size (succ nβ) β€ succ nβ
hb : succ nβ = 0 β false = true
β’ 1 β€ succ nβ |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | Lib.lean | Nat.size_le_self | [320, 1] | [338, 9] | exact Nat.succ_le_succ (Nat.zero_le _) | case f.false.succ
nβ : β
ih : size (succ nβ) β€ succ nβ
hb : succ nβ = 0 β false = true
β’ 1 β€ succ nβ | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah | [4, 1] | [10, 24] | ring_nf | a x : β
β’ (x + 1) ^ a + x ^ (a + 1) β€ (x + 1) ^ (a + 1) + x ^ a | a x : β
β’ x * x ^ a + (1 + x) ^ a β€ x * (1 + x) ^ a + x ^ a + (1 + x) ^ a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah | [4, 1] | [10, 24] | apply add_le_add_right | a x : β
β’ x * x ^ a + (1 + x) ^ a β€ x * (1 + x) ^ a + x ^ a + (1 + x) ^ a | case bc
a x : β
β’ x * x ^ a β€ x * (1 + x) ^ a + x ^ a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah | [4, 1] | [10, 24] | apply le_add_right | case bc
a x : β
β’ x * x ^ a β€ x * (1 + x) ^ a + x ^ a | case bc.h
a x : β
β’ x * x ^ a β€ x * (1 + x) ^ a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah | [4, 1] | [10, 24] | apply Nat.mul_le_mul_left | case bc.h
a x : β
β’ x * x ^ a β€ x * (1 + x) ^ a | case bc.h.h
a x : β
β’ x ^ a β€ (1 + x) ^ a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah | [4, 1] | [10, 24] | apply Nat.pow_le_pow_left | case bc.h.h
a x : β
β’ x ^ a β€ (1 + x) ^ a | case bc.h.h.h
a x : β
β’ x β€ 1 + x |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah | [4, 1] | [10, 24] | apply Nat.le_add_left | case bc.h.h.h
a x : β
β’ x β€ 1 + x | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah2 | [12, 1] | [18, 25] | apply Nat.sub_le_of_le_add | a x : β
β’ (x + 1) ^ a - x ^ a β€ (x + 1) ^ (a + 1) - x ^ (a + 1) | case h
a x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + 1) - x ^ (a + 1) + x ^ a |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah2 | [12, 1] | [18, 25] | rw [β Nat.sub_add_comm] | case h
a x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + 1) - x ^ (a + 1) + x ^ a | case h
a x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + 1) + x ^ a - x ^ (a + 1)
case h
a x : β
β’ x ^ (a + 1) β€ (x + 1) ^ (a + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah2 | [12, 1] | [18, 25] | apply Nat.le_sub_of_add_le | case h
a x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + 1) + x ^ a - x ^ (a + 1)
case h
a x : β
β’ x ^ (a + 1) β€ (x + 1) ^ (a + 1) | case h.h
a x : β
β’ (x + 1) ^ a + x ^ (a + 1) β€ (x + 1) ^ (a + 1) + x ^ a
case h
a x : β
β’ x ^ (a + 1) β€ (x + 1) ^ (a + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah2 | [12, 1] | [18, 25] | apply blah | case h.h
a x : β
β’ (x + 1) ^ a + x ^ (a + 1) β€ (x + 1) ^ (a + 1) + x ^ a
case h
a x : β
β’ x ^ (a + 1) β€ (x + 1) ^ (a + 1) | case h
a x : β
β’ x ^ (a + 1) β€ (x + 1) ^ (a + 1) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah2 | [12, 1] | [18, 25] | apply Nat.pow_le_pow_left | case h
a x : β
β’ x ^ (a + 1) β€ (x + 1) ^ (a + 1) | case h.h
a x : β
β’ x β€ x + 1 |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah2 | [12, 1] | [18, 25] | apply Nat.le_add_right | case h.h
a x : β
β’ x β€ x + 1 | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | cases a <;> cases b <;> simp | a b : β
β’ 0 ^ (a + b) - 0 ^ a β€ (0 + 1) ^ (a + b) - (0 + 1) ^ a | no goals |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | apply Nat.le_sub_of_add_le | a b x : β
β’ (x + 1) ^ (a + b) - (x + 1) ^ a β€ (x + 1 + 1) ^ (a + b) - (x + 1 + 1) ^ a | case h
a b x : β
β’ (x + 1) ^ (a + b) - (x + 1) ^ a + (x + 1 + 1) ^ a β€ (x + 1 + 1) ^ (a + b) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | rw [β Nat.sub_add_comm, add_comm, Nat.sub_add_comm] | case h
a b x : β
β’ (x + 1) ^ (a + b) - (x + 1) ^ a + (x + 1 + 1) ^ a β€ (x + 1 + 1) ^ (a + b) | case h
a b x : β
β’ (x + 1 + 1) ^ a - (x + 1) ^ a + (x + 1) ^ (a + b) β€ (x + 1 + 1) ^ (a + b)
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1 + 1) ^ a
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | apply Nat.add_le_of_le_sub _ blah3 | case h
a b x : β
β’ (x + 1 + 1) ^ a - (x + 1) ^ a + (x + 1) ^ (a + b) β€ (x + 1 + 1) ^ (a + b)
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1 + 1) ^ a
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) | a b x : β
β’ (x + 1) ^ (a + b) β€ (x + 1 + 1) ^ (a + b)
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1 + 1) ^ a
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | apply Nat.pow_le_pow_left (Nat.le_succ _) | a b x : β
β’ (x + 1) ^ (a + b) β€ (x + 1 + 1) ^ (a + b)
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1 + 1) ^ a
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) | case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1 + 1) ^ a
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | apply Nat.pow_le_pow_left (Nat.le_succ _) | case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1 + 1) ^ a
case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) | case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) |
https://github.com/calcu16/lean_complexity.git | d267eb4f3952c654f130a119311692c1c1a7cd71 | HMem/Trace/Master.lean | blah4 | [24, 1] | [33, 25] | apply Nat.pow_le_pow_right (Nat.zero_lt_succ _) | case h
a b x : β
β’ (x + 1) ^ a β€ (x + 1) ^ (a + b) | case h
a b x : β
β’ a β€ a + b |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.