name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.getLHS | Lean.Meta.Tactic.Grind.EMatch | Array Lean.Expr → ℕ → Lean.MetaM Lean.Expr | null | true |
CategoryTheory.coeMonad | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Coe (CategoryTheory.Monad C) (CategoryTheory.Functor C C) | null | true |
_private.Batteries.Recycling.MonadSatisfying.Array.0.cond.match_1.eq_2 | Batteries.Recycling.MonadSatisfying.Array | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | null | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.forgetToPresheafedSpace_reflectsPullback_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y Z : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Z) (g : Y ⟶ Z)
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f],
CategoryTheory.Limits.ReflectsLimit (CategoryTheory.Limits.cospan g f)
(AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace.comp
AlgebraicGeometry.SheafedSpace.forge... | null | true |
CategoryTheory.Functor.CorepresentableBy.ofIsoObj | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor C (Type w)} → {X Y : C} → F.CorepresentableBy X → (Y ≅ X) → F.CorepresentableBy Y | Transport `RepresentableBy` along an isomorphism of the object. | true |
SSet.stdSimplex.objMk₁_apply_eq_one_iff | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)), (SSet.stdSimplex.objMk₁ i) j = 1 ↔ i ≤ j.castSucc | null | true |
SymOptionSuccEquiv.decode_inl | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} (s : Sym (Option α) n), SymOptionSuccEquiv.decode (Sum.inl s) = none ::ₛ s | null | true |
LinearEquiv.compDer._proof_1 | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_3} {A : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {N : Type u_4}
[inst_6 : AddCommMonoid N] [inst_7 : Module A N] [inst_8 : Module R N] [inst_9 : IsScalarTower R A M]
[inst_... | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.length.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} (l : Std.DHashMap.Internal.AssocList α β),
l.length = Std.DHashMap.Internal.AssocList.foldl (fun n x x_1 => n + 1) 0 l | null | true |
List.eraseIdx_cons_zero | Init.Data.List.Basic | ∀ {α : Type u_1} {a : α} {as : List α}, (a :: as).eraseIdx 0 = as | null | true |
Lean.Elab.Do.ControlInfo.mk.inj | Lean.Elab.Do.InferControlInfo | ∀ {breaks continues returnsEarly : Bool} {numRegularExits : ℕ} {noFallthrough : Bool} {reassigns : Lean.NameSet}
{breaks_1 continues_1 returnsEarly_1 : Bool} {numRegularExits_1 : ℕ} {noFallthrough_1 : Bool}
{reassigns_1 : Lean.NameSet},
{ breaks := breaks, continues := continues, returnsEarly := returnsEarly, num... | null | true |
_private.Mathlib.Algebra.Order.Floor.Semiring.0.Nat.preimage_Ioi._simp_1_1 | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R} {n : ℕ},
0 ≤ a → (⌊a⌋₊ < n) = (a < ↑n) | null | false |
IsMulFreimanIso.subset | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {A₁ A₂ : Set α} {B₁ B₂ : Set β}
{f : α → β} {n : ℕ}, A₁ ⊆ A₂ → IsMulFreimanIso n A₂ B₂ f → Set.BijOn f A₁ B₁ → IsMulFreimanIso n A₁ B₁ f | null | true |
CategoryTheory.LocalizerMorphism.inverts | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {D₂ : Type u₅} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₅, u₅} D₂]
{W₁ : CategoryTheory.MorphismProperty C₁} {W₂ : CategoryTheory.MorphismProperty C₂}
(Φ : CategoryTheory.LocalizerMorphism W₁ W₂)... | null | true |
MinTropical.instCommSemiring._proof_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrderedAddCommMonoidWithTop R] (x : MinTropical R),
MinTropical.untrop (x * 0) = MinTropical.untrop 0 | null | false |
GromovHausdorff.instMetricSpaceGHSpace._proof_13 | Mathlib.Topology.MetricSpace.GromovHausdorff | (Bornology.cobounded GromovHausdorff.GHSpace).sets = {s | ∃ C, ∀ x ∈ sᶜ, ∀ y ∈ sᶜ, dist x y ≤ C} | null | false |
Lean.Lsp.DidChangeTextDocumentParams._sizeOf_1 | Lean.Data.Lsp.TextSync | Lean.Lsp.DidChangeTextDocumentParams → ℕ | null | false |
Topology.delabClosure | Mathlib.Topology.Defs.Basic | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `closure[_]`. | true |
MvPowerSeries.monomial_zero_one | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R], (MvPowerSeries.monomial 0) 1 = 1 | null | true |
CFC.rpow_eq_cfc_real._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | Lean.Syntax | null | false |
CategoryTheory.GrothendieckTopology.IsLocalSite.instFullSheafConstantSheafOfHasColimitsOfSizeOfHasProducts | Mathlib.CategoryTheory.Sites.LocalSite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) [J.IsLocalSite]
(A : Type u') [inst_2 : CategoryTheory.Category.{v', u'} A] [CategoryTheory.Limits.HasColimitsOfSize.{v, v, v', u'} A]
[CategoryTheory.Limits.HasProducts A] [inst_5 : CategoryTheory.HasWeakSheafify J... | See `IsLocalSite.full_constantSheaf` for a version for `w`-locally small sites. | true |
_private.Mathlib.FieldTheory.LinearDisjoint.0.IntermediateField.LinearDisjoint.lift_adjoin_rank_eq_lift_rank_right_of_isAlgebraic.match_1_1 | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u_2} {E : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type u_3} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E]
(motive : ↥(IntermediateField.extendScalars ⋯) → Prop) (x : ↥(IntermediateField.extend... | null | false |
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq._proof_3 | Std.Time.Time.PlainTime | ∀ (a : Std.Time.Hour.Ordinal) (a_1 : Std.Time.Minute.Ordinal) (a_2 : Std.Time.Second.Ordinal true)
(a_3 : Std.Time.Nanosecond.Ordinal) (b : Std.Time.Second.Ordinal true) (b_1 : Std.Time.Nanosecond.Ordinal),
¬a_2 = b →
{ hour := a, minute := a_1, second := a_2, nanosecond := a_3 } =
{ hour := a, minute :... | null | false |
instCompleteLinearOrderWithBotENat | Mathlib.Data.ENat.Lattice | CompleteLinearOrder (WithBot ℕ∞) | null | true |
Homeomorph.setCongr | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} → [inst : TopologicalSpace X] → {s t : Set X} → s = t → ↑s ≃ₜ ↑t | If two sets are equal, then they are homeomorphic. | true |
MeasureTheory.llr_smul_same | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
[μ.HaveLebesgueDecomposition ν],
μ.AbsolutelyContinuous ν →
∀ (c : ENNReal), c ≠ 0 → c ≠ ⊤ → MeasureTheory.llr (c • μ) (c • ν) =ᵐ[μ] MeasureTheory.llr μ ν | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Stochastic.0.Matrix.transpose_mem_colStochastic_iff_mem_rowStochastic._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {M : Matrix n n R},
(M ∈ Matrix.rowStochastic R n) = ((∀ (i j : n), 0 ≤ M i j) ∧ ∀ (i : n), ∑ j, M i j = 1) | null | false |
MulAut.instGroup._proof_3 | Mathlib.Algebra.Group.End | ∀ (M : Type u_1) [inst : Mul M] (a b : MulAut M), a / b = a * MulEquiv.symm b | null | false |
AlgebraNorm.isScalarTower_restriction._proof_4 | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_2} [inst : SeminormedCommRing R] {S : Type u_1} [inst_1 : Ring S] [inst_2 : Algebra R S] {A : Type u_3}
[inst_3 : CommRing A] [inst_4 : Algebra A S] (f : AlgebraNorm R S) (x : A),
f ((algebraMap A S) (-x)) = f ((algebraMap A S) x) | null | false |
_private.Mathlib.Data.DFinsupp.BigOperators.0.DFinsupp.sumAddHom._simp_1 | Mathlib.Data.DFinsupp.BigOperators | ∀ {α : Type u_1} {a : α} {s t : Multiset α}, (a ∈ s + t) = (a ∈ s ∨ a ∈ t) | null | false |
Real.sigmoid_neg | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), (-x).sigmoid = 1 - x.sigmoid | null | true |
PFun.core | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (α →. β) → Set β → Set α | Core of a set `s : Set β` with respect to a partial function `f : α →. β`. Set of all `a : α`
such that `f a ∈ s`, if `f a` is defined. | true |
SemiNormedGrp₁.instHasCokernels | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | CategoryTheory.Limits.HasCokernels SemiNormedGrp₁ | null | true |
Metric.infEDist_closure_pos_iff_notMem_closure | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x : α} {E : Set α}, 0 < Metric.infEDist x (closure E) ↔ x ∉ closure E | null | true |
Lean.DefinitionSafety._sizeOf_inst | Lean.Declaration | SizeOf Lean.DefinitionSafety | null | false |
CategoryTheory.nerve.δ₂_two | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.ComposableArrows C 2),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 2)) x =
CategoryTheory.ComposableArrows.mk₁
(x.map' 0 1 CategoryTheory.nerve.δ₂_two._proof_1 CategoryTheory.ner... | null | true |
String.Pos.prev._proof_1 | Init.Data.String.FindPos | ∀ {s : String} (pos : s.Pos),
pos ≠ s.startPos → String.Pos.ofToSlice pos.toSlice ≠ String.Pos.ofToSlice s.toSlice.startPos | null | false |
Array.getElem?_map | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {xs : Array α} {i : ℕ}, (Array.map f xs)[i]? = Option.map f xs[i]? | null | true |
TopologicalSpace.Opens.CompleteCopy.instMetricSpace._proof_4 | Mathlib.Topology.MetricSpace.Polish | ∀ {α : Type u_1} [inst : MetricSpace α] {s : TopologicalSpace.Opens α} (t : Set s.CompleteCopy),
IsOpen t ↔ ∀ x ∈ t, ∃ ε > 0, ∀ (y : s.CompleteCopy), dist x y < ε → y ∈ t | null | false |
CategoryTheory.GradedObject.Monoidal.pentagon | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ X₄ : CategoryTheory.GradedObject I C)
[inst_3 : X₁.HasTensor X₂] [inst_4 : X₂.HasTensor X₃] [inst_5 : X₃.HasTensor X₄]
[inst_6 : (CategoryTheory.GradedObject.Mo... | null | true |
_private.Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary.0.ModelWithCorners.isBoundaryPoint_iff_isBoundaryPoint_val._simp_1_1 | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {a b : Prop}, (¬a ↔ ¬b) = (a ↔ b) | null | false |
_private.Mathlib.GroupTheory.DoubleCoset.0.DoubleCoset.iUnion_finset_rightRel_eq_univ_of_rightRel._simp_1_3 | Mathlib.GroupTheory.DoubleCoset | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Complex.ofReal_mul' | Mathlib.Basic.Complex.Basic | ∀ (r : ℝ) (z : ℂ), ↑r * z = { re := r * z.re, im := r * z.im } | null | true |
MvQPF.WEquiv.below.ind | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} (a : (MvQPF.P F).A)
(f' : ((MvQPF.P F).drop.B a).Arrow α) (f₀ f₁ : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
(a_1 : ∀ (x : (MvQPF.P F).last.B a), MvQPF.WEquiv (f₀ x) (f₁ x)... | null | true |
Cardinal.ord_zero | Mathlib.SetTheory.Ordinal.Basic | Cardinal.ord 0 = 0 | null | true |
CategoryTheory.Grp.instMonoidalCategoryStruct.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.Grp.instMonoidalCategoryStruct =
{
tensorObj := fun G H =>
{ X := CategoryTheory.MonoidalCategoryStruct.tensorObj G.X H.X,
... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.le_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.Total fun x1 x2 => x1 ≤ x2] [Std.LawfulOrderLT α] {a b : α},
(b ≤ a) = ¬a < b | null | false |
Lean.Lsp.instFromJsonVersionedTextDocumentIdentifier.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.VersionedTextDocumentIdentifier | null | true |
nhds_translation_mul_inv₀ | Mathlib.Topology.Algebra.GroupWithZero | ∀ {G₀ : Type u_3} [inst : TopologicalSpace G₀] [inst_1 : GroupWithZero G₀] [SeparatelyContinuousMul G₀] {a : G₀},
a ≠ 0 → Filter.comap (fun x => x * a⁻¹) (nhds 1) = nhds a | null | true |
Polynomial.IsDistinguishedAt.algEquivQuotient._proof_4 | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : Polynomial A} {I : Ideal A},
g.IsDistinguishedAt I → ∀ [IsAdicComplete I A], (↑g).IsWeierstrassDivisorAt I | null | false |
Module.Relations.Solution.IsPresentationCore.noConfusion | Mathlib.Algebra.Module.Presentation.Basic | {P : Sort u_1} →
{A : Type u} →
{inst : Ring A} →
{relations : Module.Relations A} →
{M : Type v} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module A M} →
{solution : relations.Solution M} →
{t : solution.IsPresentationCore} →
{A' : ... | null | false |
Lean.Elab.SyntaxDeprecationEntry.text?._default | Lean.Elab.DeprecatedSyntax | Option String | null | false |
TopModuleCat.instIsLeftAdjointModuleCatForget₂ContinuousLinearMapIdCarrierLinearMap | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R],
(CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)).IsLeftAdjoint | null | true |
IsMinFilter.min | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : LinearOrder β] {f g : α → β} {a : α} {l : Filter α},
IsMinFilter f l a → IsMinFilter g l a → IsMinFilter (fun x => min (f x) (g x)) l a | null | true |
Equiv.locallyFinite_comp_iff | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {ι' : Type u_2} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X} (e : ι' ≃ ι),
LocallyFinite (f ∘ ⇑e) ↔ LocallyFinite f | null | true |
CategoryTheory.left_comp_retraction | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} (f g : A ⟶ B)
[inst_1 : CategoryTheory.IsCoreflexivePair f g],
CategoryTheory.CategoryStruct.comp f (CategoryTheory.commonRetraction f g) = CategoryTheory.CategoryStruct.id A | null | true |
CategoryTheory.Mat.instAddCommGroupHom._proof_10 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ (R : Type) [inst : Ring R] (X Y : CategoryTheory.Mat R) (a : Matrix X.obj Y.obj R), -a + a = 0 | null | false |
CategoryTheory.GrothendieckTopology.Subcanonical.recOn | Mathlib.CategoryTheory.Sites.Canonical | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{motive : J.Subcanonical → Sort u_1} →
(t : J.Subcanonical) → ((le_canonical : J ≤ CategoryTheory.Sheaf.canonicalTopology C) → motive ⋯) → motive t | null | false |
Polynomial.smul_eq_C_mul | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} (a : R), a • p = Polynomial.C a * p | null | true |
List.fst_mem_of_mem_zipIdx | Init.Data.List.Nat.Range | ∀ {α : Type u_1} {x : α × ℕ} {l : List α} {k : ℕ}, x ∈ l.zipIdx k → x.1 ∈ l | null | true |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.gaussNorm_mul_le._simp_1_4 | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.support.Nonempty = (p ≠ 0) | null | false |
Turing.TM2.Stmt.pop.elim | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(t : Turing.TM2.Stmt Γ Λ σ) →
t.ctorIdx = 2 →
((k : K) →
(a : σ → Option (Γ k) → σ) → (a_1 : Turing.TM2.Stmt Γ Λ σ) → motive (Turi... | null | false |
Subsemiring.gi | Mathlib.Algebra.Ring.Subsemiring.Basic | (R : Type u) → [inst : NonAssocSemiring R] → GaloisInsertion Subsemiring.closure SetLike.coe | `closure` forms a Galois insertion with the coercion to set. | true |
CategoryTheory.Limits.colimitQuotientCoproduct._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
[CategoryTheory.Limits.HasColimitsOfSize.{u_1, u_1, u_2, u_3} C] (F : CategoryTheory.Functor J C),
CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun j => F.obj j) | null | false |
AffineSubspace.sOppSide_iff_exists_left | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y p₁ : P},
p₁ ∈ s → (s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ ... | null | true |
MvPolynomial.rename_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [inst : CommSemiring R] (p : ℕ) (f : σ → τ) (φ : MvPolynomial σ R),
(MvPolynomial.rename f) ((MvPolynomial.expand p) φ) = (MvPolynomial.expand p) ((MvPolynomial.rename f) φ) | null | true |
MonovaryOn.subset | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β}
{s t : Set ι}, s ⊆ t → MonovaryOn f g t → MonovaryOn f g s | null | true |
TopologicalSpace.vietoris.isPreconnected_biUnion | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s : Set α} {f : α → Set β},
IsPreconnected s → ContinuousOn f s → (∃ x ∈ s, IsPreconnected (f x)) → IsPreconnected (⋃ x ∈ s, f x) | null | true |
HasProdUniformly.hasProdLocallyUniformly | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β], HasProdUniformly f g → HasProdLocallyUniformly f g | null | true |
gauge_gaugeRescale_le | Mathlib.Analysis.Convex.GaugeRescale | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] (s t : Set E) (x : E),
gauge t (gaugeRescale s t x) ≤ gauge s x | null | true |
Lean.Meta.FoldDeclErrorRef | Mathlib.Lean.FoldEnvironment | Type | An `IO.Ref` that keeps track of any errors that could have been thrown by `act`
when folding over the constants in the environment. | true |
Nat.instCommutativeHAdd | Init.Data.Nat.Basic | Std.Commutative fun x1 x2 => x1 + x2 | null | true |
aeconst_of_dense_setOf_preimage_vadd_ae | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {M : Type u_1} [inst : TopologicalSpace M] {X : Type u_2} [inst_1 : TopologicalSpace X] [R1Space X]
[inst_3 : MeasurableSpace X] [BorelSpace X] [inst_5 : VAdd M X] [ContinuousVAdd M X] {μ : MeasureTheory.Measure X}
[MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [ErgodicVAdd M X μ] {s : Set X},
MeasureTheory... | **Alias** of `aeconst_of_dense_setOfPred_preimage_vadd_ae`.
---
Let `M` act continuously on an R₁ topological space `X`.
Let `μ` be a finite inner regular measure on `X` which is ergodic with respect to this action.
If a null measurable set `s` is a.e. equal
to its preimages under the action of a dense set of element... | true |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_hom_app_eq._proof_4 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (m n p : ℤ),
autoParam (m + n = p) CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_hom_app_eq._auto_1 →
n + m = p | null | false |
Lean.Meta.Simp.ConfigCtx.iota._inherited_default | Init.MetaTypes | Bool | null | false |
Std.TreeMap.getKey_maxKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{hc : t.maxKey! ∈ t}, t.getKey t.maxKey! hc = t.maxKey! | null | true |
AdjoinRoot.eval₂_root | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R), Polynomial.eval₂ (AdjoinRoot.of f) (AdjoinRoot.root f) f = 0 | null | true |
Set.powersetCard.sign._proof_1 | Mathlib.Order.Hom.PowersetCard | ∀ {n : ℕ} {I : Type u_1} [inst : LinearOrder I] [inst_1 : Fintype I] (s : ↑(Set.powersetCard I n))
(this : ∃ m, n + m = Fintype.card I), Disjoint ↑s ↑((Set.powersetCard.compl ⋯).symm s) | null | false |
IsDedekindDomain.HeightOneSpectrum.ofPrime | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {R : Type u_1} →
[inst : CommRing R] → [IsDedekindDomain R] → {p : Ideal R} → Prime p → IsDedekindDomain.HeightOneSpectrum R | The (nonzero) prime elements of the monoid with zero `Ideal R` correspond
to an element of type `HeightOneSpectrum R`.
See `IsDedekindDomain.HeightOneSpectrum.prime` for the inverse direction. | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Gaps.0.Finset.prod_eq_prod_range_intervalGapsWithin._proof_1_3 | Mathlib.Algebra.BigOperators.Group.Finset.Gaps | ∀ {k : ℕ}, ∀ i < k, i ∈ Set.Iio k | null | false |
Int.instLawfulOrderOrd | Init.Data.Int.Compare | Std.LawfulOrderOrd ℤ | null | true |
ImportGraph.Shake.ImportNeedsKind.privAllowMeta._proof_2 | ImportGraph.Shake.DeclNeeds | (!ImportGraph.Shake.NeedsKind.priv.isMeta || true) = true | null | false |
SimpleGraph.Walk.isPath_mapLe | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G G' : SimpleGraph V} (h : G ≤ G') {u v : V} {p : G.Walk u v},
(SimpleGraph.Walk.mapLe h p).IsPath ↔ p.IsPath | null | true |
CategoryTheory.Limits.PreservesColimitsOfSize.preservesFiniteColimits | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesColimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesFiniteColimits F | If we preserve colimits of some arbitrary size, then we preserve all finite colimits. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rotateLeft_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {r n : ℕ} (w : ℕ), r < w + 1 → n < w + 1 - r → ¬r + n < w + 1 → False | null | false |
AlgebraicGeometry.Scheme.Modules.overFunctorEquiv._proof_3 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens),
(CategoryTheory.Over.forget U).IsContinuous ((Opens.grothendieckTopology ↥X).over U) (Opens.grothendieckTopology ↥X) | null | false |
Vector.find?.eq_1 | Init.Data.Vector.Lemmas | ∀ {n : ℕ} {α : Type} (f : α → Bool) (as : Vector α n), Vector.find? f as = Array.find? f as.toArray | null | true |
Filter.sup_limsup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteDistribLattice α] {f : Filter β} {u : β → α} [f.NeBot] (a : α),
a ⊔ Filter.limsup u f = Filter.limsup (fun x => a ⊔ u x) f | null | true |
SSet.RelativeMorphism.HomotopyClass | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | {X Y : SSet} → (A : X.Subcomplex) → (B : Y.Subcomplex) → (A.toSSet ⟶ B.toSSet) → Type u | The type of homotopy classes of relative morphisms. | true |
Ordinal.isCofinal_setOfPred_isInitial | Mathlib.SetTheory.Cardinal.Aleph | IsCofinal {x | x.IsInitial} | null | true |
_private.Lean.Language.Basic.0.Lean.Language.SnapshotTree.forM.match_1 | Lean.Language.Basic | (motive : Lean.Language.SnapshotTree → Sort u_1) →
(s : Lean.Language.SnapshotTree) →
((element : Lean.Language.Snapshot) →
(children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)) →
motive { element := element, children := children }) →
motive s | null | false |
MonCat.sectionsSubmonoid | Mathlib.Algebra.Category.MonCat.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] → (F : CategoryTheory.Functor J MonCat) → Submonoid ((j : J) → ↑(F.obj j)) | The flat sections of a functor into `MonCat` form a submonoid of all sections. | true |
Set.fintypeProd | Mathlib.Basic.Finite.Prod | {α : Type u_1} → {β : Type u_2} → (s : Set α) → (t : Set β) → [Fintype ↑s] → [Fintype ↑t] → Fintype ↑(s ×ˢ t) | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt64.neg_one_shiftLeft_or_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b c : UInt64}, a <<< c ||| b <<< c = (a ||| b) <<< c | null | false |
Nat.primesLE_card_eq_primeCounting | Mathlib.NumberTheory.PrimeCounting | ∀ (n : ℕ), n.primesLE.card = n.primeCounting | The cardinality of the finset `primesLE n` equals the counting function
`primeCounting` at `n`. | true |
CategoryTheory.Localization.induction_structuredArrow | Mathlib.CategoryTheory.Localization.StructuredArrow | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : L.IsLocalization W] {X : C}
(P : CategoryTheory.StructuredArrow (L.obj X) L → Prop),
P (CategoryTheory.... | null | true |
Lean.Elab.DefViewElabHeader.noConfusion | Lean.Elab.MutualDef | {P : Sort u} → {t t' : Lean.Elab.DefViewElabHeader} → t = t' → Lean.Elab.DefViewElabHeader.noConfusionType P t t' | null | false |
pow_mulLeftLinearMap | Mathlib.LinearAlgebra.Matrix.Bilinear | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} {A : Type u_6} [inst : Fintype m] [inst_1 : DecidableEq m]
[inst_2 : Semiring R] [inst_3 : Semiring A] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A] (a : Matrix m m A)
(k : ℕ), mulLeftLinearMap n R a ^ k = mulLeftLinearMap n R (a ^ k) | A version of `LinearMap.pow_mulLeft` for matrix multiplication. | true |
CategoryTheory.Limits.productUniqueIso_inv_π_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : Unique β] (f : β → C) (b : β) {Z : C}
(h : Z ⟶ f b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (CategoryTheory.Limits.Sigma.ι f b))
(CategoryTheory.Limits.coproductUniqueIso f).hom =
CategoryTheo... | null | false |
Lean.Compiler.CSimp.Entry.mk.noConfusion | Lean.Compiler.CSimpAttr | {P : Sort u} →
{fromDeclName toDeclName thmName fromDeclName' toDeclName' thmName' : Lean.Name} →
{ fromDeclName := fromDeclName, toDeclName := toDeclName, thmName := thmName } =
{ fromDeclName := fromDeclName', toDeclName := toDeclName', thmName := thmName' } →
(fromDeclName = fromDeclName' → toDec... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.