name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
alexandrovDiscrete_iSup | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} {t : ι → TopologicalSpace α}, (∀ (i : ι), AlexandrovDiscrete α) → AlexandrovDiscrete α | true |
SheafOfModules.IsFiniteType | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] →
... | true |
StrictMono.add_const | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α}
[AddRightStrictMono α], StrictMono f → ∀ (c : α), StrictMono fun x => f x + c | true |
CategoryTheory.Bicategory.Pith.pseudofunctorToPith_mapComp_inv_iso_inv | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {B' : Type u₂} [inst_1 : CategoryTheory.Bicategory B']
[inst_2 : CategoryTheory.Bicategory.IsLocallyGroupoid B'] (F : CategoryTheory.Pseudofunctor B' B) {a b c : B'}
(f : a ⟶ b) (g : b ⟶ c),
((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).mapComp f g).i... | true |
Mathlib.Meta.NormNum.evalLE | Mathlib.Tactic.NormNum.Ineq | Mathlib.Meta.NormNum.NormNumExt | true |
MeasureTheory.withDensitySMulLI._proof_1 | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
AddCommGrpCat.homAddEquiv_apply | Mathlib.Algebra.Category.Grp.Preadditive | ∀ {M N : AddCommGrpCat} (a : M ⟶ N), AddCommGrpCat.homAddEquiv a = CategoryTheory.ConcreteCategory.hom a | true |
Int.ModEq.listProd_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {n : ℤ} {l : List ℤ}, (∀ x ∈ l, x ≡ 1 [ZMOD n]) → l.prod ≡ 1 [ZMOD n] | true |
_private.Mathlib.Tactic.Abel.0.Mathlib.Tactic.Abel.evalAtom.match_1 | Mathlib.Tactic.Abel | (motive : Option Lean.Expr → Sort u_1) →
(proof? : Option Lean.Expr) → (Unit → motive none) → ((p : Lean.Expr) → motive (some p)) → motive proof? | false |
Lean.Compiler.LCNF.CtorLayout.mk | Lean.Compiler.LCNF.ToImpureType | Lean.Compiler.LCNF.CtorInfo → Array Lean.Compiler.LCNF.CtorFieldInfo → Lean.Compiler.LCNF.CtorLayout | true |
Std.DTreeMap.Internal.Impl.Const.get?_eq_some_get! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF → ∀ {a : α}, a ∈ t → Std.DTreeMap.Internal.Impl.Const.get? t a = some (Std.DTreeMap.Internal.Impl.Const.get! t a) | true |
Subgroup.relIndex_eq_one._simp_2 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G}, (H.relIndex K = 1) = (K ≤ H) | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_367 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
Subsemiring.toSemiring._proof_4 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u_1} [inst : Semiring R] (s : Subsemiring R), ↑0 = 0 | false |
_private.Mathlib.RingTheory.Polynomial.Chebyshev.0.Polynomial.Chebyshev.T.match_1.eq_1 | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (motive : ℤ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1)
(h_3 : (n : ℕ) → motive (Int.ofNat n.succ.succ)) (h_4 : (n : ℕ) → motive (Int.negSucc n)),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| Int.ofNat n.succ.succ => h_3 n
| Int.negSucc n => h_4 n) =
h_1 () | true |
Finpartition.instBotFinset | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : DecidableEq α] → (s : Finset α) → Bot (Finpartition s) | true |
_private.Mathlib.SetTheory.Descriptive.Tree.0.Descriptive.Tree.pullSub_append.match_1_4 | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} (T : ↥(Descriptive.tree A)) (x y z : List A) (motive : z ∈ Descriptive.Tree.pullSub T (x ++ y) → Prop)
(h : z ∈ Descriptive.Tree.pullSub T (x ++ y)),
(∀ (h : List.take (x ++ y).length z <+: x ++ y) (right : List.drop (x ++ y).length z ∈ T), motive ⋯) → motive h | false |
CategoryTheory.Monad.Algebra.Hom.ext | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {T : CategoryTheory.Monad C} {A B : T.Algebra}
{x y : A.Hom B}, x.f = y.f → x = y | true |
Irrational.natCast_add | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → ∀ (m : ℕ), Irrational (↑m + x) | true |
Bool.not_and_self | Init.Data.Bool | ∀ (x : Bool), (!x && x) = false | true |
PositiveLinearMap.GNS | Mathlib.Analysis.CStarAlgebra.GelfandNaimarkSegal | {A : Type u_1} →
[inst : NonUnitalCStarAlgebra A] → [inst_1 : PartialOrder A] → (A →ₚ[ℂ] ℂ) → [StarOrderedRing A] → Type u_1 | true |
WithAbs.instField._proof_23 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R] (v : AbsoluteValue R S)
(q : ℚ≥0) (x : WithAbs v),
(WithAbs.equiv v).toEquiv ((WithAbs.equiv v).symm (q • (WithAbs.equiv v).toEquiv x)) = q • (WithAbs.equiv v).toEquiv x | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.IsIsotypic.linearEquiv_fun.match_1_1 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ a, IsAtom a) → Prop) (x : ∃ a, IsAtom a), (∀ (S : Submodule R M) (hS : IsAtom S), motive ⋯) → motive x | false |
Bipointed.swapEquiv_symm | Mathlib.CategoryTheory.Category.Bipointed | Bipointed.swapEquiv.symm = Bipointed.swapEquiv | true |
Localization.partialOrder._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelMonoid α] {s : Submonoid α}
(a : Localization s), a ≤ a | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem._proof_1_2 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α}, a ∈ [] → (List.idxOf a [] + ([].length - 1)) % [].length < [].length | false |
CategoryTheory.Subgroupoid.comap_mono | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(φ : CategoryTheory.Functor C D) (S T : CategoryTheory.Subgroupoid D),
S ≤ T → CategoryTheory.Subgroupoid.comap φ S ≤ CategoryTheory.Subgroupoid.comap φ T | true |
ContinuousMap.attachBound._proof_1 | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : CompactSpace X] (f : C(X, ℝ)), Continuous fun x => ⟨f x, ⋯⟩ | false |
_private.Mathlib.Analysis.CStarAlgebra.CStarMatrix.0.CStarMatrix.instCompleteSpace._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] {m : Type u_3} {n : Type u_2}, CompleteSpace (CStarMatrix m n A) | false |
cfc_tsub._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestAttemptAllPar.match_1 | Lean.Elab.Tactic.Try | (motive : Except Lean.Exception (Lean.TSyntax `tactic × Lean.Elab.Tactic.SavedState) → Sort u_1) →
(result : Except Lean.Exception (Lean.TSyntax `tactic × Lean.Elab.Tactic.SavedState)) →
((tac : Lean.TSyntax `tactic) → (s : Lean.Elab.Tactic.SavedState) → motive (Except.ok (tac, s))) →
((a : Lean.Exception) ... | false |
RingHom.withTopMap._proof_3 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {R : Type u_2} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : DecidableEq R] [inst_2 : Nontrivial R]
[inst_3 : NonAssocSemiring S] [inst_4 : DecidableEq S] [inst_5 : Nontrivial S] (f : R →+* S)
(hf : Function.Injective ⇑f), (↑(f.toMonoidWithZeroHom.withTopMap hf)).toFun 0 = 0 | false |
cuspFunction_mul_zero | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f g : ℂ → ℂ},
ContinuousAt (Function.Periodic.cuspFunction h f) 0 →
ContinuousAt (Function.Periodic.cuspFunction h g) 0 →
Function.Periodic.cuspFunction h (f * g) 0 =
Function.Periodic.cuspFunction h f 0 * Function.Periodic.cuspFunction h g 0 | true |
Std.TreeMap.Raw.getElem?_erase | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k a : α}, (t.erase k)[a]? = if cmp k a = Ordering.eq then none else t[a]? | true |
PrimeSpectrum.BasicConstructibleSetData.instDecidableEq | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} → DecidableEq (PrimeSpectrum.BasicConstructibleSetData R) | true |
Bool.beq_comm | Init.Data.Bool | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, (a == b) = (b == a) | true |
Std.DTreeMap.Raw.Const.getD_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp],
t.WF →
∀ {l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Raw.Const.getD (Std.DTreeMap.Raw.Cons... | true |
tsub_tsub_le | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b : α},
b - (b - a) ≤ a | true |
Std.DHashMap.Internal.Raw₀.Const.get!_inter_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m₁).WF →
(↑m₂).WF → ∀ {k : α}, m₁.contains k = false → Std.DHashMap.Internal.Raw₀.Const.get! (m₁.inter m₂) k = default | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.instFinCategoryOfLOfDecidableEqR.match_7.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape}
(motive :
(b : J.R) →
(a : J.L) →
(CategoryTheory.Limits.WalkingMulticospan.left a ⟶ CategoryTheory.Limits.WalkingMulticospan.right b) →
J.fst b = a → J.snd b = a → Sort u_3)
(a : J.R) (h₁ : J.fst a = J.fst a) (h₂ : J.snd a = J.fst a)
(h_1... | true |
Std.Time.DateTime.instHAddOffset_4 | Std.Time.Zoned.DateTime | {tz : Std.Time.TimeZone} → HAdd (Std.Time.DateTime tz) Std.Time.Second.Offset (Std.Time.DateTime tz) | true |
MeasurableInv.mk | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} [inst : Inv G] [inst_1 : MeasurableSpace G], Measurable Inv.inv → MeasurableInv G | true |
CategoryTheory.GrothendieckTopology.Cover.Relation.recOn | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{J : CategoryTheory.GrothendieckTopology C} →
{S : J.Cover X} →
{motive : S.Relation → Sort u_1} →
(t : S.Relation) →
({fst snd : S.Arrow} → (r : fst.Relation snd) → motive { fst := fst, snd := s... | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeSomeUsingDefaultPrio.visit._sunfold | Lean.Elab.SyntheticMVars | ℕ → List Lean.MVarId → List Lean.MVarId → Lean.Elab.TermElabM Bool | false |
CategoryTheory.CartesianMonoidalCategory.prodComparison_natural_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₁} [inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) {A B B' : C} (g : B ⟶ B'),
CategoryTheory.CategoryStruct... | true |
Associated.setoid.eq_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M : Type u_2) [inst : Monoid M], Associated.setoid M = { r := Associated, iseqv := ⋯ } | true |
_private.Mathlib.Analysis.InnerProductSpace.Orthogonal.0.Submodule.orthogonalFamily_self.match_1_1 | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ (motive : Bool → Bool → Prop) (x x_1 : Bool),
(∀ (a : Unit), motive true true) →
(∀ (a : Unit), motive true false) →
(∀ (a : Unit), motive false true) → (∀ (a : Unit), motive false false) → motive x x_1 | false |
Submodule.pow_induction_on_left' | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Algebra R A] (M : Submodule R A)
{C : (n : ℕ) → (x : A) → x ∈ M ^ n → Prop},
(∀ (r : R), C 0 ((algebraMap R A) r) ⋯) →
(∀ (x y : A) (i : ℕ) (hx : x ∈ M ^ i) (hy : y ∈ M ^ i), C i x hx → C i y hy → C i (x + y) ⋯) →
(∀ (m : ... | true |
Array.getElem_of_mem | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, a ∈ xs → ∃ i, ∃ (h : i < xs.size), xs[i] = a | true |
convexHull_toCone_isLeast | Mathlib.Geometry.Convex.Cone.Basic | ∀ {𝕜 : Type u_1} {M : Type u_4} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup M] [inst_4 : Module 𝕜 M] (s : Set M), IsLeast {t | s ⊆ ↑t} (Convex.toCone ((convexHull 𝕜) s) ⋯) | true |
ContinuousOpenMap.instFunLike | Mathlib.Topology.Hom.Open | {α : Type u_2} → {β : Type u_3} → [inst : TopologicalSpace α] → [inst_1 : TopologicalSpace β] → FunLike (α →CO β) α β | true |
AddCommGrpCat.instAbelian._proof_4 | Mathlib.Algebra.Category.Grp.Abelian | CategoryTheory.Limits.HasKernels AddCommGrpCat | false |
CategoryTheory.ShortComplex.Exact.isColimitCoimage._proof_1 | Mathlib.CategoryTheory.Abelian.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limits.cokernel.π S.f) = 0 →
∀ {Z' : C} (u : S.X₂ ⟶ Z'),
CategoryTheory.CategorySt... | false |
ProofWidgets.instToJsonRpcEncodablePacket._@.ProofWidgets.Component.Basic.2852768078._hygCtx._hyg.28 | ProofWidgets.Component.Basic | Lean.ToJson ProofWidgets.RpcEncodablePacket✝ | false |
Lean.Elab.Term.elabPattern | Mathlib.Lean.Elab.Term | Lean.Term → Option Lean.Expr → Lean.Elab.TermElabM Lean.Expr | true |
Std.TreeMap.getKey?_of_isEmpty | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a : α},
t.isEmpty = true → t.getKey? a = none | true |
Multiset.ndunion_le_add | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : Multiset α), s.ndunion t ≤ s + t | true |
_private.Mathlib.Combinatorics.Additive.SmallTripling.0.Finset.small_neg_pos_neg_add | Mathlib.Combinatorics.Additive.SmallTripling | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : AddGroup G] {A : Finset G} {K : ℝ},
↑(3 • A).card ≤ K * ↑A.card → ↑(-A + A + -A).card ≤ K ^ 3 * ↑A.card | true |
Set.initialSegIicIicOfLE._proof_1 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] {i j : α} (h : i ≤ j) (x : ↑(Set.Iic i)),
∀
k <
{
toFun := fun x =>
match x with
| ⟨k, hk⟩ => ⟨k, ⋯⟩,
inj' := ⋯, map_rel_iff' := ⋯ }
x,
∃ y,
{
toFun := fun x =>
match x with
... | false |
TendstoLocallyUniformlyOn.add | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {X : Type u_4}
[inst_3 : TopologicalSpace X] {F G : ι → X → α} {f g : X → α} {s : Set X} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s → TendstoLocallyUniformlyOn G g l s → TendstoLocallyUniformlyOn (F + G) (f + ... | true |
Metric.AreSeparated.union_right | Mathlib.Topology.MetricSpace.MetricSeparated | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {s t t' : Set X},
Metric.AreSeparated s t → Metric.AreSeparated s t' → Metric.AreSeparated s (t ∪ t') | true |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit_eq_insertManyIfNewUnit! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {x : Ord α} {l : List α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} (h : t.Balanced),
↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l h) =
↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit! t l) | true |
_private.Mathlib.Analysis.Normed.Group.Seminorm.0.GroupSeminorm.instMin._simp_4 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), a⁻¹ / b⁻¹ = (a / b)⁻¹ | false |
Std.DTreeMap.Internal.Impl.Equiv.constMinEntry?_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF → t₁.Equiv t₂ → Std.DTreeMap.Internal.Impl.Const.minEntry? t₁ = Std.DTreeMap.Internal.Impl.Const.minEntry? t₂ | true |
Std.Time.Second.instDecidableEqOffset | Std.Time.Time.Unit.Second | DecidableEq Std.Time.Second.Offset | true |
MonotoneOn.map_csSup_of_continuousWithinAt | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[OrderTopology α] [inst_3 : ConditionallyCompleteLinearOrder β] [inst_4 : TopologicalSpace β] [OrderClosedTopology β]
{f : α → β} {A : Set α},
ContinuousWithinAt f A (sSup A) →
MonotoneOn f A →
A.No... | true |
GroupNorm.instPartialOrder._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : Group E], Function.Injective fun f => ⇑f | false |
ack_ack_lt_ack_max_add_two | Mathlib.Computability.Ackermann | ∀ (m n k : ℕ), ack m (ack n k) < ack (max m n + 2) k | true |
_private.Mathlib.NumberTheory.Padics.PadicNorm.0.padicNorm.nonarchimedean_aux | Mathlib.NumberTheory.Padics.PadicNorm | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ},
padicValRat p q ≤ padicValRat p r → padicNorm p (q + r) ≤ max (padicNorm p q) (padicNorm p r) | true |
Equiv.subtypePreimage._proof_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (p : α → Prop) [inst : DecidablePred p] (x₀ : { a // p a } → β)
(x : { x // x ∘ Subtype.val = x₀ }), (fun a => if h : p a then x₀ ⟨a, h⟩ else ↑x ↑⟨a, h⟩) ∘ Subtype.val = x₀ | false |
ComplexShape.TensorSigns | Mathlib.Algebra.Homology.ComplexShapeSigns | {I : Type u_7} → [AddMonoid I] → ComplexShape I → Type u_7 | true |
derivWithin_of_mem_nhds | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜}, s ∈ nhds x → derivWithin f s x = deriv f x | true |
Std.TreeMap.getD_diff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{fallback : β}, (t₁ \ t₂).getD k fallback = if k ∈ t₂ then fallback else t₁.getD k fallback | true |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.coeff_eq_sum._simp_1_3 | Mathlib.LinearAlgebra.Lagrange | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go_as_denote | Std.Sat.AIG.CNF | ∀ {inv sat? : Bool} (aig : Std.Sat.AIG ℕ) (start : ℕ) (h1 : start < aig.decls.size) (assign1 : ℕ → Bool),
(⟦assign1, { aig := aig, ref := { gate := start, invert := inv, hgate := h1 } }⟧ &&
Std.Sat.AIG.toCNF.State.eval✝ (Std.Sat.AIG.toCNF.cnfSatAssignment✝ aig assign1)
↑(Std.Sat.AIG.toCNF.go✝ aig st... | true |
String.instOrd | Init.Data.Ord.String | Ord String | true |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.Internal.memcmpStr.go.eq_def | Init.Data.String.Pattern.Basic | ∀ (lhs rhs : String) (lstart rstart len : String.Pos.Raw) (h1 : len.offsetBy lstart ≤ lhs.rawEndPos)
(h2 : len.offsetBy rstart ≤ rhs.rawEndPos) (curr : String.Pos.Raw),
String.Slice.Pattern.Internal.memcmpStr.go✝ lhs rhs lstart rstart len h1 h2 curr =
if h : curr < len then
have hl := ⋯;
have hr := ... | true |
CategoryTheory.Abelian.coim._proof_3 | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(f : CategoryTheory.Arrow C), CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.kernel.ι f.hom) | false |
Derivation.liftOfRightInverse | Mathlib.RingTheory.Derivation.Basic | {R : Type u_1} →
{A : Type u_2} →
{M : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : CommRing A] →
[inst_2 : CommRing M] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R M] →
{F : Type u_4} →
[inst_5 : FunLike F A M] →
... | true |
Int32.toInt.eq_1 | Init.Data.SInt.Lemmas | ∀ (i : Int32), i.toInt = i.toBitVec.toInt | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_filter._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
MeasurableEquiv.Set.singleton._proof_5 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} [inst : MeasurableSpace α] (a : α), Measurable ⇑(Equiv.Set.singleton a).symm | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_7 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b ≤ a) = ¬a < b | false |
Opposite.unop_inj_iff | Mathlib.Data.Opposite | ∀ {α : Sort u} (x y : αᵒᵖ), Opposite.unop x = Opposite.unop y ↔ x = y | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.IsUniformInducing.image_hausdorff._simp_1_2 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | false |
BddDistLat.hasForgetToBddLat | Mathlib.Order.Category.BddDistLat | CategoryTheory.HasForget₂ BddDistLat BddLat | true |
CategoryTheory.Adjunction.Triple.isIso_unit_iff_isIso_counit | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t : CategoryTheory.Adjunction.Triple F G H),
CategoryTheory.IsIso t.adj₁.unit ↔ Category... | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.evalPanelWidgets.match_1 | Lean.Widget.UserWidget | (motive : Lean.Widget.PanelWidgetsExtEntry → Sort u_1) →
(e : Lean.Widget.PanelWidgetsExtEntry) →
((n : Lean.Name) → motive (Lean.Widget.PanelWidgetsExtEntry.global n)) →
((wi : Lean.Widget.WidgetInstance) → motive (Lean.Widget.PanelWidgetsExtEntry.local wi)) → motive e | false |
Std.HashMap.Raw.size_ofList | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {l : List (α × β)},
List.Pairwise (fun a b => (a.1 == b.1) = false) l → (Std.HashMap.Raw.ofList l).size = l.length | true |
Partrec.fix | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable σ] {f : α →. σ ⊕ α},
Partrec f → Partrec f.fix | true |
Int.mul_right_comm | Init.Data.Int.Lemmas | ∀ (a b c : ℤ), a * b * c = a * c * b | true |
Finset.Aesop.sigma_nonempty_of_exists_nonempty | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Finset ι} {t : (i : ι) → Finset (α i)},
(∃ i ∈ s, (t i).Nonempty) → (s.sigma t).Nonempty | true |
ConvexCone.instCompleteLattice._proof_5 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] (a b : ConvexCone R M), Lattice.inf a b ≤ b | false |
Polynomial.Splits.splits | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R} [IsDomain R],
f.Splits → f = 0 ∨ ∀ {g : Polynomial R}, Irreducible g → g ∣ f → g.degree ≤ 1 | true |
CategoryTheory.Bicategory.yoneda_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj_toPrelaxFunctor_toPrelaxFunctorStruct_toPrefunctor_obj_α | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (x : B) (y : Bᵒᵖ),
↑((CategoryTheory.Bicategory.yoneda.obj x).obj y) = (Opposite.unop y ⟶ x) | true |
_private.Mathlib.Combinatorics.Extremal.RuzsaSzemeredi.0.ruzsaSzemerediNumberNat_asymptotic_lower_bound._simp_1_4 | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {P : β → Prop},
(∀ᶠ (b : β) in Filter.map m f, P b) = ∀ᶠ (a : α) in f, P (m a) | false |
Cardinal.mk_image_eq_lift | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α),
Function.Injective f → Cardinal.lift.{u, v} (Cardinal.mk ↑(f '' s)) = Cardinal.lift.{v, u} (Cardinal.mk ↑s) | true |
SSet.PtSimplex.MulStruct.δ_succ_castSucc_map_assoc | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i) {Z : SSet} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.succ)
(CategoryTheory.CategoryStruct.comp self.map h) =
CategoryTheory.CategoryStruct.comp... | true |
IsNilpotent.map | Mathlib.RingTheory.Nilpotent.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : MonoidWithZero R] [inst_1 : MonoidWithZero S] {r : R} {F : Type u_3}
[inst_2 : FunLike F R S] [MonoidWithZeroHomClass F R S], IsNilpotent r → ∀ (f : F), IsNilpotent (f r) | true |
Set.inv_range' | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : InvolutiveInv α] {ι : Type u_5} {f : ι → α}, (Set.range f)⁻¹ = Set.range f⁻¹ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.