Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | num_lines int64 1 150 | complexity_score float64 2.72 139,370,958,066,637,970,000,000,000,000,000,000,000,000,000,000,000,000,000B | diff_level int64 0 2 | file_diff_level float64 0 2 | theorem_same_file int64 1 32 | rank_file int64 0 2.51k |
|---|---|---|---|---|---|---|---|---|---|---|---|
import Mathlib.Algebra.IsPrimePow
import Mathlib.NumberTheory.ArithmeticFunction
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import number_theory.von_mangoldt from "leanprover-community/mathlib"@"c946d6097a6925ad16d7ec55677bbc977f9846de"
namespace ArithmeticFunction
open Finset Nat
open scoped Arit... | Mathlib/NumberTheory/VonMangoldt.lean | 144 | 160 | theorem sum_moebius_mul_log_eq {n : β} : (β d β n.divisors, (ΞΌ d : β) * log d) = -Ξ n := by |
simp only [β log_mul_moebius_eq_vonMangoldt, mul_comm log, mul_apply, log_apply, intCoe_apply, β
Finset.sum_neg_distrib, neg_mul_eq_mul_neg]
rw [sum_divisorsAntidiagonal fun i j => (ΞΌ i : β) * -Real.log j]
have : (β i β n.divisors, (ΞΌ i : β) * -Real.log (n / i : β)) =
β i β n.divisors, ((ΞΌ i : β) * Rea... | 16 | 8,886,110.520508 | 2 | 0.636364 | 11 | 552 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 160 | 161 | theorem sum_blocksFun : β i, c.blocksFun i = n := by |
conv_rhs => rw [β c.blocks_sum, β ofFn_blocksFun, sum_ofFn]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 187 | 189 | theorem length_le : c.length β€ n := by |
conv_rhs => rw [β c.blocks_sum]
exact length_le_sum_of_one_le _ fun i hi => c.one_le_blocks hi
| 2 | 7.389056 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 192 | 195 | theorem length_pos_of_pos (h : 0 < n) : 0 < c.length := by |
apply length_pos_of_sum_pos
convert h
exact c.blocks_sum
| 3 | 20.085537 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 204 | 204 | theorem sizeUpTo_zero : c.sizeUpTo 0 = 0 := by | simp [sizeUpTo]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 207 | 210 | theorem sizeUpTo_ofLength_le (i : β) (h : c.length β€ i) : c.sizeUpTo i = n := by |
dsimp [sizeUpTo]
convert c.blocks_sum
exact take_all_of_le h
| 3 | 20.085537 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 218 | 220 | theorem sizeUpTo_le (i : β) : c.sizeUpTo i β€ n := by |
conv_rhs => rw [β c.blocks_sum, β sum_take_add_sum_drop _ i]
exact Nat.le_add_right _ _
| 2 | 7.389056 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 223 | 226 | theorem sizeUpTo_succ {i : β} (h : i < c.length) :
c.sizeUpTo (i + 1) = c.sizeUpTo i + c.blocks.get β¨i, hβ© := by |
simp only [sizeUpTo]
rw [sum_take_succ _ _ h]
| 2 | 7.389056 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 234 | 236 | theorem sizeUpTo_strict_mono {i : β} (h : i < c.length) : c.sizeUpTo i < c.sizeUpTo (i + 1) := by |
rw [c.sizeUpTo_succ h]
simp
| 2 | 7.389056 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 252 | 252 | theorem boundary_zero : c.boundary 0 = 0 := by | simp [boundary, Fin.ext_iff]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 256 | 257 | theorem boundary_last : c.boundary (Fin.last c.length) = Fin.last n := by |
simp [boundary, Fin.ext_iff]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 647 | 649 | theorem splitWrtCompositionAux_cons (l : List Ξ±) (n ns) :
l.splitWrtCompositionAux (n::ns) = take n l::(drop n l).splitWrtCompositionAux ns := by |
simp [splitWrtCompositionAux]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 652 | 656 | theorem length_splitWrtCompositionAux (l : List Ξ±) (ns) :
length (l.splitWrtCompositionAux ns) = ns.length := by |
induction ns generalizing l
Β· simp [splitWrtCompositionAux, *]
Β· simp [*]
| 3 | 20.085537 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 843 | 846 | theorem compositionAsSet_card (n : β) : Fintype.card (CompositionAsSet n) = 2 ^ (n - 1) := by |
have : Fintype.card (Finset (Fin (n - 1))) = 2 ^ (n - 1) := by simp
rw [β this]
exact Fintype.card_congr (compositionAsSetEquiv n)
| 3 | 20.085537 | 1 | 0.642857 | 14 | 553 |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 870 | 872 | theorem length_lt_card_boundaries : c.length < c.boundaries.card := by |
rw [c.card_boundaries_eq_succ_length]
exact lt_add_one _
| 2 | 7.389056 | 1 | 0.642857 | 14 | 553 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 38 | 39 | theorem count_zero : count p 0 = 0 := by |
rw [count, List.range_zero, List.countP, List.countP.go]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 54 | 56 | theorem count_eq_card_filter_range (n : β) : count p n = ((range n).filter p).card := by |
rw [count, List.countP_eq_length_filter]
rfl
| 2 | 7.389056 | 1 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 60 | 62 | theorem count_eq_card_fintype (n : β) : count p n = Fintype.card { k : β // k < n β§ p k } := by |
rw [count_eq_card_filter_range, β Fintype.card_ofFinset, β CountSet.fintype]
rfl
| 2 | 7.389056 | 1 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 65 | 66 | theorem count_succ (n : β) : count p (n + 1) = count p n + if p n then 1 else 0 := by |
split_ifs with h <;> simp [count, List.range_succ, h]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 74 | 83 | theorem count_add (a b : β) : count p (a + b) = count p a + count (fun k β¦ p (a + k)) b := by |
have : Disjoint ((range a).filter p) (((range b).map <| addLeftEmbedding a).filter p) := by
apply disjoint_filter_filter
rw [Finset.disjoint_left]
simp_rw [mem_map, mem_range, addLeftEmbedding_apply]
rintro x hx β¨c, _, rflβ©
exact (self_le_add_right _ _).not_lt hx
simp_rw [count_eq_card_filter_r... | 9 | 8,103.083928 | 2 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 86 | 88 | theorem count_add' (a b : β) : count p (a + b) = count (fun k β¦ p (k + b)) a + count p b := by |
rw [add_comm, count_add, add_comm]
simp_rw [add_comm b]
| 2 | 7.389056 | 1 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 91 | 91 | theorem count_one : count p 1 = if p 0 then 1 else 0 := by | simp [count_succ]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 94 | 96 | theorem count_succ' (n : β) :
count p (n + 1) = count (fun k β¦ p (k + 1)) n + if p 0 then 1 else 0 := by |
rw [count_add', count_one]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 102 | 103 | theorem count_lt_count_succ_iff {n : β} : count p n < count p (n + 1) β p n := by |
by_cases h : p n <;> simp [count_succ, h]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 106 | 107 | theorem count_succ_eq_succ_count_iff {n : β} : count p (n + 1) = count p n + 1 β p n := by |
by_cases h : p n <;> simp [h, count_succ]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 110 | 111 | theorem count_succ_eq_count_iff {n : β} : count p (n + 1) = count p n β Β¬p n := by |
by_cases h : p n <;> simp [h, count_succ]
| 1 | 2.718282 | 0 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 120 | 122 | theorem count_le_cardinal (n : β) : (count p n : Cardinal) β€ Cardinal.mk { k | p k } := by |
rw [count_eq_card_fintype, β Cardinal.mk_fintype]
exact Cardinal.mk_subtype_mono fun x hx β¦ hx.2
| 2 | 7.389056 | 1 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 133 | 137 | theorem count_injective {m n : β} (hm : p m) (hn : p n) (heq : count p m = count p n) : m = n := by |
by_contra! h : m β n
wlog hmn : m < n
Β· exact this hn hm heq.symm h.symm (h.lt_or_lt.resolve_left hmn)
Β· simpa [heq] using count_strict_mono hm hmn
| 4 | 54.59815 | 2 | 0.642857 | 14 | 554 |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 140 | 142 | theorem count_le_card (hp : (setOf p).Finite) (n : β) : count p n β€ hp.toFinset.card := by |
rw [count_eq_card_filter_range]
exact Finset.card_mono fun x hx β¦ hp.mem_toFinset.2 (mem_filter.1 hx).2
| 2 | 7.389056 | 1 | 0.642857 | 14 | 554 |
import Mathlib.Data.Fin.VecNotation
import Mathlib.SetTheory.Cardinal.Basic
#align_import model_theory.basic from "leanprover-community/mathlib"@"369525b73f229ccd76a6ec0e0e0bf2be57599768"
set_option autoImplicit true
universe u v u' v' w w'
open Cardinal
open Cardinal
namespace FirstOrder
-- intended to b... | Mathlib/ModelTheory/Basic.lean | 95 | 100 | theorem lift_mk {i : β} :
Cardinal.lift.{v,u} #(Sequenceβ aβ aβ aβ i)
= #(Sequenceβ (ULift.{v,u} aβ) (ULift.{v,u} aβ) (ULift.{v,u} aβ) i) := by |
rcases i with (_ | _ | _ | i) <;>
simp only [Sequenceβ, mk_uLift, Nat.succ_ne_zero, IsEmpty.forall_iff, Nat.succ.injEq,
add_eq_zero, OfNat.ofNat_ne_zero, and_false, one_ne_zero, mk_eq_zero, lift_zero]
| 3 | 20.085537 | 1 | 0.666667 | 3 | 555 |
import Mathlib.Data.Fin.VecNotation
import Mathlib.SetTheory.Cardinal.Basic
#align_import model_theory.basic from "leanprover-community/mathlib"@"369525b73f229ccd76a6ec0e0e0bf2be57599768"
set_option autoImplicit true
universe u v u' v' w w'
open Cardinal
open Cardinal
namespace FirstOrder
-- intended to b... | Mathlib/ModelTheory/Basic.lean | 104 | 106 | theorem sum_card : Cardinal.sum (fun i => #(Sequenceβ aβ aβ aβ i)) = #aβ + #aβ + #aβ := by |
rw [sum_nat_eq_add_sum_succ, sum_nat_eq_add_sum_succ, sum_nat_eq_add_sum_succ]
simp [add_assoc, Sequenceβ]
| 2 | 7.389056 | 1 | 0.666667 | 3 | 555 |
import Mathlib.Data.Fin.VecNotation
import Mathlib.SetTheory.Cardinal.Basic
#align_import model_theory.basic from "leanprover-community/mathlib"@"369525b73f229ccd76a6ec0e0e0bf2be57599768"
set_option autoImplicit true
universe u v u' v' w w'
open Cardinal
open Cardinal
namespace FirstOrder
-- intended to b... | Mathlib/ModelTheory/Basic.lean | 174 | 178 | theorem card_eq_card_functions_add_card_relations :
L.card =
(Cardinal.sum fun l => Cardinal.lift.{v} #(L.Functions l)) +
Cardinal.sum fun l => Cardinal.lift.{u} #(L.Relations l) := by |
simp [card, Symbols]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 555 |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode Ξ±) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 32 | 33 | theorem All_def {t : RBNode Ξ±} : t.All p β β x β t, p x := by |
induction t <;> simp [or_imp, forall_and, *]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 556 |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode Ξ±) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 35 | 36 | theorem Any_def {t : RBNode Ξ±} : t.Any p β β x β t, p x := by |
induction t <;> simp [or_and_right, exists_or, *]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 556 |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode Ξ±) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 42 | 43 | theorem mem_congr [@TransCmp Ξ± cmp] {t : RBNode Ξ±} (h : cmp x y = .eq) :
Mem cmp x t β Mem cmp y t := by | simp [Mem, TransCmp.cmp_congr_left' h]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 556 |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode Ξ±) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 45 | 65 | theorem isOrdered_iff' [@TransCmp Ξ± cmp] {t : RBNode Ξ±} :
isOrdered cmp t L R β
(β a β L, t.All (cmpLT cmp a Β·)) β§
(β a β R, t.All (cmpLT cmp Β· a)) β§
(β a β L, β b β R, cmpLT cmp a b) β§
Ordered cmp t := by |
induction t generalizing L R with
| nil =>
simp [isOrdered]; split <;> simp [cmpLT_iff]
next h => intro _ ha _ hb; cases h _ _ ha hb
| node _ l v r =>
simp [isOrdered, *]
exact β¨
fun β¨β¨Ll, lv, Lv, olβ©, β¨vr, rR, vR, orβ©β© => β¨
fun _ h => β¨Lv _ h, Ll _ h, (Lv _ h).trans_l vrβ©,
... | 15 | 3,269,017.372472 | 2 | 0.666667 | 6 | 556 |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode Ξ±) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 67 | 68 | theorem isOrdered_iff [@TransCmp Ξ± cmp] {t : RBNode Ξ±} :
isOrdered cmp t β Ordered cmp t := by | simp [isOrdered_iff']
| 1 | 2.718282 | 0 | 0.666667 | 6 | 556 |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode Ξ±) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 92 | 100 | theorem IsCut.congr [IsCut cmp cut] [TransCmp cmp] (H : cmp x y = .eq) : cut x = cut y := by |
cases ey : cut y
Β· exact IsCut.le_lt_trans (fun h => nomatch H.symm.trans <| OrientedCmp.cmp_eq_gt.1 h) ey
Β· cases ex : cut x
Β· exact IsCut.le_lt_trans (fun h => nomatch H.symm.trans h) ex |>.symm.trans ey
Β· rfl
Β· refine IsCut.le_gt_trans (cmp := cmp) (fun h => ?_) ex |>.symm.trans ey
cases H.s... | 8 | 2,980.957987 | 2 | 0.666667 | 6 | 556 |
import Mathlib.Data.Set.Subsingleton
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Nat
import Mathlib.Data.Set.Basic
#align_import data.set.equitable from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
variable {Ξ± Ξ² : Type*}
namespace Set
def Equ... | Mathlib/Data/Set/Equitable.lean | 42 | 54 | theorem equitableOn_iff_exists_le_le_add_one {s : Set Ξ±} {f : Ξ± β β} :
s.EquitableOn f β β b, β a β s, b β€ f a β§ f a β€ b + 1 := by |
refine β¨?_, fun β¨b, hbβ© x y hx hy => (hb x hx).2.trans (add_le_add_right (hb y hy).1 _)β©
obtain rfl | β¨x, hxβ© := s.eq_empty_or_nonempty
Β· simp
intro hs
by_cases h : β y β s, f x β€ f y
Β· exact β¨f x, fun y hy => β¨h _ hy, hs hy hxβ©β©
push_neg at h
obtain β¨w, hw, hwxβ© := h
refine β¨f w, fun y hy => β¨Nat.le... | 11 | 59,874.141715 | 2 | 0.666667 | 3 | 557 |
import Mathlib.Data.Set.Subsingleton
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Nat
import Mathlib.Data.Set.Basic
#align_import data.set.equitable from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
variable {Ξ± Ξ² : Type*}
namespace Set
def Equ... | Mathlib/Data/Set/Equitable.lean | 57 | 59 | theorem equitableOn_iff_exists_image_subset_icc {s : Set Ξ±} {f : Ξ± β β} :
s.EquitableOn f β β b, f '' s β Icc b (b + 1) := by |
simpa only [image_subset_iff] using equitableOn_iff_exists_le_le_add_one
| 1 | 2.718282 | 0 | 0.666667 | 3 | 557 |
import Mathlib.Data.Set.Subsingleton
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Nat
import Mathlib.Data.Set.Basic
#align_import data.set.equitable from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
variable {Ξ± Ξ² : Type*}
namespace Set
def Equ... | Mathlib/Data/Set/Equitable.lean | 62 | 64 | theorem equitableOn_iff_exists_eq_eq_add_one {s : Set Ξ±} {f : Ξ± β β} :
s.EquitableOn f β β b, β a β s, f a = b β¨ f a = b + 1 := by |
simp_rw [equitableOn_iff_exists_le_le_add_one, Nat.le_and_le_add_one_iff]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 557 |
import Mathlib.LinearAlgebra.Ray
import Mathlib.LinearAlgebra.Determinant
#align_import linear_algebra.orientation from "leanprover-community/mathlib"@"0c1d80f5a86b36c1db32e021e8d19ae7809d5b79"
noncomputable section
section OrderedCommSemiring
variable (R : Type*) [StrictOrderedCommSemiring R]
variable (M : Typ... | Mathlib/LinearAlgebra/Orientation.lean | 74 | 75 | theorem Orientation.map_refl : (Orientation.map ΞΉ <| LinearEquiv.refl R M) = Equiv.refl _ := by |
rw [Orientation.map, AlternatingMap.domLCongr_refl, Module.Ray.map_refl]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 558 |
import Mathlib.LinearAlgebra.Ray
import Mathlib.LinearAlgebra.Determinant
#align_import linear_algebra.orientation from "leanprover-community/mathlib"@"0c1d80f5a86b36c1db32e021e8d19ae7809d5b79"
noncomputable section
section OrderedCommSemiring
variable (R : Type*) [StrictOrderedCommSemiring R]
variable (M : Typ... | Mathlib/LinearAlgebra/Orientation.lean | 100 | 101 | theorem Orientation.reindex_refl : (Orientation.reindex R M <| Equiv.refl ΞΉ) = Equiv.refl _ := by |
rw [Orientation.reindex, AlternatingMap.domDomCongrβ_refl, Module.Ray.map_refl]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 558 |
import Mathlib.LinearAlgebra.Ray
import Mathlib.LinearAlgebra.Determinant
#align_import linear_algebra.orientation from "leanprover-community/mathlib"@"0c1d80f5a86b36c1db32e021e8d19ae7809d5b79"
noncomputable section
section OrderedCommSemiring
variable (R : Type*) [StrictOrderedCommSemiring R]
variable (M : Typ... | Mathlib/LinearAlgebra/Orientation.lean | 125 | 133 | theorem Orientation.map_of_isEmpty [IsEmpty ΞΉ] (x : Orientation R M ΞΉ) (f : M ββ[R] M) :
Orientation.map ΞΉ f x = x := by |
induction' x using Module.Ray.ind with g hg
rw [Orientation.map_apply]
congr
ext i
rw [AlternatingMap.compLinearMap_apply]
congr
simp only [LinearEquiv.coe_coe, eq_iff_true_of_subsingleton]
| 7 | 1,096.633158 | 2 | 0.666667 | 3 | 558 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.FreeModule.Basic
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.LinearAlgebra.Projection
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
open Function Set Submodule
set_option ... | Mathlib/LinearAlgebra/Basis/VectorSpace.lean | 67 | 69 | theorem range_extend (hs : LinearIndependent K ((β) : s β V)) :
range (Basis.extend hs) = hs.extend (subset_univ _) := by |
rw [coe_extend, Subtype.range_coe_subtype, setOf_mem_eq]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 559 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.FreeModule.Basic
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.LinearAlgebra.Projection
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
open Function Set Submodule
set_option ... | Mathlib/LinearAlgebra/Basis/VectorSpace.lean | 117 | 119 | theorem ofVectorSpace_apply_self (x : ofVectorSpaceIndex K V) : ofVectorSpace K V x = x := by |
unfold ofVectorSpace
exact Basis.mk_apply _ _ _
| 2 | 7.389056 | 1 | 0.666667 | 3 | 559 |
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.FreeModule.Basic
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.LinearAlgebra.Projection
#align_import linear_algebra.basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
open Function Set Submodule
set_option ... | Mathlib/LinearAlgebra/Basis/VectorSpace.lean | 127 | 131 | theorem ofVectorSpaceIndex.linearIndependent :
LinearIndependent K ((β) : ofVectorSpaceIndex K V β V) := by |
convert (ofVectorSpace K V).linearIndependent
ext x
rw [ofVectorSpace_apply_self]
| 3 | 20.085537 | 1 | 0.666667 | 3 | 559 |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.Cover
import Mathlib.Order.Iterate
import Mathlib.Order.WellFounded
#align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
open Function OrderDual Set
variable {Ξ± Ξ² : Type*}
@[ext]
class SuccOr... | Mathlib/Order/SuccPred/Basic.lean | 279 | 281 | theorem succ_lt_succ_iff_of_not_isMax (ha : Β¬IsMax a) (hb : Β¬IsMax b) :
succ a < succ b β a < b := by |
rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 560 |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.Cover
import Mathlib.Order.Iterate
import Mathlib.Order.WellFounded
#align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
open Function OrderDual Set
variable {Ξ± Ξ² : Type*}
@[ext]
class SuccOr... | Mathlib/Order/SuccPred/Basic.lean | 284 | 286 | theorem succ_le_succ_iff_of_not_isMax (ha : Β¬IsMax a) (hb : Β¬IsMax b) :
succ a β€ succ b β a β€ b := by |
rw [succ_le_iff_of_not_isMax ha, lt_succ_iff_of_not_isMax hb]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 560 |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.Cover
import Mathlib.Order.Iterate
import Mathlib.Order.WellFounded
#align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
open Function OrderDual Set
variable {Ξ± Ξ² : Type*}
@[ext]
class SuccOr... | Mathlib/Order/SuccPred/Basic.lean | 290 | 295 | theorem succ_le_succ (h : a β€ b) : succ a β€ succ b := by |
by_cases hb : IsMax b
Β· by_cases hba : b β€ a
Β· exact (hb <| hba.trans <| le_succ _).trans (le_succ _)
Β· exact succ_le_of_lt ((h.lt_of_not_le hba).trans_le <| le_succ b)
Β· rwa [succ_le_iff_of_not_isMax fun ha => hb <| ha.mono h, lt_succ_iff_of_not_isMax hb]
| 5 | 148.413159 | 2 | 0.666667 | 3 | 560 |
import Mathlib.Combinatorics.Quiver.Cast
import Mathlib.Combinatorics.Quiver.Symmetric
#align_import combinatorics.quiver.single_obj from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
namespace Quiver
-- Porting note: Removed `deriving Unique`.
@[nolint unusedArguments]
def SingleObj ... | Mathlib/Combinatorics/Quiver/SingleObj.lean | 110 | 112 | theorem toPrefunctor_symm_comp (f : SingleObj Ξ± β₯€q SingleObj Ξ²) (g : SingleObj Ξ² β₯€q SingleObj Ξ³) :
toPrefunctor.symm (f βq g) = toPrefunctor.symm g β toPrefunctor.symm f := by |
simp only [Equiv.symm_apply_eq, toPrefunctor_comp, Equiv.apply_symm_apply]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 561 |
import Mathlib.Combinatorics.Quiver.Cast
import Mathlib.Combinatorics.Quiver.Symmetric
#align_import combinatorics.quiver.single_obj from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
namespace Quiver
-- Porting note: Removed `deriving Unique`.
@[nolint unusedArguments]
def SingleObj ... | Mathlib/Combinatorics/Quiver/SingleObj.lean | 132 | 136 | theorem listToPath_pathToList {x : SingleObj Ξ±} (p : Path (star Ξ±) x) :
listToPath (pathToList p) = p.cast rfl ext := by |
induction' p with y z p a ih
Β· rfl
Β· dsimp at *; rw [ih]
| 3 | 20.085537 | 1 | 0.666667 | 3 | 561 |
import Mathlib.Combinatorics.Quiver.Cast
import Mathlib.Combinatorics.Quiver.Symmetric
#align_import combinatorics.quiver.single_obj from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
namespace Quiver
-- Porting note: Removed `deriving Unique`.
@[nolint unusedArguments]
def SingleObj ... | Mathlib/Combinatorics/Quiver/SingleObj.lean | 139 | 142 | theorem pathToList_listToPath (l : List Ξ±) : pathToList (listToPath l) = l := by |
induction' l with a l ih
Β· rfl
Β· change a :: pathToList (listToPath l) = a :: l; rw [ih]
| 3 | 20.085537 | 1 | 0.666667 | 3 | 561 |
import Mathlib.SetTheory.Game.Basic
import Mathlib.Tactic.NthRewrite
#align_import set_theory.game.impartial from "leanprover-community/mathlib"@"2e0975f6a25dd3fbfb9e41556a77f075f6269748"
universe u
namespace SetTheory
open scoped PGame
namespace PGame
def ImpartialAux : PGame β Prop
| G => (G β -G) β§ (β i... | Mathlib/SetTheory/Game/Impartial.lean | 35 | 38 | theorem impartialAux_def {G : PGame} :
G.ImpartialAux β
(G β -G) β§ (β i, ImpartialAux (G.moveLeft i)) β§ β j, ImpartialAux (G.moveRight j) := by |
rw [ImpartialAux]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 562 |
import Mathlib.SetTheory.Game.Basic
import Mathlib.Tactic.NthRewrite
#align_import set_theory.game.impartial from "leanprover-community/mathlib"@"2e0975f6a25dd3fbfb9e41556a77f075f6269748"
universe u
namespace SetTheory
open scoped PGame
namespace PGame
def ImpartialAux : PGame β Prop
| G => (G β -G) β§ (β i... | Mathlib/SetTheory/Game/Impartial.lean | 50 | 52 | theorem impartial_def {G : PGame} :
G.Impartial β (G β -G) β§ (β i, Impartial (G.moveLeft i)) β§ β j, Impartial (G.moveRight j) := by |
simpa only [impartial_iff_aux] using impartialAux_def
| 1 | 2.718282 | 0 | 0.666667 | 3 | 562 |
import Mathlib.SetTheory.Game.Basic
import Mathlib.Tactic.NthRewrite
#align_import set_theory.game.impartial from "leanprover-community/mathlib"@"2e0975f6a25dd3fbfb9e41556a77f075f6269748"
universe u
namespace SetTheory
open scoped PGame
namespace PGame
def ImpartialAux : PGame β Prop
| G => (G β -G) β§ (β i... | Mathlib/SetTheory/Game/Impartial.lean | 137 | 142 | theorem equiv_or_fuzzy_zero : (G β 0) β¨ G β 0 := by |
rcases lt_or_equiv_or_gt_or_fuzzy G 0 with (h | h | h | h)
Β· exact ((nonneg G) h).elim
Β· exact Or.inl h
Β· exact ((nonpos G) h).elim
Β· exact Or.inr h
| 5 | 148.413159 | 2 | 0.666667 | 3 | 562 |
import Mathlib.Init.Function
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Inhabit
#align_import data.prod.basic from "leanprover-community/mathlib"@"d07245fd37786daa997af4f1a73a49fa3b748408"
variable {Ξ± : Type*} {Ξ² : Type*} {Ξ³ : Type*} {Ξ΄ : Type*}
@[simp]
theorem Prod.map_apply (f : Ξ± β Ξ³) (g : Ξ² β Ξ΄... | Mathlib/Data/Prod/Basic.lean | 105 | 107 | theorem mk.inj_left {Ξ± Ξ² : Type*} (a : Ξ±) : Function.Injective (Prod.mk a : Ξ² β Ξ± Γ Ξ²) := by |
intro bβ bβ h
simpa only [true_and, Prod.mk.inj_iff, eq_self_iff_true] using h
| 2 | 7.389056 | 1 | 0.666667 | 3 | 563 |
import Mathlib.Init.Function
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Inhabit
#align_import data.prod.basic from "leanprover-community/mathlib"@"d07245fd37786daa997af4f1a73a49fa3b748408"
variable {Ξ± : Type*} {Ξ² : Type*} {Ξ³ : Type*} {Ξ΄ : Type*}
@[simp]
theorem Prod.map_apply (f : Ξ± β Ξ³) (g : Ξ² β Ξ΄... | Mathlib/Data/Prod/Basic.lean | 110 | 113 | theorem mk.inj_right {Ξ± Ξ² : Type*} (b : Ξ²) :
Function.Injective (fun a β¦ Prod.mk a b : Ξ± β Ξ± Γ Ξ²) := by |
intro bβ bβ h
simpa only [and_true, eq_self_iff_true, mk.inj_iff] using h
| 2 | 7.389056 | 1 | 0.666667 | 3 | 563 |
import Mathlib.Init.Function
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Inhabit
#align_import data.prod.basic from "leanprover-community/mathlib"@"d07245fd37786daa997af4f1a73a49fa3b748408"
variable {Ξ± : Type*} {Ξ² : Type*} {Ξ³ : Type*} {Ξ΄ : Type*}
@[simp]
theorem Prod.map_apply (f : Ξ± β Ξ³) (g : Ξ² β Ξ΄... | Mathlib/Data/Prod/Basic.lean | 122 | 123 | theorem ext_iff {p q : Ξ± Γ Ξ²} : p = q β p.1 = q.1 β§ p.2 = q.2 := by |
rw [mk.inj_iff]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 563 |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 76 | 78 | theorem coe_inv_of_nonzero {J : FractionalIdeal Rββ° K} (h : J β 0) :
(βJβ»ΒΉ : Submodule Rβ K) = IsLocalization.coeSubmodule K β€ / (J : Submodule Rβ K) := by |
simp_rw [inv_nonzero _ h, coe_one, coe_mk, IsLocalization.coeSubmodule_top]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 564 |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 87 | 92 | theorem inv_anti_mono (hI : I β 0) (hJ : J β 0) (hIJ : I β€ J) : Jβ»ΒΉ β€ Iβ»ΒΉ := by |
-- Porting note: in Lean3, introducing `x` would just give `x β Jβ»ΒΉ β x β Iβ»ΒΉ`, but
-- in Lean4, it goes all the way down to the subtypes
intro x
simp only [val_eq_coe, mem_coe, mem_inv_iff hJ, mem_inv_iff hI]
exact fun h y hy => h y (hIJ hy)
| 5 | 148.413159 | 2 | 0.666667 | 6 | 564 |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 108 | 122 | theorem right_inverse_eq (I J : FractionalIdeal Rββ° K) (h : I * J = 1) : J = Iβ»ΒΉ := by |
have hI : I β 0 := ne_zero_of_mul_eq_one I J h
suffices h' : I * (1 / I) = 1 from
congr_arg Units.inv <| @Units.ext _ _ (Units.mkOfMulEqOne _ _ h) (Units.mkOfMulEqOne _ _ h') rfl
apply le_antisymm
Β· apply mul_le.mpr _
intro x hx y hy
rw [mul_comm]
exact (mem_div_iff_of_nonzero hI).mp hy x hx
... | 14 | 1,202,604.284165 | 2 | 0.666667 | 6 | 564 |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 136 | 137 | theorem map_inv (I : FractionalIdeal Rββ° K) (h : K ββ[Rβ] K') :
Iβ»ΒΉ.map (h : K ββ[Rβ] K') = (I.map h)β»ΒΉ := by | rw [inv_eq, map_div, map_one, inv_eq]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 564 |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 148 | 150 | theorem spanSingleton_div_spanSingleton (x y : K) :
spanSingleton Rββ° x / spanSingleton Rββ° y = spanSingleton Rββ° (x / y) := by |
rw [div_spanSingleton, mul_comm, spanSingleton_mul_spanSingleton, div_eq_mul_inv]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 564 |
import Mathlib.Algebra.Algebra.Subalgebra.Pointwise
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Maximal
import Mathlib.AlgebraicGeometry.PrimeSpectrum.Noetherian
import Mathlib.RingTheory.ChainOfDivisors
import Mathlib.RingTheory.DedekindDomain.Basic
import Mathlib.RingTheory.FractionalIdeal.Operations
#align_impo... | Mathlib/RingTheory/DedekindDomain/Ideal.lean | 153 | 155 | theorem spanSingleton_div_self {x : K} (hx : x β 0) :
spanSingleton Rββ° x / spanSingleton Rββ° x = 1 := by |
rw [spanSingleton_div_spanSingleton, div_self hx, spanSingleton_one]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 564 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 51 | 53 | theorem tendsto_pi {Ξ² : Type*} {m : Ξ² β β i, Ξ± i} {l : Filter Ξ²} :
Tendsto m l (pi f) β β i, Tendsto (fun x => m x i) l (f i) := by |
simp only [pi, tendsto_iInf, tendsto_comap_iff]; rfl
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 74 | 77 | theorem pi_mem_pi {I : Set ΞΉ} (hI : I.Finite) (h : β i β I, s i β f i) : I.pi s β pi f := by |
rw [pi_def, biInter_eq_iInter]
refine mem_iInf_of_iInter hI (fun i => ?_) Subset.rfl
exact preimage_mem_comap (h i i.2)
| 3 | 20.085537 | 1 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 80 | 88 | theorem mem_pi {s : Set (β i, Ξ± i)} :
s β pi f β β I : Set ΞΉ, I.Finite β§ β t : β i, Set (Ξ± i), (β i, t i β f i) β§ I.pi t β s := by |
constructor
Β· simp only [pi, mem_iInf', mem_comap, pi_def]
rintro β¨I, If, V, hVf, -, rfl, -β©
choose t htf htV using hVf
exact β¨I, If, t, htf, iInterβ_mono fun i _ => htV iβ©
Β· rintro β¨I, If, t, htf, htsβ©
exact mem_of_superset (pi_mem_pi If fun i _ => htf i) hts
| 7 | 1,096.633158 | 2 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 96 | 104 | theorem mem_of_pi_mem_pi [β i, NeBot (f i)] {I : Set ΞΉ} (h : I.pi s β pi f) {i : ΞΉ} (hi : i β I) :
s i β f i := by |
rcases mem_pi.1 h with β¨I', -, t, htf, htsβ©
refine mem_of_superset (htf i) fun x hx => ?_
have : β i, (t i).Nonempty := fun i => nonempty_of_mem (htf i)
choose g hg using this
have : update g i x β I'.pi t := fun j _ => by
rcases eq_or_ne j i with (rfl | hne) <;> simp [*]
simpa using hts this i hi
| 7 | 1,096.633158 | 2 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 121 | 125 | theorem hasBasis_pi {ΞΉ' : ΞΉ β Type} {s : β i, ΞΉ' i β Set (Ξ± i)} {p : β i, ΞΉ' i β Prop}
(h : β i, (f i).HasBasis (p i) (s i)) :
(pi f).HasBasis (fun If : Set ΞΉ Γ β i, ΞΉ' i => If.1.Finite β§ β i β If.1, p i (If.2 i))
fun If : Set ΞΉ Γ β i, ΞΉ' i => If.1.pi fun i => s i <| If.2 i := by |
simpa [Set.pi_def] using hasBasis_iInf' fun i => (h i).comap (eval i : (β j, Ξ± j) β Ξ± i)
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 229 | 230 | theorem mem_coprodα΅’_iff {s : Set (β i, Ξ± i)} :
s β Filter.coprodα΅’ f β β i : ΞΉ, β tβ β f i, eval i β»ΒΉ' tβ β s := by | simp [Filter.coprodα΅’]
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 233 | 235 | theorem compl_mem_coprodα΅’ {s : Set (β i, Ξ± i)} :
sαΆ β Filter.coprodα΅’ f β β i, (eval i '' s)αΆ β f i := by |
simp only [Filter.coprodα΅’, mem_iSup, compl_mem_comap]
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 238 | 240 | theorem coprodα΅’_neBot_iff' :
NeBot (Filter.coprodα΅’ f) β (β i, Nonempty (Ξ± i)) β§ β d, NeBot (f d) := by |
simp only [Filter.coprodα΅’, iSup_neBot, β exists_and_left, β comap_eval_neBot_iff']
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 244 | 245 | theorem coprodα΅’_neBot_iff [β i, Nonempty (Ξ± i)] : NeBot (Filter.coprodα΅’ f) β β d, NeBot (f d) := by |
simp [coprodα΅’_neBot_iff', *]
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 248 | 250 | theorem coprodα΅’_eq_bot_iff' : Filter.coprodα΅’ f = β₯ β (β i, IsEmpty (Ξ± i)) β¨ f = β₯ := by |
simpa only [not_neBot, not_and_or, funext_iff, not_forall, not_exists, not_nonempty_iff]
using coprodα΅’_neBot_iff'.not
| 2 | 7.389056 | 1 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 254 | 255 | theorem coprodα΅’_eq_bot_iff [β i, Nonempty (Ξ± i)] : Filter.coprodα΅’ f = β₯ β f = β₯ := by |
simpa [funext_iff] using coprodα΅’_neBot_iff.not
| 1 | 2.718282 | 0 | 0.666667 | 12 | 565 |
import Mathlib.Order.Filter.Bases
#align_import order.filter.pi from "leanprover-community/mathlib"@"ce64cd319bb6b3e82f31c2d38e79080d377be451"
open Set Function
open scoped Classical
open Filter
namespace Filter
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*} {f fβ fβ : (i : ΞΉ) β Filter (Ξ± i)} {s : (i : ΞΉ) β Set (Ξ± i)}
... | Mathlib/Order/Filter/Pi.lean | 284 | 290 | theorem map_pi_map_coprodα΅’_le :
map (fun k : β i, Ξ± i => fun i => m i (k i)) (Filter.coprodα΅’ f) β€
Filter.coprodα΅’ fun i => map (m i) (f i) := by |
simp only [le_def, mem_map, mem_coprodα΅’_iff]
intro s h i
obtain β¨t, H, hHβ© := h i
exact β¨{ x : Ξ± i | m i x β t }, H, fun x hx => hH hxβ©
| 4 | 54.59815 | 2 | 0.666667 | 12 | 565 |
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.GaloisConnection
import Mathlib.Order.Hom.Basic
#align_import order.hom.order from "leanprover-community/mathlib"@"ba2245edf0c8bb155f1569fd9b9492a9b384cde6"
namespace OrderHom
variable {Ξ± Ξ² : Type*}
section Preorder
variable [Preorder Ξ±]
instance [Sem... | Mathlib/Order/Hom/Order.lean | 97 | 99 | theorem coe_iInf {ΞΉ : Sort*} [CompleteLattice Ξ²] (f : ΞΉ β Ξ± βo Ξ²) :
((β¨
i, f i : Ξ± βo Ξ²) : Ξ± β Ξ²) = β¨
i, (f i : Ξ± β Ξ²) := by |
funext x; simp [iInf_apply]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 566 |
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.GaloisConnection
import Mathlib.Order.Hom.Basic
#align_import order.hom.order from "leanprover-community/mathlib"@"ba2245edf0c8bb155f1569fd9b9492a9b384cde6"
namespace OrderHom
variable {Ξ± Ξ² : Type*}
section Preorder
variable [Preorder Ξ±]
instance [Sem... | Mathlib/Order/Hom/Order.lean | 117 | 119 | theorem coe_iSup {ΞΉ : Sort*} [CompleteLattice Ξ²] (f : ΞΉ β Ξ± βo Ξ²) :
((β¨ i, f i : Ξ± βo Ξ²) : Ξ± β Ξ²) = β¨ i, (f i : Ξ± β Ξ²) := by |
funext x; simp [iSup_apply]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 566 |
import Mathlib.Logic.Function.Iterate
import Mathlib.Order.GaloisConnection
import Mathlib.Order.Hom.Basic
#align_import order.hom.order from "leanprover-community/mathlib"@"ba2245edf0c8bb155f1569fd9b9492a9b384cde6"
namespace OrderHom
variable {Ξ± Ξ² : Type*}
section Preorder
variable [Preorder Ξ±]
instance [Sem... | Mathlib/Order/Hom/Order.lean | 133 | 154 | theorem iterate_sup_le_sup_iff {Ξ± : Type*} [SemilatticeSup Ξ±] (f : Ξ± βo Ξ±) :
(β nβ nβ aβ aβ, f^[nβ + nβ] (aβ β aβ) β€ f^[nβ] aβ β f^[nβ] aβ) β
β aβ aβ, f (aβ β aβ) β€ f aβ β aβ := by |
constructor <;> intro h
Β· exact h 1 0
Β· intro nβ nβ aβ aβ
have h' : β n aβ aβ, f^[n] (aβ β aβ) β€ f^[n] aβ β aβ := by
intro n
induction' n with n ih <;> intro aβ aβ
Β· rfl
Β· calc
f^[n + 1] (aβ β aβ) = f^[n] (f (aβ β aβ)) := Function.iterate_succ_apply f n _
_ β€ f^[n]... | 19 | 178,482,300.963187 | 2 | 0.666667 | 3 | 566 |
import Mathlib.Data.Sigma.Basic
import Mathlib.Algebra.Order.Ring.Nat
#align_import set_theory.lists from "leanprover-community/mathlib"@"497d1e06409995dd8ec95301fa8d8f3480187f4c"
variable {Ξ± : Type*}
inductive Lists'.{u} (Ξ± : Type u) : Bool β Type u
| atom : Ξ± β Lists' Ξ± false
| nil : Lists' Ξ± true
| con... | Mathlib/SetTheory/Lists.lean | 88 | 88 | theorem toList_cons (a : Lists Ξ±) (l) : toList (cons a l) = a :: l.toList := by | simp
| 1 | 2.718282 | 0 | 0.666667 | 3 | 567 |
import Mathlib.Data.Sigma.Basic
import Mathlib.Algebra.Order.Ring.Nat
#align_import set_theory.lists from "leanprover-community/mathlib"@"497d1e06409995dd8ec95301fa8d8f3480187f4c"
variable {Ξ± : Type*}
inductive Lists'.{u} (Ξ± : Type u) : Bool β Type u
| atom : Ξ± β Lists' Ξ± false
| nil : Lists' Ξ± true
| con... | Mathlib/SetTheory/Lists.lean | 99 | 99 | theorem to_ofList (l : List (Lists Ξ±)) : toList (ofList l) = l := by | induction l <;> simp [*]
| 1 | 2.718282 | 0 | 0.666667 | 3 | 567 |
import Mathlib.Data.Sigma.Basic
import Mathlib.Algebra.Order.Ring.Nat
#align_import set_theory.lists from "leanprover-community/mathlib"@"497d1e06409995dd8ec95301fa8d8f3480187f4c"
variable {Ξ± : Type*}
inductive Lists'.{u} (Ξ± : Type u) : Bool β Type u
| atom : Ξ± β Lists' Ξ± false
| nil : Lists' Ξ± true
| con... | Mathlib/SetTheory/Lists.lean | 103 | 120 | theorem of_toList : β l : Lists' Ξ± true, ofList (toList l) = l :=
suffices
β (b) (h : true = b) (l : Lists' Ξ± b),
let l' : Lists' Ξ± true := by | rw [h]; exact l
ofList (toList l') = l'
from this _ rfl
fun b h l => by
induction l with
| atom => cases h
-- Porting note: case nil was not covered.
| nil => simp
| cons' b a _ IH =>
intro l'
-- Porting note: Previous code was:
-- change l' with cons' a l
--
... | 15 | 3,269,017.372472 | 2 | 0.666667 | 3 | 567 |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 29 | 30 | theorem aeval_T (x : A) (n : β€) : aeval x (T R n) = (T A n).eval x := by |
rw [aeval_def, evalβ_eq_eval_map, map_T]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 568 |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 34 | 35 | theorem aeval_U (x : A) (n : β€) : aeval x (U R n) = (U A n).eval x := by |
rw [aeval_def, evalβ_eq_eval_map, map_U]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 568 |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 39 | 41 | theorem algebraMap_eval_T (x : R) (n : β€) :
algebraMap R A ((T R n).eval x) = (T A n).eval (algebraMap R A x) := by |
rw [β aeval_algebraMap_apply_eq_algebraMap_eval, aeval_T]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 568 |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 45 | 47 | theorem algebraMap_eval_U (x : R) (n : β€) :
algebraMap R A ((U R n).eval x) = (U A n).eval (algebraMap R A x) := by |
rw [β aeval_algebraMap_apply_eq_algebraMap_eval, aeval_U]
| 1 | 2.718282 | 0 | 0.666667 | 6 | 568 |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 73 | 86 | theorem T_complex_cos (n : β€) : (T β n).eval (cos ΞΈ) = cos (n * ΞΈ) := by |
induction n using Polynomial.Chebyshev.induct with
| zero => simp
| one => simp
| add_two n ih1 ih2 =>
simp only [T_add_two, eval_sub, eval_mul, eval_X, eval_ofNat, ih1, ih2, sub_eq_iff_eq_add,
cos_add_cos]
push_cast
ring_nf
| neg_add_one n ih1 ih2 =>
simp only [T_sub_one, eval_sub, eva... | 13 | 442,413.392009 | 2 | 0.666667 | 6 | 568 |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 92 | 105 | theorem U_complex_cos (n : β€) : (U β n).eval (cos ΞΈ) * sin ΞΈ = sin ((n + 1) * ΞΈ) := by |
induction n using Polynomial.Chebyshev.induct with
| zero => simp
| one => simp [one_add_one_eq_two, sin_two_mul]; ring
| add_two n ih1 ih2 =>
simp only [U_add_two, add_sub_cancel_right, eval_sub, eval_mul, eval_X, eval_ofNat, sub_mul,
mul_assoc, ih1, ih2, sub_eq_iff_eq_add, sin_add_sin]
push_cas... | 13 | 442,413.392009 | 2 | 0.666667 | 6 | 568 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 38 | 39 | theorem shiftLeft'_ne_zero_left (b) {m} (h : m β 0) (n) : shiftLeft' b m n β 0 := by |
induction n <;> simp [bit_ne_zero, shiftLeft', *]
| 1 | 2.718282 | 0 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 51 | 51 | theorem size_zero : size 0 = 0 := by | simp [size]
| 1 | 2.718282 | 0 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 55 | 61 | theorem size_bit {b n} (h : bit b n β 0) : size (bit b n) = succ (size n) := by |
rw [size]
conv =>
lhs
rw [binaryRec]
simp [h]
rw [div2_bit]
| 6 | 403.428793 | 2 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 85 | 97 | theorem size_shiftLeft' {b m n} (h : shiftLeft' b m n β 0) :
size (shiftLeft' b m n) = size m + n := by |
induction' n with n IH <;> simp [shiftLeft'] at h β’
rw [size_bit h, Nat.add_succ]
by_cases s0 : shiftLeft' b m n = 0 <;> [skip; rw [IH s0]]
rw [s0] at h β’
cases b; Β· exact absurd rfl h
have : shiftLeft' true m n + 1 = 1 := congr_arg (Β· + 1) s0
rw [shiftLeft'_tt_eq_mul_pow] at this
obtain rfl := succ.in... | 11 | 59,874.141715 | 2 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 103 | 104 | theorem size_shiftLeft {m} (h : m β 0) (n) : size (m <<< n) = size m + n := by |
simp only [size_shiftLeft' (shiftLeft'_ne_zero_left _ h _), β shiftLeft'_false]
| 1 | 2.718282 | 0 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 107 | 116 | theorem lt_size_self (n : β) : n < 2 ^ size n := by |
rw [β one_shiftLeft]
have : β {n}, n = 0 β n < 1 <<< (size n) := by simp
apply binaryRec _ _ n
Β· apply this rfl
intro b n IH
by_cases h : bit b n = 0
Β· apply this h
rw [size_bit h, shiftLeft_succ, shiftLeft_eq, one_mul, β bit0_val]
exact bit_lt_bit0 _ (by simpa [shiftLeft_eq, shiftRight_eq_div_pow] u... | 9 | 8,103.083928 | 2 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 137 | 138 | theorem lt_size {m n : β} : m < size n β 2 ^ m β€ n := by |
rw [β not_lt, Decidable.iff_not_comm, not_lt, size_le]
| 1 | 2.718282 | 0 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 141 | 141 | theorem size_pos {n : β} : 0 < size n β 0 < n := by | rw [lt_size]; rfl
| 1 | 2.718282 | 0 | 0.666667 | 9 | 569 |
import Mathlib.Data.Nat.Bits
import Mathlib.Order.Lattice
#align_import data.nat.size from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
namespace Nat
section
set_option linter.deprecated false
theorem shiftLeft_eq_mul_pow (m) : β n, m <<< n = m * 2 ^ n := shiftLeft_eq _
#align nat.... | Mathlib/Data/Nat/Size.lean | 144 | 145 | theorem size_eq_zero {n : β} : size n = 0 β n = 0 := by |
simpa [Nat.pos_iff_ne_zero, not_iff_not] using size_pos
| 1 | 2.718282 | 0 | 0.666667 | 9 | 569 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q... | Mathlib/Data/ENNReal/Operations.lean | 33 | 41 | theorem mul_lt_mul (ac : a < c) (bd : b < d) : a * b < c * d := by |
rcases lt_iff_exists_nnreal_btwn.1 ac with β¨a', aa', a'cβ©
lift a to ββ₯0 using ne_top_of_lt aa'
rcases lt_iff_exists_nnreal_btwn.1 bd with β¨b', bb', b'dβ©
lift b to ββ₯0 using ne_top_of_lt bb'
norm_cast at *
calc
β(a * b) < β(a' * b') := coe_lt_coe.2 (mul_lt_mulβ aa' bb')
_ β€ c * d := mul_le_mul' a'c.... | 8 | 2,980.957987 | 2 | 0.666667 | 12 | 570 |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ββ₯0β} {r p q... | Mathlib/Data/ENNReal/Operations.lean | 71 | 77 | theorem mul_left_strictMono (h0 : a β 0) (hinf : a β β) : StrictMono (a * Β·) := by |
lift a to ββ₯0 using hinf
rw [coe_ne_zero] at h0
intro x y h
contrapose! h
simpa only [β mul_assoc, β coe_mul, inv_mul_cancel h0, coe_one, one_mul]
using mul_le_mul_left' h (βaβ»ΒΉ)
| 6 | 403.428793 | 2 | 0.666667 | 12 | 570 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.