name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Order.Frame.recOn | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
{motive : Order.Frame α → Sort u} →
(t : Order.Frame α) →
([toCompleteLattice : CompleteLattice α] →
[toHImp : HImp α] →
(le_himp_iff : ∀ (a b c : α), a ≤ b ⇨ c ↔ a ⊓ b ≤ c) →
[toCompl : Compl α] →
(himp_bot : ∀ (a : α), a ⇨ ⊥ = aᶜ) →
... | null | false |
_private.Mathlib.Topology.TietzeExtension.0.BoundedContinuousFunction.exists_extension_forall_exists_le_ge_of_isClosedEmbedding._simp_1_1 | Mathlib.Topology.TietzeExtension | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
max_sub_sub_right | Mathlib.Algebra.Order.Group.MinMax | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
max (a - c) (b - c) = max a b - c | null | true |
CategoryTheory.MonoOver.liftIso | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{Y : D} →
{F₁ F₂ : CategoryTheory.Functor (CategoryTheory.Over Y) (CategoryTheory.Over X)} →
(h₁ :
∀ (f : Cate... | Isomorphic functors `Over Y ⥤ Over X` lift to isomorphic functors `MonoOver Y ⥤ MonoOver X`.
| true |
CategoryTheory.instCategoryTransportEnrichment._aux_1 | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | {V : Type u_5} →
[inst : CategoryTheory.Category.{u_3, u_5} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
(C : Type u_2) →
[CategoryTheory.Category.{u_1, u_2} C] →
{W : Type u_6} →
[inst_3 : CategoryTheory.Category.{u_4, u_6} W] →
[inst_4 : CategoryTheory.Mo... | null | false |
StieltjesFunction.measure_botSet | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R], f.measure botSet = 0 | null | true |
CategoryTheory.RelCat.rel_iso_iff | Mathlib.CategoryTheory.Category.RelCat | ∀ {X Y : CategoryTheory.RelCat} (r : X ⟶ Y),
CategoryTheory.IsIso r ↔ ∃ f, CategoryTheory.RelCat.graphFunctor.map f.hom = r | A relation is an isomorphism in `RelCat` iff it is the image of an isomorphism in
`Type u`. | true |
Int.negSucc_mul_ofNat | Init.Data.Int.Lemmas | ∀ (m n : ℕ), Int.negSucc m * ↑n = -↑(m.succ * n) | null | true |
_private.Lean.Parser.Syntax.0.Lean.Parser.Syntax.unary._regBuiltin.Lean.Parser.Syntax.unary.formatter_7 | Lean.Parser.Syntax | IO Unit | null | false |
_private.Mathlib.Order.BooleanSubalgebra.0.BooleanSubalgebra.mem_closure_iff_sup_sdiff.match_1_1 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {s : Set α} (t : Finset (↑s × ↑s))
(motive : (∃ t_1, (t.sup fun x => ↑x.1 \ ↑x.2)ᶜ = t_1.sup fun x => ↑x.1 \ ↑x.2) → Prop)
(x : ∃ t_1, (t.sup fun x => ↑x.1 \ ↑x.2)ᶜ = t_1.sup fun x => ↑x.1 \ ↑x.2),
(∀ (tc : Finset (↑s × ↑s)) (eq : (t.sup fun x => ↑x.1 \ ↑x.2)ᶜ = tc.sup f... | null | false |
RingOfIntegers.ZModXQuotSpanEquivQuotSpanPair._proof_9 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K} {p : ℕ} {Q : Polynomial ℤ},
(Ideal.span {↑p} ⊔ Ideal.span {(Polynomial.aeval θ) Q}).IsTwoSided | null | false |
Set.forall_mem_const | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s : Set α} {p : Prop} [Nonempty ↑s], (∀ x ∈ s, p) ↔ p | null | true |
_private.Init.Data.Range.Polymorphic.Map.0.Std.PRange.LawfulUpwardEnumerableLT.ofMap._simp_1_1 | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
Lean.PrettyPrinter.categoryParenthesizerAttribute | Lean.PrettyPrinter.Parenthesizer | Lean.KeyedDeclsAttribute Lean.PrettyPrinter.CategoryParenthesizer | Registers a parenthesizer for a syntax category.
`@[category_parenthesizer cat]` registers a declaration of type
`Lean.PrettyPrinter.CategoryParenthesizer` for the syntax category `cat`, which is used when
parenthesizing occurrences of `cat:prec` (`categoryParser cat prec`). Implementations should call
`maybeParenthes... | true |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology._proof_16 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X] (B : Set (Set X)),
Maximal (fun x => x ∈ {P | P ⊆ constructibleTopologySubbasis X ∧ (∀ Q ⊆ P, Q.Finite → (⋂₀ Q).Nonempty) ∧ ⋂₀ P = ∅})
B →
∀ (Y₁ Y₂ : Set X), ∀ A₁ ⊆ insert Y₁ B, ∀ A₂ ⊆ insert Y₂ B, A₁ \ {Y₁} ∪ A₂ \ {Y₂} ⊆ constructibleTopologySubbasis X | null | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyze.analyzeLet | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit | null | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Complex.norm_sub_eq_norm_sub_of_isMinOn._simp_1_1 | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a * a ^ n = a ^ (n + 1) | null | false |
CategoryTheory.GrothendieckTopology.W.isLocallySurjective | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] {FA : A → A → Type u_1} {CA : A → Type w'}
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_3 : CategoryTheory.ConcreteCategory A FA]
[J.WEqua... | null | true |
CategoryTheory.ShiftedHom.map_smul | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {M : Type u_4} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : CategoryTheory.HasShift D M] {X Y : C} {R : Type u_5}
[inst_5 : Ring R] [inst_6 : CategoryTheory.Prea... | null | true |
Module.End.instDivisionRing._proof_2 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Module.End R M)] [inst_4 : IsSimpleModule R M] (a : Module.End R M), a ^ 0 = 1 | null | false |
Lean.Grind.CommRing.Mon.denote_concat | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (m₁ m₂ : Lean.Grind.CommRing.Mon),
Lean.Grind.CommRing.Mon.denote ctx (m₁.concat m₂) =
Lean.Grind.CommRing.Mon.denote ctx m₁ * Lean.Grind.CommRing.Mon.denote ctx m₂ | null | true |
TrivialStar.isStarNormal | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : StarMul R] [TrivialStar R] {x : R}, IsStarNormal x | null | true |
OpenNormalAddSubgroup.instInfOpenNormalAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → Min (OpenNormalAddSubgroup G) | null | true |
linearOrderOfSTO._proof_2 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [inst : IsStrictTotalOrder α r] (x y : α), x ≤ y ∨ y ≤ x | null | false |
CategoryTheory.Under.eqToHom_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {f g : CategoryTheory.Under X} (h : f = g),
CategoryTheory.Under.Hom.right (CategoryTheory.eqToHom h) = CategoryTheory.eqToHom ⋯ | null | true |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.EuclideanGeometry.existsUnique_dist_eq_of_insert._proof_1_2 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : AffineSubspace ℝ P} [inst_4 : s.direction.HasOrthogonalProjection] {p : P}
(this : Nonempty ↥s) (cc : P) (cr : ℝ),
dist p ↑((EuclideanGeometry.orthogonalProje... | null | false |
associatedPrimes | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | (R : Type u_1) → [inst : CommSemiring R] → (M : Type u_2) → [inst_1 : AddCommMonoid M] → [Module R M] → Set (Ideal R) | The set of associated primes of a module. | true |
preNormEDS'.eq_4 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] (b c d : R), preNormEDS' b c d 3 = c | null | true |
Std.ExtDHashMap.isSome_getKey?_iff_mem._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) | null | false |
_private.Mathlib.Data.List.AList.0.AList.union_assoc._simp_1_1 | Mathlib.Data.List.AList | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
CategoryTheory.Limits.IndObjectPresentation.yoneda_I | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.Limits.IndObjectPresentation.yoneda X).I = CategoryTheory.Discrete PUnit.{v + 1} | null | true |
DirectLimit.Ring.of._proof_2 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(f : (x x_1 : ι) → (h : x ≤ x_1) → T h) [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | null | false |
Seminorm.ext | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E]
{p q : Seminorm 𝕜 E}, (∀ (x : E), p x = q x) → p = q | null | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.merge.eq_def | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (le : α → α → Bool) (x x_1 : Batteries.BinomialHeap.Imp.Heap α),
Batteries.BinomialHeap.Imp.Heap.merge le x x_1 =
match x, x_1 with
| Batteries.BinomialHeap.Imp.Heap.nil, h => h
| h, Batteries.BinomialHeap.Imp.Heap.nil => h
| s₁@h:(Batteries.BinomialHeap.Imp.Heap.cons r₁ a₁ n₁ t₁),
... | null | true |
Topology.CWComplex.OneSkeletonGraph.not_exists_isLoopAt_iff_nontrivial | Mathlib.Topology.CWComplex.Classical.Graph | ∀ {X : Type u_1} [inst : TopologicalSpace X] {C : Set X} [inst_1 : Topology.CWComplex C]
(e : Topology.RelCWComplex.cell C 1),
(¬∃ x, (Topology.CWComplex.OneSkeletonGraph C).IsLoopAt e x) ↔ (Topology.RelCWComplex.cellFrontier 1 e).Nontrivial | null | true |
CategoryTheory.Presieve.Arrows.pullbackCompatible_iff | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.Functor Cᵒᵖ (Type w)) {B : C}
{I : Type u_1} {X : I → C} (π : (i : I) → X i ⟶ B)
[inst_1 : (CategoryTheory.Presieve.ofArrows X π).HasPairwisePullbacks] (x : (i : I) → P.obj (Opposite.op (X i))),
CategoryTheory.Presieve.Arrows.Compatib... | null | true |
Algebra.PreSubmersivePresentation.isUnit_jacobian_iff_aevalDifferential_bijective | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ) [inst_3 : Finite σ],
IsUnit P.jacobian ↔ Function.Bijective ⇑P.aevalDifferential | null | true |
BialgEquiv.noConfusion | Mathlib.RingTheory.Bialgebra.Equiv | {P : Sort u_1} →
{R : Type u} →
{inst : CommSemiring R} →
{A : Type v} →
{B : Type w} →
{inst_1 : Semiring A} →
{inst_2 : Semiring B} →
{inst_3 : Algebra R A} →
{inst_4 : Algebra R B} →
{inst_5 : CoalgebraStruct R A} →
... | null | false |
CategoryTheory.Subobject.le_of_comm | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B}
(f : CategoryTheory.Subobject.underlying.obj X ⟶ CategoryTheory.Subobject.underlying.obj Y),
CategoryTheory.CategoryStruct.comp f Y.arrow = X.arrow → X ≤ Y | null | true |
ZFSet.coeEquiv | Mathlib.SetTheory.ZFC.Class | ZFSet.{u} ≃ { s // Small.{u, u + 1} ↑s } | `SetLike.coe` as an equivalence. | true |
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_laxMonoidalToMon_obj_mul | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.Mon C),
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.mul (CategoryTheory.CategoryStruct.id F.X) | null | true |
Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred.recOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.C... | null | false |
MulAction.selfEquivSigmaOrbitsQuotientStabilizer'.eq_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (G : Type u) (X : Type v) [inst : Group G] [inst_1 : MulAction G X] {φ : Quotient (MulAction.orbitRel G X) → X}
(hφ : Function.LeftInverse Quotient.mk'' φ),
MulAction.selfEquivSigmaOrbitsQuotientStabilizer' G X hφ =
Trans.trans (MulAction.selfEquivSigmaOrbits' G X)
(Equiv.sigmaCongrRight fun ω => (Set.e... | null | true |
Primrec₂.unpaired' | Mathlib.Computability.Primrec.Basic | ∀ {f : ℕ → ℕ → ℕ}, Nat.Primrec (Nat.unpaired f) ↔ Primrec₂ f | null | true |
Lean.Elab.Term.Quotation.HeadCheck.unconditional.sizeOf_spec | Lean.Elab.Quotation | sizeOf Lean.Elab.Term.Quotation.HeadCheck.unconditional = 1 | null | true |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_singleton_iff_mapClusterPt._simp_1_4 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
BiheytingHom.noConfusion | Mathlib.Order.Heyting.Hom | {P : Sort u} →
{α : Type u_6} →
{β : Type u_7} →
{inst : BiheytingAlgebra α} →
{inst_1 : BiheytingAlgebra β} →
{t : BiheytingHom α β} →
{α' : Type u_6} →
{β' : Type u_7} →
{inst' : BiheytingAlgebra α'} →
{inst'_1 : BiheytingAlgebr... | null | false |
ConvexOn.hasDerivWithinAt_rightDeriv_of_mem_interior | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x : ℝ},
ConvexOn ℝ S f → x ∈ interior S → HasDerivWithinAt f (derivWithin f (Set.Ioi x) x) (Set.Ioi x) x | null | true |
Lean.Grind.CommRing.Expr.add.elim | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) → t.ctorIdx = 5 → ((a b : Lean.Grind.CommRing.Expr) → motive (a.add b)) → motive t | null | false |
_private.Mathlib.Topology.Order.Monotone.0.MonotoneOn.tendsto_nhdsWithin_Ioo_left._simp_1_1 | Mathlib.Topology.Order.Monotone | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
Batteries.BinaryHeap.mem_singleton | Batteries.Data.BinaryHeap.Lemmas | ∀ {α : Type u_1} {y : α} [inst : Ord α] {x : α}, x ∈ Batteries.BinaryHeap.singleton y ↔ x = y | null | true |
_private.Init.Data.BitVec.Bootstrap.0.BitVec.getElem_cons._proof_1_1 | Init.Data.BitVec.Bootstrap | ∀ {n i : ℕ}, i < n → n ≤ i → False | null | false |
_private.Mathlib.Util.TermReduce.0.Mathlib.Util.TermReduce.elabDelta.match_1 | Mathlib.Util.TermReduce | (motive : Option Lean.Expr → Sort u_1) →
(__x : Option Lean.Expr) → ((t : Lean.Expr) → motive (some t)) → ((x : Option Lean.Expr) → motive x) → motive __x | null | false |
_private.Lean.Data.Json.Basic.0.Lean.instHashableJsonNumber.hash.match_1 | Lean.Data.Json.Basic | (motive : Lean.JsonNumber → Sort u_1) →
(x : Lean.JsonNumber) → ((a : ℤ) → (a_1 : ℕ) → motive { mantissa := a, exponent := a_1 }) → motive x | null | false |
MeasureTheory.Content.rec | Mathlib.MeasureTheory.Measure.Content | {G : Type w} →
[inst : TopologicalSpace G] →
{motive : MeasureTheory.Content G → Sort u} →
((toFun : TopologicalSpace.Compacts G → NNReal) →
(mono' : ∀ (K₁ K₂ : TopologicalSpace.Compacts G), ↑K₁ ⊆ ↑K₂ → toFun K₁ ≤ toFun K₂) →
(sup_disjoint' :
∀ (K₁ K₂ : TopologicalSpace... | null | false |
_private.Lean.Meta.ExprLens.0.Lean.Meta.lensCoord._sparseCasesOn_1 | Lean.Meta.ExprLens | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name... | null | false |
Lean.Linter.LinterOptions.rec | Lean.Linter.Init | {motive : Lean.Linter.LinterOptions → Sort u} →
((toOptions : Lean.Options) →
(linterSets : Lean.Linter.LinterSets) → motive { toOptions := toOptions, linterSets := linterSets }) →
(t : Lean.Linter.LinterOptions) → motive t | null | false |
_private.Mathlib.Topology.UniformSpace.Basic.0.«term_∘₂_» | Mathlib.Topology.UniformSpace.Basic | Lean.TrailingParserDescr | null | true |
CategoryTheory.Limits.limit.toStructuredArrow._proof_4 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasLimit F] {X Y Z : J} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.StructuredArrow.homMk (CategoryTheory.CategoryStruct.comp f... | null | false |
_private.Init.Data.Order.Lemmas.0.Std.lt_of_le_of_ne._simp_1_2 | Init.Data.Order.Lemmas | ∀ {a : Prop}, (a → False) = ¬a | null | false |
unary_relation_sInf_iff | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_8} (s : Set (α → Prop)) {a : α}, sInf s a ↔ ∀ r ∈ s, r a | null | true |
ContinuousENorm.rec | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
[inst : TopologicalSpace E] →
{motive : ContinuousENorm E → Sort u} →
([toENorm : ENorm E] →
(continuous_enorm : Continuous enorm) → motive { toENorm := toENorm, continuous_enorm := continuous_enorm }) →
(t : ContinuousENorm E) → motive t | null | false |
Std.Time.DateTime.toPlainDate | Std.Time.Zoned | Std.Time.DateTime → Std.Time.PlainDate | Converts a `DateTime` to a `PlainDate`
| true |
Submodule.reflection_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection],
Kᗮ.reflection = K.reflection.trans (LinearIsometryEquiv.neg 𝕜) | null | true |
ContinuousLinearMap.analyticOn_uncurry_of_multilinear | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {ι : Type u_5}
{Em : ι → Type u_6} [inst_5 : (i : ι) → NormedAddCommGroup (Em i)] [inst_6 : (i : ι) → NormedSpac... | null | true |
Real.HolderTriple.of_pos | Mathlib.Basic.Real.ConjExponents | ∀ {p q : ℝ}, 0 < p → 0 < q → p.HolderTriple q (p⁻¹ + q⁻¹)⁻¹ | null | true |
CategoryTheory.Bicategory.Adj.lIso._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {adj₁ adj₂ : a ⟶ b}
(e : adj₁ ≅ adj₂), CategoryTheory.CategoryStruct.comp e.hom.τl e.inv.τl = CategoryTheory.CategoryStruct.id adj₁.l | null | false |
List.rtakeWhile_idempotent | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.rtakeWhile p (List.rtakeWhile p l) = List.rtakeWhile p l | null | true |
PowerBasis.ofAdjoinEqTop_dim | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_1} {S : Type u_2} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S] {x : S}
(hx : IsIntegral K x) (hx' : K[x] = ⊤), (PowerBasis.ofAdjoinEqTop hx hx').dim = (minpoly K x).natDegree | null | true |
Nat.modCore_eq | Init.Data.Nat.Div.Basic | ∀ (x y : ℕ), x.modCore y = if 0 < y ∧ y ≤ x then (x - y).modCore y else x | null | true |
Vector.getElem_set | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {x : α} (hi : i < n) {j : ℕ} (hj : j < n),
(xs.set i x hi)[j] = if i = j then x else xs[j] | null | true |
Ordinal.bsup'_eq_iSup | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_3} (r : ι → ι → Prop) [inst : IsWellOrder ι r] (f : ι → Ordinal.{max u_3 u_4}),
(Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = iSup f | null | true |
CategoryTheory.IsCardinalFiltered.mk | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
(∀ {A : Type w} [inst_2 : CategoryTheory.SmallCategory A] (F : CategoryTheory.Functor A J),
HasCardinalLT (CategoryTheory.Arrow A) κ → Nonempty (CategoryTheory.Limits.Cocone F)) →
CategoryTheory.IsCardin... | null | true |
DifferentiableWithinAt.smul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{s : Set E} {𝕜' : Type u_4} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module ... | null | true |
Equiv.injective_pointReflection_left_of_injective_two_nsmul | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_5} {P : Type u_6} [inst : AddCommGroup G] [inst_1 : AddTorsor G P],
(Function.Injective fun x => 2 • x) → ∀ (y : P), Function.Injective fun x => (Equiv.pointReflection x) y | null | true |
_private.Init.GrindInstances.Ring.UInt.0.UInt16.intCast_ofNat._simp_1_2 | Init.GrindInstances.Ring.UInt | ∀ (a : ℕ), (a ∣ a) = True | null | false |
CategoryTheory.Limits.coconeOfCoconeFiberwiseColimit_pt | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
{G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H}
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F... | null | true |
BesselPotentialSpace.mk.noConfusion | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | {E : Type u_1} →
{F : Type u_2} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedAddCommGroup F} →
{inst_2 : InnerProductSpace ℝ E} →
{inst_3 : FiniteDimensional ℝ E} →
{inst_4 : MeasurableSpace E} →
{inst_5 : BorelSpace E} →
{inst_6 : CompleteSpa... | null | false |
ENat.recTopCoe_natCast | Mathlib.Data.ENat.Defs | ∀ {C : ℕ∞ → Sort u_1} (d : C ⊤) (f : (a : ℕ) → C ↑a) (x : ℕ), ENat.recTopCoe d f ↑x = f x | null | true |
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.basisProd._proof_7 | Mathlib.Algebra.Lie.Basis.Prod | ∀ {ι₁ : Type u_1} {ι₂ : Type u_5} {L₁ : Type u_2} {L₂ : Type u_3} [inst : Finite ι₁] [inst_1 : Finite ι₂] (eι : ι₁ ≃ ι₂)
[inst_2 : LieRing L₁] [inst_3 : LieRing L₂] {R : Type u_4} [inst_4 : CommRing R] [inst_5 : LieAlgebra R L₁]
{H₁ : LieSubalgebra R L₁} (b₁ : LieAlgebra.Basis ι₁ H₁) [inst_6 : LieAlgebra R L₂] {H₂ ... | null | false |
SSet.HomotopyCategory.hom_rec | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {X : SSet} {motive : {x y : X.HomotopyCategory} → (x ⟶ y) → Prop},
(∀ {x y : X.obj (Opposite.op { len := 0 })} (e : SSet.Edge x y), motive (SSet.HomotopyCategory.homMk e)) →
(∀ {x y z : X.HomotopyCategory} (f : x ⟶ y) (g : y ⟶ z),
motive f → motive g → motive (CategoryTheory.CategoryStruct.comp f g)) →
... | Induction principle for morphisms in the homotopy category of a simplicial set:
in order to prove a property for all morphisms, its suffices to prove the property for
morphisms induced by an edge and that the property is stable by composition. | true |
IsUpperModularLattice.casesOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsUpperModularLattice α → Sort u} →
(t : IsUpperModularLattice α) →
((covBy_sup_of_inf_covBy : ∀ {a b : α}, a ⊓ b ⋖ a → b ⋖ a ⊔ b) → motive ⋯) → motive t | null | false |
AlgHomClass.toRingHom_toAlgHom | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {F : Type u_4} [inst_5 : FunLike F A B] [inst_6 : AlgHomClass F R A B]
(f : F), ↑↑f = ↑f | **Alias** of `AlgHomClass.toRingHom_ofClass`. | true |
Vector.flatMap.eq_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {m : ℕ} (xs : Vector α n) (f : α → Vector β m),
xs.flatMap f = Vector.mk (Array.flatMap (fun a => (f a).toArray) xs.toArray) ⋯ | null | true |
Lean.Lsp.instInhabitedResolvableCompletionItem.default | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ResolvableCompletionItem | null | true |
Std.DTreeMap.Internal.Impl.getKey!_inter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k : α},
(m₁.inter! m₂).getKey! k = if Std.DTreeMap.Internal.Impl.contains k m₂ = true then m₁.getKey! k else default | null | true |
MonadFinally.mk.noConfusion | Init.Control.Except | {m : Type u → Type v} →
{P : Sort u_1} →
{tryFinally' tryFinally'' : {α β : Type u} → m α → (Option α → m β) → m (α × β)} →
{ tryFinally' := tryFinally' } = { tryFinally' := tryFinally'' } → (tryFinally' ≍ tryFinally'' → P) → P | null | false |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.atEnd.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.atEnd = decide (i.byteIdx ≥ s.rawEndPos.byteIdx) | null | true |
Order.succ_iterate | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddMonoidWithOne α] [inst_2 : SuccAddOrder α] (x : α) (n : ℕ),
Order.succ^[n] x = x + ↑n | null | true |
instStreamRawChar | Init.Data.String.Stream | Std.Stream Substring.Raw Char | null | true |
ProbabilityTheory.map_eq_of_forall_ae_eq | Mathlib.Probability.Process.FiniteDimensionalLaws | ∀ {T : Type u_1} {Ω : Type u_2} {𝓧 : T → Type u_3} {mΩ : MeasurableSpace Ω} {mα : (t : T) → MeasurableSpace (𝓧 t)}
{X Y : (t : T) → Ω → 𝓧 t} {P : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure P],
AEMeasurable (fun ω x => X x ω) P →
AEMeasurable (fun ω x => Y x ω) P →
(∀ (t : T), X t =ᵐ[P] Y t... | If two processes are modifications of each other, then they have the same distribution. | true |
Set.fintypeLENat | Mathlib.Data.Set.Finite.Basic | (n : ℕ) → Fintype ↑{i | i ≤ n} | null | true |
StarAlgebra.adjoin_mono | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {s t : Set A},
s ⊆ t → StarAlgebra.adjoin R s ≤ StarAlgebra.adjoin R t | null | true |
ContMDiffWithinAt.mpullback_vectorField_of_mem_nhdsWithin_of_eq | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSp... | The pullback of a `C^m` vector field by a `C^n` function with invertible derivative and
with `m + 1 ≤ n` is `C^m`.
Version within a set at a point, but with full pullback. | true |
Lean.Lsp.TextDocumentIdentifier._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → ℕ | null | false |
FinVec.Forall._sunfold | Mathlib.Data.Fin.Tuple.Reflection | {α : Type u_1} → {m : ℕ} → ((Fin m → α) → Prop) → Prop | null | false |
Mathlib.Tactic.Ring.RingCompute.isOne | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{x : Q(«$α»)} → Mathlib.Tactic.Ring.RatCoeff x → Option Q(Mathlib.Meta.NormNum.IsNat «$x» 1) | Decide if `x` is 1 and provide a proof if so. | true |
Vector._sizeOf_1 | Init.Data.Vector.Basic | {α : Type u} → {n : ℕ} → [SizeOf α] → Vector α n → ℕ | null | false |
MeasureTheory.NullMeasurableSet.fundamentalInterior | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] (s : Set α) [Countable G]
[inst_3 : MeasurableSpace α] [MeasurableConstSMul G α] {μ : MeasureTheory.Measure α}
[MeasureTheory.SMulInvariantMeasure G α μ],
MeasureTheory.NullMeasurableSet s μ → MeasureTheory.NullMeasurableSet (MeasureTheory.... | null | true |
Lean.Meta.Grind.AC.State.mk.inj | Lean.Meta.Tactic.Grind.AC.Types | ∀ {structs : Array Lean.Meta.Grind.AC.Struct} {opIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)}
{exprToOpIds : Lean.PHashMap Lean.Meta.Sym.ExprPtr (List ℕ)} {steps : ℕ} {structs_1 : Array Lean.Meta.Grind.AC.Struct}
{opIdOf_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)}
{exprToOpIds_1 : Lean.PHashMap ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.