name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
genLoopEquivOfUnique._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [inst_1 : Unique N] (p : LoopSpace X x),
{ toFun := fun c => p (c default), continuous_toFun := ⋯ } ∈ GenLoop N X x |
Lean.Server.instMonadLiftCancellableMRequestM.match_1 | Lean.Server.Requests | {α : Type} →
(motive : Except Lean.Server.RequestCancellation α → Sort u_1) →
(r : Except Lean.Server.RequestCancellation α) →
((a : Lean.Server.RequestCancellation) → motive (Except.error a)) → ((v : α) → motive (Except.ok v)) → motive r |
CategoryTheory.PrelaxFunctorStruct.map₂ | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : Quiver B] →
[inst_1 : (a b : B) → Quiver (a ⟶ b)] →
{C : Type u₂} →
[inst_2 : Quiver C] →
[inst_3 : (a b : C) → Quiver (a ⟶ b)] →
(self : CategoryTheory.PrelaxFunctorStruct B C) →
{a b : B} → {f g : a ⟶ b} → (f ⟶ g) → (self.map f ⟶ self.map g) |
ArchimedeanClass.closedBallAddSubgroup.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M]
(c : ArchimedeanClass M), c.closedBallAddSubgroup = ArchimedeanClass.addSubgroup (UpperSet.Ici c) |
Std.DTreeMap.Internal.Const.RicSliceData.rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Const.RicSliceData α β → Sort u_1} →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => β) →
(range : Std.Ric α) → motive { treeMap := treeMap, range := range }) →
(t : Std.DTreeMap.Internal.Const.RicSliceData α β) → motive t |
Lean.Data.AC.Variable.mk | Init.Data.AC | {α : Sort u} → {op : α → α → α} → (value : α) → Option (PLift (Std.LawfulIdentity op value)) → Lean.Data.AC.Variable op |
_private.Mathlib.Combinatorics.Additive.ApproximateSubgroup.0.IsApproximateSubgroup.pow_inter_pow_covBySMul_sq_inter_sq._simp_1_10 | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) |
CommRingCat.Colimits.Prequotient.noConfusion | Mathlib.Algebra.Category.Ring.Colimits | {P : Sort u} →
{J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J CommRingCat} →
{t : CommRingCat.Colimits.Prequotient F} →
{J' : Type v} →
{inst' : CategoryTheory.SmallCategory J'} →
{F' : CategoryTheory.Functor J' CommRingCat} →
{t' : CommRingCat.Colimits.Prequotient F'} →
J = J' → inst ≍ inst' → F ≍ F' → t ≍ t' → CommRingCat.Colimits.Prequotient.noConfusionType P t t' |
PartOrd.dual | Mathlib.Order.Category.PartOrd | CategoryTheory.Functor PartOrd PartOrd |
Int.ModEq.prod_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f : α → ℤ} {s : Finset α}, (∀ x ∈ s, f x ≡ 1 [ZMOD n]) → ∏ x ∈ s, f x ≡ 1 [ZMOD n] |
Lean.Parser.Term.stateRefT._regBuiltin.Lean.Parser.Term.macroDollarArg.formatter_11 | Lean.Parser.Term | IO Unit |
CategoryTheory.Adjunction.leftAdjointUniq_trans_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {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 F' F'' : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (adj1 : F ⊣ G) (adj2 : F' ⊣ G) (adj3 : F'' ⊣ G) {Z : CategoryTheory.Functor C D}
(h : F'' ⟶ Z),
CategoryTheory.CategoryStruct.comp (adj1.leftAdjointUniq adj2).hom
(CategoryTheory.CategoryStruct.comp (adj2.leftAdjointUniq adj3).hom h) =
CategoryTheory.CategoryStruct.comp (adj1.leftAdjointUniq adj3).hom h |
_private.Mathlib.MeasureTheory.Integral.PeakFunction.0.tendsto_integral_comp_smul_smul_of_integrable._simp_1_3 | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) |
UInt64.toNat_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt64), (-a).toNat = (UInt64.size - a.toNat) % UInt64.size |
UniqueMDiffWithinAt.preimage_PartialHomeomorph | Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {s : Set M} {x : M},
UniqueMDiffWithinAt I s x →
∀ {e : OpenPartialHomeomorph M M'},
OpenPartialHomeomorph.MDifferentiable I I' e →
x ∈ e.source → UniqueMDiffWithinAt I' (e.target ∩ ↑e.symm ⁻¹' s) (↑e x) |
Aesop.GoalState.toNodeState | Aesop.Tree.Data | Aesop.GoalState → Aesop.NodeState |
MeasureTheory.Measure.FiniteSpanningSetsIn.disjointed_set_eq | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(S : μ.FiniteSpanningSetsIn {s | MeasurableSet s}), S.disjointed.set = disjointed S.set |
NNReal.arith_mean_le_rpow_mean | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → NNReal),
∑ i ∈ s, w i = 1 → ∀ {p : ℝ}, 1 ≤ p → ∑ i ∈ s, w i * z i ≤ (∑ i ∈ s, w i * z i ^ p) ^ (1 / p) |
CategoryTheory.Idempotents.KaroubiFunctorCategoryEmbedding.obj._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {J : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C))
(j : J), (CategoryTheory.CategoryStruct.comp P.p P.p).app j = P.p.app j |
String.isInt | Init.Data.String.Search | String → Bool |
CategoryTheory.Under.forgetCone._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (X : T) ⦃X_1 Y : CategoryTheory.Under X⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const (CategoryTheory.Under X)).obj X).map f) Y.hom =
CategoryTheory.CategoryStruct.comp X_1.hom ((CategoryTheory.Under.forget X).map f) |
CategoryTheory.MonoidalClosed.enrichedCategorySelf_id | Mathlib.CategoryTheory.Monoidal.Closed.Enrichment | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] (X : C), CategoryTheory.eId C X = CategoryTheory.MonoidalClosed.id X |
Lean.Parser.Term.letOptUsedOnly._regBuiltin.Lean.Parser.Term.letOptUsedOnly.docString_1 | Lean.Parser.Term | IO Unit |
Std.DTreeMap.Raw.get!_eq_default | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {a : α} [inst_1 : Inhabited (β a)], a ∉ t → t.get! a = default |
Finset.isScalarTower' | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : DecidableEq γ] [inst_1 : DecidableEq β] [inst_2 : SMul α β]
[inst_3 : SMul α γ] [inst_4 : SMul β γ] [IsScalarTower α β γ], IsScalarTower α (Finset β) (Finset γ) |
_private.Mathlib.LinearAlgebra.Basis.Exact.0.Submodule.linearProjOfIsCompl_comp_bijective_of_exact._simp_1_1 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {p : Submodule R M}, Set.InjOn ⇑f ↑p = Disjoint p f.ker |
Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.MinImports.2495106528._hygCtx._hyg.4 | Mathlib.Tactic.Linter.MinImports | IO (Lean.Option Bool) |
FirstOrder.Language.IsFraisse.is_equiv_invariant | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [h : FirstOrder.Language.IsFraisse K]
{M N : CategoryTheory.Bundled L.Structure}, Nonempty (L.Equiv ↑M ↑N) → (M ∈ K ↔ N ∈ K) |
String.take_eq | Batteries.Data.String.Lemmas | ∀ (s : String) (n : ℕ), String.Legacy.take s n = String.ofList (List.take n s.toList) |
Preord.inv_hom_apply | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (e : X ≅ Y) (x : ↑X),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x |
Batteries.RBSet.upperBound?_mem_toList | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x y : α} {t : Batteries.RBSet α cmp}, t.upperBound? x = some y → y ∈ t.toList |
CategoryTheory.Presheaf.isSheaf_iff_extensiveSheaf_of_projective | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] (F : CategoryTheory.Functor Cᵒᵖ A)
[inst_2 : CategoryTheory.Preregular C] [inst_3 : CategoryTheory.FinitaryExtensive C]
[∀ (X : C), CategoryTheory.Projective X],
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology C) F ↔
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.extensiveTopology C) F |
Frm.Hom.recOn | Mathlib.Order.Category.Frm | {X Y : Frm} →
{motive : X.Hom Y → Sort u_1} → (t : X.Hom Y) → ((hom' : FrameHom ↑X ↑Y) → motive { hom' := hom' }) → motive t |
Polynomial.one_le_cauchyBound._simp_1 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {K : Type u_1} [inst : NormedDivisionRing K] (p : Polynomial K), (1 ≤ p.cauchyBound) = True |
Std.ExtTreeMap.getKey!_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α}, cmp k k' = Ordering.eq → t.getKey! k = t.getKey! k' |
Membership.noConfusionType | Init.Prelude | Sort u_1 → {α : Type u} → {γ : Type v} → Membership α γ → {α' : Type u} → {γ' : Type v} → Membership α' γ' → Sort u_1 |
HahnSeries.SummableFamily.instModule._proof_10 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_4} {R : Type u_2} {V : Type u_5} {α : Type u_3} [inst : AddCommMonoid Γ]
[inst_1 : PartialOrder Γ] [inst_2 : PartialOrder Γ'] [inst_3 : AddAction Γ Γ'] [inst_4 : IsOrderedCancelVAdd Γ Γ']
[inst_5 : Semiring R] [inst_6 : AddCommMonoid V] [inst_7 : Module R V] (x : HahnSeries Γ R)
(x_1 x_2 : HahnSeries.SummableFamily Γ' V α), x • (x_1 + x_2) = x • x_1 + x • x_2 |
Bipointed.toProd | Mathlib.CategoryTheory.Category.Bipointed | (self : Bipointed) → self.X × self.X |
Representation.IntertwiningMap.instAddCommMonoid._proof_8 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommRing A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (a b : ρ.IntertwiningMap σ), a + b = b + a |
String.Pos.Raw.offsetOfPos | Init.Data.String.Basic | String → String.Pos.Raw → ℕ |
Mathlib.Tactic.IntervalCases.Methods.roundDown | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
_private.Lean.Linter.MissingDocs.0.Lean.Linter.MissingDocs.missingDocsExt.match_3 | Lean.Linter.MissingDocs | (motive : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler → Sort u_1) →
(x : Lean.Name × Lean.Name × Lean.Linter.MissingDocs.Handler) →
((n k : Lean.Name) → (h : Lean.Linter.MissingDocs.Handler) → motive (n, k, h)) → motive x |
CentroidHom.applyModule._proof_3 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), f 0 = 0 |
SheafOfModules.Presentation.isColimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] {M : SheafOfModules R}
(P : M.Presentation),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.kernel P.generators.π).freeHomEquiv.symm P.relations.s)
(CategoryTheory.Limits.kernel.ι P.generators.π))
P.generators.π =
0 |
SubmodulesRingBasis.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
{B : ι → Submodule R A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (a : A) (i : ι), ∃ j, a • B j ≤ B i) → (∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) → SubmodulesRingBasis B |
Lean.Server.Test.Runner.Client.InteractiveTermGoal.noConfusionType | Lean.Server.Test.Runner | Sort u →
Lean.Server.Test.Runner.Client.InteractiveTermGoal → Lean.Server.Test.Runner.Client.InteractiveTermGoal → Sort u |
RelSeries.last_drop | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length + 1)), (p.drop i).last = p.last |
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.handleCodeActionResolve.match_3 | Lean.Server.CodeActions.Basic | (motive : Option (IO Lean.Lsp.CodeAction) → Sort u_1) →
(x : Option (IO Lean.Lsp.CodeAction)) →
((lazy : IO Lean.Lsp.CodeAction) → motive (some lazy)) →
((x : Option (IO Lean.Lsp.CodeAction)) → motive x) → motive x |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn._regBuiltin._private.Lean.Meta.Constructions.CtorElim.0.Lean.initFn.docString_1._@.Lean.Meta.Constructions.CtorElim.299025572._hygCtx._hyg.2 | Lean.Meta.Constructions.CtorElim | IO Unit |
Lean.Syntax.TSepArray.mk | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → {sep : String} → Array Lean.Syntax → Lean.Syntax.TSepArray ks sep |
Lean.Int.mkInstHPow | Lean.Expr | Lean.Expr |
ContMDiffSection.toFun | Mathlib.Geometry.Manifold.VectorBundle.SmoothSection | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{M : Type u_4} →
[inst_4 : TopologicalSpace M] →
[inst_5 : ChartedSpace H M] →
{F : Type u_5} →
[inst_6 : NormedAddCommGroup F] →
[inst_7 : NormedSpace 𝕜 F] →
{n : WithTop ℕ∞} →
{V : M → Type u_6} →
[inst_8 : TopologicalSpace (Bundle.TotalSpace F V)] →
[inst_9 : (x : M) → TopologicalSpace (V x)] →
[inst_10 : FiberBundle F V] → ContMDiffSection I F n V → (x : M) → V x |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.hsum._simp_1 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R) (a : Γ),
(a ∈ x.support) = (x.coeff a ≠ 0) |
Finsupp.mapRange.equiv._proof_2 | Mathlib.Data.Finsupp.Defs | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Zero M] [inst_1 : Zero N] (e : M ≃ N) (hf : e 0 = 0)
(x : ι →₀ M), Finsupp.mapRange ⇑e.symm ⋯ (Finsupp.mapRange (⇑e) hf x) = x |
WithTop.instMulZeroOneClass._proof_2 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroOneClass α] [Nontrivial α] (x : WithTop α), x * 1 = x |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_324 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] 1)) <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.MorL | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option Std.Time.Month.Ordinal |
Std.TreeMap.getKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α}
{v : β} {h₁ : a ∈ t.insert k v}, (t.insert k v).getKey a h₁ = if h₂ : cmp k a = Ordering.eq then k else t.getKey a ⋯ |
Submodule.toLocalized' | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_1} →
(S : Type u_2) →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
[inst_6 : Algebra R S] →
[inst_7 : Module S N] →
[inst_8 : IsScalarTower R S N] →
(p : Submonoid R) →
[inst_9 : IsLocalization p S] →
(f : M →ₗ[R] N) →
[inst_10 : IsLocalizedModule p f] →
(M' : Submodule R M) → ↥M' →ₗ[R] ↥(Submodule.localized' S p f M') |
le_sup_iff._simp_3 | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) |
isGLB_ciInf_set | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {f : β → α} {s : Set β},
BddBelow (f '' s) → s.Nonempty → IsGLB (f '' s) (⨅ i, f ↑i) |
Fin.one_eq_zero_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n], 1 = 0 ↔ n = 1 |
Finset.attach_empty | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1}, ∅.attach = ∅ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.filter_equiv_self_iff._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel |
Finset.exists_subsuperset_card_eq | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s t : Finset α} {n : ℕ}, s ⊆ t → s.card ≤ n → n ≤ t.card → ∃ u, s ⊆ u ∧ u ⊆ t ∧ u.card = n |
SheafOfModules.mk.noConfusion | Mathlib.Algebra.Category.ModuleCat.Sheaf | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
{P : Sort u_1} →
{val : PresheafOfModules R.val} →
{isSheaf : CategoryTheory.Presheaf.IsSheaf J val.presheaf} →
{val' : PresheafOfModules R.val} →
{isSheaf' : CategoryTheory.Presheaf.IsSheaf J val'.presheaf} →
{ val := val, isSheaf := isSheaf } = { val := val', isSheaf := isSheaf' } → (val ≍ val' → P) → P |
Orientation.rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)), o.rotation ↑(Real.pi / 2) = o.rightAngleRotation |
MeasureTheory.Measure.isAddLeftInvariant_eq_smul_of_innerRegular | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsAddLeftInvariant]
[μ.InnerRegular] [μ'.InnerRegular], μ' = μ'.addHaarScalarFactor μ • μ |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ring.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_4 : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.IneqCnstrProof) →
t.ctorIdx = 2 →
((c : Lean.Meta.Grind.Arith.Linear.RingIneqCnstr) →
(lhs : Lean.Meta.Grind.Arith.Linear.LinExpr) →
motive_4 (Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ring c lhs)) →
motive_4 t |
String.posGE_eq_posGE_toSlice | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} (h : p ≤ s.rawEndPos), s.posGE p h = String.Pos.ofToSlice (s.toSlice.posGE p ⋯) |
LaurentPolynomial.trunc | Mathlib.Algebra.Polynomial.Laurent | {R : Type u_1} → [inst : Semiring R] → LaurentPolynomial R →+ Polynomial R |
CategoryTheory.Oplax.OplaxTrans.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Hom η θ} →
{B' : Type u₁} →
{inst' : CategoryTheory.Bicategory B'} →
{C' : Type u₂} →
{inst'_1 : CategoryTheory.Bicategory C'} →
{F' G' : CategoryTheory.OplaxFunctor B' C'} →
{η' θ' : F' ⟶ G'} →
{t' : CategoryTheory.Oplax.OplaxTrans.Hom η' θ'} →
B = B' →
inst ≍ inst' →
C = C' →
inst_1 ≍ inst'_1 →
F ≍ F' →
G ≍ G' →
η ≍ η' →
θ ≍ θ' → t ≍ t' → CategoryTheory.Oplax.OplaxTrans.Hom.noConfusionType P t t' |
_private.Mathlib.Order.Filter.FilterProduct.0.Filter.Germ.coe_lt._simp_1_4 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {f : Ultrafilter α} {p : α → Prop}, (∀ᶠ (x : α) in ↑f, ¬p x) = ¬∀ᶠ (x : α) in ↑f, p x |
NumberField.mixedEmbedding.unitSMul_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ) (x : NumberField.mixedEmbedding.mixedSpace K),
u • x = (NumberField.mixedEmbedding K) ((algebraMap (NumberField.RingOfIntegers K) K) ↑u) * x |
CategoryTheory.mateEquiv_conjugateEquiv_vcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D}
{L₁ : CategoryTheory.Functor A B} {R₁ : CategoryTheory.Functor B A} {L₂ : CategoryTheory.Functor C D}
{R₂ : CategoryTheory.Functor D C} {L₃ : CategoryTheory.Functor C D} {R₃ : CategoryTheory.Functor D C} (adj₁ : L₁ ⊣ R₁)
(adj₂ : L₂ ⊣ R₂) (adj₃ : L₃ ⊣ R₃) (α : CategoryTheory.TwoSquare G L₁ L₂ H) (β : L₃ ⟶ L₂),
(CategoryTheory.mateEquiv adj₁ adj₃) (α.whiskerRight β) =
((CategoryTheory.mateEquiv adj₁ adj₂) α).whiskerBottom ((CategoryTheory.conjugateEquiv adj₂ adj₃) β) |
BitVec.smod_eq | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w),
x.smod y =
match x.msb, y.msb with
| false, false => x.umod y
| false, true =>
have u := x.umod (-y);
if u = 0#w then u else u + y
| true, false =>
have u := (-x).umod y;
if u = 0#w then u else y - u
| true, true => -(-x).umod (-y) |
spectrum.subset_subalgebra | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [inst_4 : SubringClass S A] [inst_5 : SMulMemClass S R A] {s : S} (a : ↥s),
spectrum R ↑a ⊆ spectrum R a |
IsPrimitiveRoot.isIntegral | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K}, IsPrimitiveRoot μ n → 0 < n → IsIntegral ℤ μ |
Equiv.nonUnitalCommSemiring._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β], e (e.symm 0) = 0 |
QPF.fixToW._proof_1 | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u_1 → Type u_1} [q : QPF F] (x y : (QPF.P F).W),
QPF.Wequiv x y → QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) x = QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) y |
FiberBundleCore.localTrivAsPartialEquiv_target | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι), (Z.localTrivAsPartialEquiv i).target = (Z.localTriv i).target |
_private.Mathlib.Geometry.Manifold.ContMDiff.Constructions.0.contMDiffWithinAt_pi_space._simp_1_4 | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.cocone_nonempty._simp_1_4 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) |
_private.Init.Data.UInt.Bitwise.0.UInt64.zero_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) |
Lean.Omega.IntList.gcd_eq_zero._simp_1 | Init.Omega.IntList | ∀ {xs : Lean.Omega.IntList}, (xs.gcd = 0) = ∀ x ∈ xs, x = 0 |
Ring.DirectLimit.lift_of | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) (i : ι) (x : G i),
(Ring.DirectLimit.lift G f P g Hg) ((Ring.DirectLimit.of G f i) x) = (g i) x |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.casesOn | Lean.Meta.InferType | {motive : Lean.Meta.ArrowPropResult✝ → Sort u} →
(t : Lean.Meta.ArrowPropResult✝¹) →
motive Lean.Meta.ArrowPropResult.false✝ →
motive Lean.Meta.ArrowPropResult.true✝ →
motive Lean.Meta.ArrowPropResult.undef✝ → ((idx : ℕ) → motive (Lean.Meta.ArrowPropResult.bvar✝ idx)) → motive t |
CategoryTheory.Monad.monadicOfHasPreservesReflexiveCoequalizersOfReflectsIsomorphisms._proof_1 | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D}
(adj : F ⊣ G) [CategoryTheory.Limits.HasReflexiveCoequalizers D] [G.ReflectsIsomorphisms]
[CategoryTheory.Monad.PreservesColimitOfIsReflexivePair G], (CategoryTheory.Monad.comparison adj).IsEquivalence |
sigmaFinsuppEquivDFinsupp_symm_apply | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {η : ι → Type u_4} {N : Type u_5} [inst : Zero N] (f : Π₀ (i : ι), η i →₀ N) (s : (i : ι) × η i),
(sigmaFinsuppEquivDFinsupp.symm f) s = (f s.fst) s.snd |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_14 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
¬-1 * ↑i + ↑a.size ≤ 0 →
¬↑i + -1 * ↑(min j (a ++ b).size) ≤ 0 →
((a ++ b).extract i j).size = (a.extract i j).size →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size |
UInt8.ofBitVec_shiftRight_mod | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8) (b : ℕ), { toBitVec := a >>> (b % 8) } = { toBitVec := a } >>> UInt8.ofNat b |
Std.Time.TimeZone.convertTZif | Std.Time.Zoned.Database.Basic | Std.Time.TimeZone.TZif.TZif → String → Except String Std.Time.TimeZone.ZoneRules |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.Structured.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : Lean.Json.Structured → Sort u_1) →
(x : Lean.Json.Structured) →
((a : Array Lean.Json) → motive (Lean.Json.Structured.arr a)) →
((o : Std.TreeMap.Raw String Lean.Json compare) → motive (Lean.Json.Structured.obj o)) → motive x |
CategoryTheory.SmallObject.SuccStruct.isColimitIterationCocone | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] →
CategoryTheory.Limits.IsColimit (Φ.iterationCocone J) |
ULift.group._proof_6 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Group α] (x : ULift.{u_1, u_2} α) (x_1 : ℤ), Equiv.ulift (x ^ x_1) = Equiv.ulift (x ^ x_1) |
WithBot.unbotD_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] (d : α), WithBot.unbotD d 0 = 0 |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_11 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k < ↑i - 1 → ¬↑k + 1 < ↑j → ↑k < ↑j → ↑k < ↑i → ↑k + 1 + 1 = ↑k |
BddAbove.smul_of_nonpos | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [inst_3 : AddCommGroup β]
[inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β] {s : Set β} {a : α},
a ≤ 0 → BddAbove s → BddBelow (a • s) |
Orientation.norm_div_tan_oangle_sub_left_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖y‖ / (o.oangle (x - y) x).tan = ‖x‖ |
Sym2.fromRelOrderEmbedding._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (r : { r // Symmetric r }), Symmetric ↑r |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.