name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Topology.IsConstructible.preimage | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f →
(∀ (s : Set Y), IsOpen s → IsRetrocompact s → IsRetrocompact (f ⁻¹' s)) →
Topology.IsConstructible s → Topology.IsConstructible (f ⁻¹' s) | If `f` is continuous and is such that preimages of open retrocompact sets are retrocompact,
then preimages of constructible sets are constructible. | true |
Lean.Grind.CommRing.Expr.toPolyC_nc.go | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible_aux₂ | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {ι : Type u_1} {K : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : CharZero K]
[inst_2 : DecidableEq ι] [inst_3 : Fintype ι] [inst_4 : AddCommGroup M] [inst_5 : Module K M]
[inst_6 : AddCommGroup N] [inst_7 : Module K N] {P : RootPairing ι K M N} [inst_8 : P.IsCrystallographic] {b : P.Base}
... | null | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.success.sizeOf_spec | Mathlib.Tactic.TacticAnalysis.Declarations | ∀ (stx : Lean.TSyntax `tactic), sizeOf (Mathlib.TacticAnalysis.TerminalReplacementOutcome.success✝ stx) = 1 + sizeOf stx | null | true |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.instMonadPrettyFormatStateMTaggedState.match_1 | Lean.Widget.TaggedText | (motive : Lean.Widget.TaggedText.TaggedState✝ → Sort u_1) →
(x : Lean.Widget.TaggedText.TaggedState✝) →
((out : Lean.Widget.TaggedText (ℕ × ℕ)) →
(ts : List (ℕ × ℕ × Lean.Widget.TaggedText (ℕ × ℕ))) →
(col : ℕ) → motive { out := out, tagStack := ts, column := col }) →
motive x | null | false |
CategoryTheory.PreZeroHypercover.sectionsEquivOfHasPullbacks | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S : C} →
(E : CategoryTheory.PreZeroHypercover S) →
[inst_1 : E.HasPullbacks] →
(F : CategoryTheory.Functor Cᵒᵖ (Type u_2)) →
(E.toPreOneHypercover.multicospanIndex F).sections ≃
Subtype (CategoryTh... | If the pre-`0`-hypercover `E` has pairwise pullbacks, the sections over the multifork
associated to a presheaf of types are equivalent to the compatible families on `E`. | true |
_private.Mathlib.Util.AtLocation.0.Mathlib.Tactic.instReprBehaviorIfUnchanged.repr.match_1 | Mathlib.Util.AtLocation | (motive : Mathlib.Tactic.BehaviorIfUnchanged → Sort u_1) →
(x : Mathlib.Tactic.BehaviorIfUnchanged) →
(Unit → motive Mathlib.Tactic.BehaviorIfUnchanged.silent) →
(Unit → motive Mathlib.Tactic.BehaviorIfUnchanged.warning) →
(Unit → motive Mathlib.Tactic.BehaviorIfUnchanged.error) → motive x | null | false |
LindelofSpace.mk | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u_2} [inst : TopologicalSpace X], IsLindelof Set.univ → LindelofSpace X | null | true |
Set.Finite.wellFoundedOn | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α}, s.Finite → s.WellFoundedOn r | null | true |
Lean.DeclNameGenerator.noConfusionType | Lean.CoreM | Sort u → Lean.DeclNameGenerator → Lean.DeclNameGenerator → Sort u | null | false |
AddSubgroup.addCommutator.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G],
AddSubgroup.addCommutator = { bracket := fun H₁ H₂ => AddSubgroup.closure {g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g} } | null | true |
stoneCechEquivalence._proof_5 | Mathlib.Topology.Category.CompHaus.Basic | ∀ (Y : CompHaus), CompactSpace ↑Y.toTop | null | false |
maximal_subset_iff | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : Set α → Prop} {s : Set α}, Maximal P s ↔ P s ∧ ∀ ⦃t : Set α⦄, P t → s ⊆ t → s = t | null | true |
Std.Time.Modifier.v | Std.Time.Format.Modifier | Std.Time.ZoneName → Std.Time.Modifier | `v`: Generic time zone name, without DST distinction (e.g., Pacific Time, PT).
| true |
Localization.exists_awayMap_bijective_of_localRingHom_bijective | Mathlib.RingTheory.Unramified.LocalRing | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R}
[inst_3 : p.IsPrime] {q : Ideal S} [inst_4 : q.IsPrime],
p.primesOver S = {q} →
∀ [Module.Finite R S] [inst_6 : q.LiesOver p],
(RingHom.ker (algebraMap R S)).FG →
Function.Bijective ⇑(Loc... | null | true |
Mathlib.Tactic.Echelon.ListMatrixLit | Mathlib.Tactic.Echelon.Cert | {u : Lean.Level} → Q(Type u) → ℕ → ℕ → Type | Three forms of one list-based matrix literal. This makes the argument list more succinct when
a cert construction function needs to use multiple representations. | true |
CategoryTheory.CommMon.toMon | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → CategoryTheory.Mon C | A commutative monoid object is a monoid object. | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State.mk.noConfusion | Std.Sync.Channel | {α : Type} →
{P : Sort u} →
{values : Std.Queue α} →
{consumers : Std.Queue (Std.CloseableChannel.Consumer✝ α)} →
{closed : Bool} →
{values' : Std.Queue α} →
{consumers' : Std.Queue (Std.CloseableChannel.Consumer✝ α)} →
{closed' : Bool} →
{ values ... | null | false |
CategoryTheory.MorphismProperty.comp_mem | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderComposition] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
W f → W g → W (CategoryTheory.CategoryStruct.comp f g) | null | true |
linearOrderOfCompares._proof_8 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] (cmp : α → α → Ordering),
(∀ (a b : α), (cmp a b).Compares a b) → ∀ (a b : α), a ≤ b ∨ b ≤ a | null | false |
_private.Mathlib.GroupTheory.Goursat.0.Subgroup.mk_goursatFst_eq_iff_mk_goursatSnd_eq._simp_1_1 | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} [inst : Group G] {N : Subgroup G} [nN : N.Normal] {x y : G}, (↑x = ↑y) = (x / y ∈ N) | null | false |
ZMod.χ₈' | Mathlib.NumberTheory.LegendreSymbol.ZModChar | MulChar (ZMod 8) ℤ | Define the second primitive quadratic character on `ZMod 8`, `χ₈'`.
It corresponds to the extension `ℚ(√-2)/ℚ`. | true |
Lean.Lsp.SignatureInformation._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureInformation → ℕ | null | false |
_private.Batteries.Data.Float.Lemmas.0.Float.Model.UnpackedFloat.isNaN.match_1.splitter._sparseCasesOn_2 | Batteries.Data.Float.Lemmas | {motive : Float.Model.UnpackedFloat → Sort u} →
(t : Float.Model.UnpackedFloat) →
motive Float.Model.UnpackedFloat.notANumber → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Std.Http.Status.multiStatus.elim | Std.Http.Data.Status | {motive : Std.Http.Status → Sort u} →
(t : Std.Http.Status) → t.ctorIdx = 11 → motive Std.Http.Status.multiStatus → motive t | null | false |
_private.Mathlib.Topology.Order.0.continuous_sInf_rng._simp_1_1 | Mathlib.Topology.Order | ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
Continuous f = (TopologicalSpace.coinduced f t₁ ≤ t₂) | null | false |
Std.Http.Status.ofCode | Std.Http.Data.Status | Option { x // Std.Http.IsValidReasonPhrase x } → UInt16 → Option Std.Http.Status | Converts a `UInt16` to `Status`.
| true |
ModularForm.mul._proof_2 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k_1 k_2 : ℤ} [inst : Γ.HasDetPlusMinusOne] (f : ModularForm Γ k_1)
(g : ModularForm Γ k_2) {c : OnePoint ℝ},
IsCusp c Γ →
∀ (γ : GL (Fin 2) ℝ),
γ • OnePoint.infty = c →
UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map (k_1 + k_2) γ (f.mul g.toSlashInvariantForm).... | null | false |
Real.sin_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (Real.pi - x) = Real.sin x | null | true |
OrderType.card_monotone | Mathlib.Order.Types.Arithmetic | Monotone OrderType.card | null | true |
RingQuot.instSemiring | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → Semiring (RingQuot r) | null | true |
ModularForm.weakFEPair._proof_5 | Mathlib.NumberTheory.ModularForms.LFunction | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.IsArithmetic] {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] (f : F)
[ModularFormClass F Γ k] (r : ℝ),
(fun x => f (↑UpperHalfPlane.ofComplex (Complex.I * ↑x)) - UpperHalfPlane.valueAtInfty ⇑f) =O[Filter.atTop] fun x =>
x ^ r | null | false |
IsLocalization.Away.commutes | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_5} [inst : CommSemiring R] (S₁ : Type u_6) (S₂ : Type u_7) (T : Type u_8) [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] [inst_3 : CommSemiring T] [inst_4 : Algebra R S₁] [inst_5 : Algebra R S₂]
[inst_6 : Algebra R T] [inst_7 : Algebra S₁ T] [inst_8 : Algebra S₂ T] [IsScalarTower R S₁ T] [IsSca... | If `S₁` is the localization of `R` away from `f` and `S₂` is the localization away from `g`,
then any localization `T` of `S₂` away from `f` is also a localization of `S₁` away from `g`. | true |
Subring.list_sum_mem | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) {l : List R}, (∀ x ∈ l, x ∈ s) → l.sum ∈ s | Sum of a list of elements in a subring is in the subring. | true |
CochainComplex.mapBifunctorHomologicalComplexShift₁Iso | Mathlib.Algebra.Homology.BifunctorShift | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
[inst_3 : CategoryTheory.Preadditive C₁] →
[inst_4 : Category... | Auxiliary definition for `mapBifunctorShift₁Iso`. | true |
GenContFract.coe_toGenContFract | Mathlib.Algebra.ContinuedFractions.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Coe α β] {g : GenContFract α},
↑g = { h := Coe.coe g.h, s := Stream'.Seq.map GenContFract.Pair.coeFn g.s } | null | true |
CommRingCat.Colimits.Relation.right_distrib | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x y z : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F ((x.add y).mul z) ((x.mul z).add (y.mul z)) | null | true |
UniformConvergenceCLM.neg_apply | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Neg β}
{inst_2 : Neg F} [self : IsNegApply F α β] (f : F) (x : α), (-f) x = -f x | **Alias** of `neg_apply`. | true |
Lean.Grind.AC.Seq.sort'_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | true |
IsUnifLocDoublingMeasure | Mathlib.MeasureTheory.Measure.Doubling | {α : Type u_1} → [PseudoMetricSpace α] → [inst : MeasurableSpace α] → MeasureTheory.Measure α → Prop | A measure `μ` is said to be a uniformly locally doubling measure if there exists a constant `C`
such that for all sufficiently small radii `ε`, and for any centre, the measure of a ball of radius
`2 * ε` is bounded by `C` times the measure of the concentric ball of radius `ε`.
Note: it is important that this definitio... | true |
_private.Mathlib.Topology.Order.0.isClosed_induced._simp_1_1 | Mathlib.Topology.Order | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
Matrix.replicateRow_inj._simp_1 | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {n : Type u_3} {α : Type v} {ι : Type u_6} [Nonempty ι] {v w : n → α},
(Matrix.replicateRow ι v = Matrix.replicateRow ι w) = (v = w) | null | false |
CStarAlgebra.instNegPart | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | {A : Type u_1} →
[inst : NonUnitalRing A] →
[inst_1 : Module ℝ A] →
[inst_2 : SMulCommClass ℝ A A] →
[inst_3 : IsScalarTower ℝ A A] →
[inst_4 : StarRing A] →
[inst_5 : TopologicalSpace A] → [NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] → NegPart A | null | true |
Aesop.ForwardStateStats.mk.noConfusion | Aesop.Stats.Basic | {P : Sort u} →
{ruleStateStats ruleStateStats' : Array Aesop.ForwardRuleStateStats} →
{ ruleStateStats := ruleStateStats } = { ruleStateStats := ruleStateStats' } →
(ruleStateStats = ruleStateStats' → P) → P | null | false |
Lean.Server.DirectImports.noConfusionType | Lean.Server.References | Sort u → Lean.Server.DirectImports → Lean.Server.DirectImports → Sort u | null | false |
Std.DTreeMap.Internal.Impl.maxKey?_eq_back?_keysArray | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.maxKey? = t.keysArray.back? | null | true |
Function.Surjective.addGroup.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₂] [inst_1 : Zero M₂] [inst_2 : SMul ℕ M₂] [inst_3 : Neg M₂]
[inst_4 : Sub M₂] [inst_5 : SMul ℤ M₂] [inst_6 : AddGroup M₁] (f : M₁ → M₂) (hf : Function.Surjective f)
(one : f 0 = 0) (mul : ∀ (x y : M₁), f (x + y) = f x + f y) (inv : ∀ (x : M₁), f (-x) = -f x)
(div : ... | null | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.TopologicalSpace.Compacts.instCompleteSpace.match_9 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] (U : SetRel α α) (K x : TopologicalSpace.Compacts α)
(motive : x ∈ {x | (fun K' => (↑K, ↑K') ∈ hausdorffEntourage U) x} → Prop)
(x_1 : x ∈ {x | (fun K' => (↑K, ↑K') ∈ hausdorffEntourage U) x}),
(∀ (left : (↑K, ↑x).1 ⊆ U.preimage (↑K, ↑x).2) (h : (↑K, ↑x).2 ⊆ U.image (↑K, ↑... | null | false |
Aesop.instInhabitedGoalDiff.default | Aesop.RuleTac.GoalDiff | Aesop.GoalDiff | null | true |
orderOf_one | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G], orderOf 1 = 1 | null | true |
_private.Mathlib.Geometry.Euclidean.Inversion.Basic.0.EuclideanGeometry.dist_inversion_center._simp_1_6 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
CochainComplex.mappingCocone.triangle_obj₂ | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C],
(CochainComplex.mappingCocone.triangle φ).obj₂ = K | null | true |
Asymptotics.isBigO_congr | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
{g₁ g₂ : α → F}, f₁ =ᶠ[l] f₂ → g₁ =ᶠ[l] g₂ → (f₁ =O[l] g₁ ↔ f₂ =O[l] g₂) | null | true |
Std.Time.Modifier.x.injEq | Std.Time.Format.Modifier | ∀ (presentation presentation_1 : Std.Time.OffsetX),
(Std.Time.Modifier.x presentation = Std.Time.Modifier.x presentation_1) = (presentation = presentation_1) | null | true |
CategoryTheory.Limits.FormalCoproduct.isoOfComponents._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {X Y : CategoryTheory.Limits.FormalCoproduct C}
(e : X.I ≃ Y.I) (h : (i : X.I) → X.obj i ≅ Y.obj (e i)),
CategoryTheory.CategoryStruct.comp
{ f := ⇑e.symm, φ := fun i => CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (h (e.symm i)).... | null | false |
SeminormedCommRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} → [toSeminormedRing : SeminormedRing α] → (∀ (a b : α), a * b = b * a) → SeminormedCommRing α | null | true |
CategoryTheory.InducedCategory.hasForget₂._proof_1 | Mathlib.CategoryTheory.ConcreteCategory.Forget | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} D] {FD : outParam (D → D → Type u_5)}
{CD : outParam (D → Type u_3)} [inst_1 : outParam ((X Y : D) → FunLike (FD X Y) (CD X) (CD Y))]
[inst_2 : CategoryTheory.ConcreteCategory D FD] (f : C → D),
(CategoryTheory.inducedFunctor f).comp (Cate... | null | false |
CategoryTheory.LaxFunctor.mapComp'.congr_simp | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) {b₀ b₁ b₂ : B} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (fg : b₀ ⟶ b₂)
(h : CategoryTheory.CategoryStruct.comp f g = fg), F.mapComp' f g fg h = F.mapComp' f g fg h | null | true |
CategoryTheory.Limits.IsZero.iso.congr_simp | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X)
(hY : CategoryTheory.Limits.IsZero Y), hX.iso hY = hX.iso hY | null | true |
CategoryTheory.Functor.CommShift₂.commShiftObj | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
... | null | true |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.initFn._@.Batteries.Linter.UnnecessarySeqFocus.2411125583._hygCtx._hyg.4 | Batteries.Linter.UnnecessarySeqFocus | IO (Lean.Option Bool) | null | false |
PNat.instMetricSpace._proof_8 | Mathlib.Topology.Instances.PNat | autoParam (∀ (x y : ℕ+), PNat.instMetricSpace._aux_6 x y = ENNReal.ofReal (dist x y))
PseudoMetricSpace.edist_dist._autoParam | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.mul_eq_zero_iff | Init.Data.Int.Linear | ∀ (a k : ℤ), k > 0 → (k * a = 0 ↔ a = 0) | null | true |
Multiset.le_iff_exists_add | Mathlib.Data.Multiset.AddSub | ∀ {α : Type u_1} {s t : Multiset α}, s ≤ t ↔ ∃ u, t = s + u | null | true |
Lean.InductiveVal.numNested | Lean.Declaration | Lean.InductiveVal → ℕ | Number of auxiliary data types produced from nested occurrences.
An inductive definition `T` is nested when there is a constructor with an argument `x : F T`,
where `F : Type → Type` is some suitably behaved (ie strictly positive) function (Eg `Array T`, `List T`, `T × T`, ...). | true |
RBTree.RBNode.balance2_eq | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {c : RBTree.RBColor} {n : ℕ} {l : RBTree.RBNode α} {v : α} {r : RBTree.RBNode α},
r.Balanced c n → l.balance2 v r = RBTree.RBNode.node RBTree.RBColor.black l v r | The `balance2` function does nothing if the second argument is already balanced. | true |
_private.Mathlib.CategoryTheory.Idempotents.Karoubi.0.CategoryTheory.Idempotents.instEssSurjKaroubiToKaroubiOfIsIdempotentComplete._simp_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
_private.Mathlib.Analysis.Complex.JensenFormula.0.herglotzLogIntegrand_circleAverage_tendsto._simp_1_3 | Mathlib.Analysis.Complex.JensenFormula | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
HomotopyCategory.Plus.quasiIso.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ (A : Type u_3) [inst : CategoryTheory.Category.{v_3, u_3} A] [inst_1 : CategoryTheory.Abelian A],
HomotopyCategory.Plus.quasiIso A =
(HomotopyCategory.quasiIso A (ComplexShape.up ℤ)).inverseImage (HomotopyCategory.Plus.ι A) | null | true |
AddLECancellable.tsub_mul | Mathlib.Algebra.Order.Ring.Canonical | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] [inst_1 : PartialOrder R] [CanonicallyOrderedAdd R] [inst_3 : Sub R]
[OrderedSub R] [Std.Total fun x1 x2 => x1 ≤ x2] [MulRightMono R] {a b c : R},
AddLECancellable (b * c) → (a - b) * c = a * c - b * c | null | true |
Std.Tactic.BVDecide.Normalize.BitVec.ult_max' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a.ult (-1#w) = !a == -1#w | null | true |
BddDistLat.recOn | Mathlib.Order.Category.BddDistLat | {motive : BddDistLat → Sort u} →
(t : BddDistLat) →
((toDistLat : DistLat) →
[isBoundedOrder : BoundedOrder ↑toDistLat] →
motive { toDistLat := toDistLat, isBoundedOrder := isBoundedOrder }) →
motive t | null | false |
ContinuousLinearEquiv.arrowCongrEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_7} {R₂ : Type u_1} {R₃ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_8}
... | null | false |
norm_neg_pow | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : α) (n : ℕ), ‖(-a) ^ n‖ = ‖a ^ n‖ | null | true |
Submodule.coe_finsetInf | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
(s : Finset ι) (p : ι → Submodule R M), ↑(s.inf p) = ⋂ i ∈ s, ↑(p i) | null | true |
Matroid.Indep.mem_closure_iff' | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {I : Set α} {x : α},
M.Indep I → (x ∈ M.closure I ↔ x ∈ M.E ∧ (M.Indep (insert x I) → x ∈ I)) | null | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_7 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Finset.instLattice._proof_3 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (x x_1 x_2 : Finset α), x ⊆ x_2 → x_1 ⊆ x_2 → ∀ x_3 ∈ x ∪ x_1, x_3 ∈ x_2 | null | false |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8.else_eq | Lean.Elab.DeclNameGen | ∀ {motive : Lean.Name → Sort u} (t : Lean.Name) (str : (pre : Lean.Name) → (str : String) → motive (pre.str str))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8✝ t str «else» = «else» h | null | false |
VectorBundleCore.coordChange | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField R] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace R F] →
[inst_3 : TopologicalSpace B] → {ι : Type u_5} → VectorBundleCore R B F ι → ι → ι → B → F →L[R] F | null | true |
Lean.Elab.Structural.RecArgCandidates._sizeOf_1 | Lean.Elab.PreDefinition.Structural.FindRecArg | Lean.Elab.Structural.RecArgCandidates → ℕ | null | false |
Metric.metricSpaceSum._private_1 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : MetricSpace Y] (x y : X ⊕ Y),
Metric.Sum.dist x y = Metric.Sum.dist y x | null | false |
Lean.IR.CtorInfo.mk.inj | Lean.Compiler.IR.Basic | ∀ {name : Lean.Name} {cidx size usize ssize : ℕ} {name_1 : Lean.Name} {cidx_1 size_1 usize_1 ssize_1 : ℕ},
{ name := name, cidx := cidx, size := size, usize := usize, ssize := ssize } =
{ name := name_1, cidx := cidx_1, size := size_1, usize := usize_1, ssize := ssize_1 } →
name = name_1 ∧ cidx = cidx_1 ∧ s... | null | true |
Matrix.uniqueRingEquiv._proof_2 | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {A : Type u_2} [inst : Unique m] [inst_1 : NonUnitalNonAssocSemiring A] (x y : Matrix m m A),
Matrix.uniqueAddEquiv.toFun (x + y) = Matrix.uniqueAddEquiv.toFun x + Matrix.uniqueAddEquiv.toFun y | null | false |
CochainComplex.homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | null | false |
_private.Mathlib.Geometry.Manifold.ChartedSpace.0.ChartedSpace.t1Space._simp_1_1 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Lean.ScopedEnvExtension.ScopedEntries.mk.injEq | Lean.ScopedEnvExtension | ∀ {β : Type} (map map_1 : Lean.SMap Lean.Name (Lean.PArray β)), ({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
SSet.anodyneExtensions.whiskerRight | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PushoutProduct | ∀ {X Y : SSet} {f : X ⟶ Y},
SSet.anodyneExtensions f →
∀ (Z : SSet), SSet.anodyneExtensions (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z) | null | true |
CategoryTheory.Functor.sheafPullbackConstruction.preservesFiniteLimits | Mathlib.CategoryTheory.Sites.Pullback | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
(G : CategoryTheory.Functor C D) (A : Type u₁) [inst_2 : CategoryTheory.Category.{v₁, u₁} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : G.IsC... | null | true |
OrderIso.arrowCongr | Mathlib.Order.Hom.Basic | {α : Type u_6} →
{β : Type u_7} →
{γ : Type u_8} →
{δ : Type u_9} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : Preorder γ] → [inst_3 : Preorder δ] → α ≃o γ → β ≃o δ → (α →o β) ≃o (γ →o δ) | An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. | true |
_private.Lean.Meta.Sorry.0.Lean.Meta.SorryLabelView.encode.match_1 | Lean.Meta.Sorry | (motive : Option Lean.DeclarationLocation → Sort u_1) →
(x : Option Lean.DeclarationLocation) →
((module : Lean.Name) →
(pos : Lean.Position) →
(charUtf16 : ℕ) →
(endPos : Lean.Position) →
(endCharUtf16 : ℕ) →
motive
(some
... | null | false |
Lean.Lsp.instHashableInsertReplaceEdit.hash | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.InsertReplaceEdit → UInt64 | null | true |
Aesop.instInhabitedRuleTacDescr.default | Aesop.RuleTac.Descr | Aesop.RuleTacDescr | null | true |
MeasureTheory.setLIntegral_withDensity_eq_lintegral_mul₀ | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ {g : α → ENNReal},
AEMeasurable g μ →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ | null | true |
cfcₙHomSuperset | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 :... | The composition of `cfcₙHom` with the natural embedding `C(s, R)₀ → C(quasispectrum R a, R)₀`
whenever `quasispectrum R a ⊆ s`.
This is sometimes necessary in order to consider the same continuous functions applied to multiple
distinct elements, with the added constraint that `cfcₙ` does not suffice. This can occur, f... | true |
String.Slice.copy_slice_eq_iff_splits | Init.Data.String.Lemmas.Splits | ∀ {t : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
(∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = t) ↔ ∃ t₁ t₂, pos₁.Splits t₁ (t ++ t₂) ∧ pos₂.Splits (t₁ ++ t) t₂ | null | true |
instInhabitedAsBoolRing | Mathlib.Algebra.Ring.BooleanRing | {α : Type u_1} → [Inhabited α] → Inhabited (AsBoolRing α) | null | true |
Fin.partialProd.eq_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin n → M) (i : Fin (n + 1)),
Fin.partialProd f i = (List.take (↑i) (List.ofFn f)).prod | null | true |
GenContFract.contsAux_eq_contsAux_squashGCF_of_le | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {g : GenContFract K} [inst : DivisionRing K] {m : ℕ},
m ≤ n → g.contsAux m = (g.squashGCF n).contsAux m | The auxiliary continuants before the squashed position stay the same. | true |
LinearIsometryEquiv.rTensor | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
(G : Type u_4) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : InnerProductSpace 𝕜 F] →
... | This is the natural linear isometric equivalence induced by `f : E ≃ₗᵢ F`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.