name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
IsStarProjection.map | Mathlib.Algebra.Star.StarProjection | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Star A] [inst_2 : Mul B] [inst_3 : Star B] {F : Type u_4}
[inst_4 : FunLike F A B] [StarHomClass F A B] [MulHomClass F A B] {x : A},
IsStarProjection x → ∀ (f : F), IsStarProjection (f x) | true |
Std.Iter.Total.instForIn' | Init.Data.Iterators.Consumers.Loop | {α β : Type w} →
{n : Type x → Type x'} →
[Monad n] →
[inst : Std.Iterator α Id β] →
[Std.IteratorLoop α Id n] →
[Std.Iterators.Finite α Id] →
ForIn' n (Std.Iter.Total β) β { mem := fun it out => it.it.IsPlausibleIndirectOutput out } | true |
_private.Mathlib.Probability.Distributions.Gaussian.CharFun.0.ProbabilityTheory.gaussian_charFunDual_congr._simp_1_10 | Mathlib.Probability.Distributions.Gaussian.CharFun | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) | false |
Subgroup.isCoatom_map._simp_1 | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) (f : G ≃* ↥H) {K : Subgroup G},
IsCoatom (Subgroup.map (↑f) K) = IsCoatom K | false |
Lean.Grind.CommRing.Expr.toPolyS_NonnegCoeffs | Init.Grind.Ring.CommSemiringAdapter | ∀ {e : Lean.Grind.CommRing.Expr}, e.toPolyS.NonnegCoeffs | true |
Filter.EventuallyLE.isLocalMaxOn | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : Preorder β] {s : Set α} {f g : α → β} {a : α},
g ≤ᶠ[nhdsWithin a s] f → f a = g a → IsLocalMaxOn f s a → IsLocalMaxOn g s a | true |
Lean.Environment.importsOf | ImportGraph.Imports.ImportGraph | Lean.Environment → Lean.Name → Array Lean.Name | true |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalNNRatCast._proof_2 | Mathlib.Data.Rat.Cast.Order | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | false |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.InjOn.image_iInter_eq._simp_1_2 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
CoalgEquiv.trans | Mathlib.RingTheory.Coalgebra.Equiv | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{C : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : AddCommMonoid B] →
[inst_3 : AddCommMonoid C] →
[inst_4 : Module R A] →
[inst_5 : Module R B] →
... | true |
DirichletCharacter.FactorsThrough.χ₀._proof_1 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} {χ : DirichletCharacter R n} {d : ℕ}, χ.FactorsThrough d → d ∣ n | false |
CategoryTheory.Comonad.Coalgebra.noConfusion | Mathlib.CategoryTheory.Monad.Algebra | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{G : CategoryTheory.Comonad C} →
{t : G.Coalgebra} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{G' : CategoryTheory.Comonad C'} →
{t' : G'.Coalgebra... | false |
Measurable.eq_mp | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {δ : Type u_4} (X : δ → Type u_6) [inst : (a : δ) → MeasurableSpace (X a)] {β : Type u_7} [inst_1 : MeasurableSpace β]
{i i' : δ} (h : i = i') {f : β → X i}, Measurable f → Measurable fun x => ⋯.mp (f x) | true |
CategoryTheory.Adjunction.ε_comp_map_ε_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) [inst_4 : F.Monoidal]
[i... | true |
IsLocalizedModule.linearIndependent_lift | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_3} {Mₛ : Type u_4} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid Mₛ] [inst_4 : Module R Mₛ] (f : M →ₗ[R] Mₛ) [IsLocalizedModule S f]
{ι : Type u_5} {v : ι → Mₛ}, LinearIndependent R v → ∃ w, LinearIndependent R w | true |
Lean.ParseImports.setMeta | Lean.Elab.ParseImportsFast | Lean.ParseImports.Parser | true |
Function.«term_↪_» | Mathlib.Logic.Embedding.Basic | Lean.TrailingParserDescr | true |
Lean.Widget.InfoPopup.mk.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | ∀ (type exprExplicit : Option Lean.Widget.CodeWithInfos) (doc : Option String),
sizeOf { type := type, exprExplicit := exprExplicit, doc := doc } = 1 + sizeOf type + sizeOf exprExplicit + sizeOf doc | true |
StarAlgHom.fst | Mathlib.Algebra.Star.StarAlgHom | (R : Type u_1) →
(A : Type u_2) →
(B : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : Star A] → [inst_4 : Semiring B] → [inst_5 : Algebra R B] → [inst_6 : Star B] → A × B →⋆ₐ[R] A | true |
AddOpposite.op_eq_zero_iff._simp_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Zero α] (a : α), (AddOpposite.op a = 0) = (a = 0) | false |
LinearMap.surjective_compr₂ₛₗ_of_equiv | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} [inst : CommSemiring R] {R₂ : Type u_15} {R₃ : Type u_16} {R₄ : Type u_17} {M : Type u_18}
{N : Type u_19} {P : Type u_20} {Q : Type u_21} [inst_1 : CommSemiring R₂] [inst_2 : CommSemiring R₃]
[inst_3 : CommSemiring R₄] [inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P... | true |
Polynomial.toFinsuppIsoAlg_apply | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ (R : Type u) [inst : CommSemiring R] (self : Polynomial R), (Polynomial.toFinsuppIsoAlg R) self = self.toFinsupp | true |
TopologicalSpace.isSeparable_range | Mathlib.Topology.Bases | ∀ {α : Type u} {β : Type u_1} [t : TopologicalSpace α] [inst : TopologicalSpace β] [TopologicalSpace.SeparableSpace α]
{f : α → β}, Continuous f → TopologicalSpace.IsSeparable (Set.range f) | true |
ConvexSpace.noConfusionType | Mathlib.LinearAlgebra.ConvexSpace | Sort u_1 →
{R : Type u} →
{M : Type v} →
[inst : PartialOrder R] →
[inst_1 : Semiring R] →
[inst_2 : IsStrictOrderedRing R] →
ConvexSpace R M →
{R' : Type u} →
{M' : Type v} →
[inst' : PartialOrder R'] →
[inst'... | false |
AddMonoidHom.measurePreserving | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [BorelSpace G] {H : Type u_2} [inst_5 : AddGroup H] [inst_6 : TopologicalSpace H]
[IsTopologicalAddGroup H] [CompactSpace H] [inst_9 : MeasurableSpace H] [BorelSpace H] {μ : MeasureTheory.Measur... | true |
ENNReal.continuous_sub_right | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ (a : ENNReal), Continuous fun x => x - a | true |
CategoryTheory.Localization.hasSmallLocalizedShiftedHom_iff_source | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (W : CategoryTheory.MorphismProperty C) (M : Type w')
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] {X : C} [W.IsCompatibleWithShift M] {X' : C}
(f : X ⟶ X'),
W f →
∀ (Y : C),
CategoryTheory.Localization.HasSmallLocalizedShifted... | true |
IntermediateField.equivOfEq | Mathlib.FieldTheory.IntermediateField.Basic | {F : Type u_4} →
[inst : Field F] →
{E : Type u_5} → [inst_1 : Field E] → [inst_2 : Algebra F E] → {S T : IntermediateField F E} → S = T → ↥S ≃ₐ[F] ↥T | true |
Sym2.reflexive_iff_diagSet_subset_fromRel | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (sym : Symmetric r), Reflexive r ↔ Sym2.diagSet ⊆ Sym2.fromRel sym | true |
Lean.Meta.Sym.Simp.Result.ctorElim | Lean.Meta.Sym.Simp.SimpM | {motive : Lean.Meta.Sym.Simp.Result → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.Sym.Simp.Result) → ctorIdx = t.ctorIdx → Lean.Meta.Sym.Simp.Result.ctorElimType ctorIdx → motive t | false |
Int.tdiv_eq_iff_eq_mul_left | Init.Data.Int.DivMod.Lemmas | ∀ {a b c : ℤ}, b ≠ 0 → b ∣ a → (a.tdiv b = c ↔ a = c * b) | true |
TopologicalSpace.OpenNhdsOf.instDistribLattice._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} (x_1 x_2 : TopologicalSpace.OpenNhdsOf x),
(x_1 ⊓ x_2).toOpens = (x_1 ⊓ x_2).toOpens | false |
LinearMap.range_neg | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_10} {R₂ : Type u_11} {M : Type u_12} {M₂ : Type u_13} [inst : Semiring R] [inst_1 : Ring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] (f : M →ₛₗ[τ₁₂] M₂), (-f).range = f.range | true |
_private.Plausible.Gen.0.Plausible.Gen.oneOf.match_1 | Plausible.Gen | {α : Type u_1} →
(xs : Array (Plausible.Gen α)) →
(motive : ULift.{u_1, 0} { a // 0 ≤ a ∧ a < xs.size } → Sort u_2) →
(__discr : ULift.{u_1, 0} { a // 0 ≤ a ∧ a < xs.size }) →
((x : ℕ) → (left : 0 ≤ x) → (h2 : x < xs.size) → motive { down := ⟨x, ⋯⟩ }) → motive __discr | false |
Mathlib.Tactic.Translate.TranslateData.mk | Mathlib.Tactic.Translate.Core | Lean.NameMapExtension (List ℕ) →
Lean.NameMapExtension Bool →
Option Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt →
Lean.NameMapExtension Mathlib.Tactic.Translate.TranslationInfo →
Lean.Name → Bool → Bool → Mathlib.Tactic.GuessName.GuessNameData → Mathlib.Tactic.Translate.TranslateData | true |
sigmaAntidiagonalEquivProd_symm_apply_fst | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | ∀ (x : ℕ+ × ℕ+), ↑(sigmaAntidiagonalEquivProd.symm x).fst = ↑x.1 * ↑x.2 | true |
_private.Mathlib.Order.Cover.0.WithBot.bot_covBy_coe._simp_1_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a ⋖ b) = (a < b ∧ Set.Ioo a b = ∅) | false |
ONote.instPreorder._proof_1 | Mathlib.SetTheory.Ordinal.Notation | ∀ (x : ONote), x.repr ≤ x.repr | false |
Lean.mkOutParamArgsImplicit | Lean.Class | Lean.Expr → Lean.Expr | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.trStmts₁_trans._simp_1_11 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | false |
NNReal.le_rpow_inv_iff_of_neg | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x : NNReal} {z : ℝ} {y : NNReal}, 0 < x → 0 < y → z < 0 → (x ≤ y ^ z⁻¹ ↔ y ≤ x ^ z) | true |
Matroid.IsBasis.isBasis_of_closure_eq_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X Y I : Set α},
M.IsBasis I X →
I ⊆ Y →
M.closure X = M.closure Y →
autoParam (Y ⊆ M.E) Matroid.IsBasis.isBasis_of_closure_eq_closure._auto_1 → M.IsBasis I Y | true |
Std.Time.PlainTime.minute | Std.Time.Time.PlainTime | Std.Time.PlainTime → Std.Time.Minute.Ordinal | true |
Lean.Elab.Command.InductiveElabStep2.rec | Lean.Elab.MutualInductive | {motive : Lean.Elab.Command.InductiveElabStep2 → Sort u} →
((ctors : List Lean.Constructor) →
(collectUsedFVars : StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit) →
(collectExtraHeaderLMVars : StateRefT' IO.RealWorld Lean.CollectLevelMVars.State Lean.MetaM Unit) →
(checkUnivers... | false |
CategoryTheory.Triangulated.TStructure.eTriangleLTGE._proof_2 | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.ExpandedFieldVal.nested.inj | Lean.Elab.StructInst | ∀ {fieldViews : Array Lean.Elab.Term.StructInst.FieldView}
{sources : Array Lean.Elab.Term.StructInst.ExplicitSourceView}
{fieldViews_1 : Array Lean.Elab.Term.StructInst.FieldView}
{sources_1 : Array Lean.Elab.Term.StructInst.ExplicitSourceView},
Lean.Elab.Term.StructInst.ExpandedFieldVal.nested✝ fieldViews sou... | true |
Lean.Syntax.stripPos | Qq.MatchImpl | Lean.Syntax → Lean.Syntax | true |
Lean.Grind.offsetUnexpander | Init.Grind.Util | Lean.PrettyPrinter.Unexpander | true |
Batteries.RBNode.Balanced.below.rec | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1} {motive : (a : Batteries.RBNode α) → (a_1 : Batteries.RBColor) → (a_2 : ℕ) → a.Balanced a_1 a_2 → Prop}
{motive_1 :
{a : Batteries.RBNode α} →
{a_1 : Batteries.RBColor} → {a_2 : ℕ} → (t : a.Balanced a_1 a_2) → Batteries.RBNode.Balanced.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ {x : Batteries... | false |
_private.Mathlib.LinearAlgebra.Prod.0.LinearMap.range_prod_eq._simp_1_4 | Mathlib.LinearAlgebra.Prod | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | false |
Std.HashSet.mem_insertMany_of_mem | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} {ρ : Type v} [inst : ForIn Id ρ α] [EquivBEq α]
[LawfulHashable α] {l : ρ} {k : α}, k ∈ m → k ∈ m.insertMany l | true |
AlgebraicTopology.DoldKan.Γ₀.Obj.map_on_summand' | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : ChainComplex C ℕ) [inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] {Δ Δ' : SimplexCategoryᵒᵖ}
(A : SimplicialObject.Splitting.IndexSet Δ) (θ : Δ ⟶ Δ'),
CategoryTheory.CategoryStruct.comp (((AlgebraicT... | true |
Polynomial.isUnit_C_add_X_mul_iff | Mathlib.RingTheory.Polynomial.Nilpotent | ∀ {R : Type u_1} {r : R} [inst : CommRing R] {P : Polynomial R},
IsUnit (Polynomial.C r + Polynomial.X * P) ↔ IsUnit r ∧ IsNilpotent P | true |
MulOpposite.instFree | Mathlib.LinearAlgebra.Basis.MulOpposite | ∀ {R : Type u_1} {H : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid H] [inst_2 : Module R H] [Module.Free R H],
Module.Free R Hᵐᵒᵖ | true |
Module.Basis.ofZLatticeBasis_span | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] [inst_1 : LinearOrder K] [inst_2 : IsStrictOrderedRing K]
[inst_3 : HasSolidNorm K] [inst_4 : FloorRing K] {E : Type u_2} [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace K E] [inst_7 : FiniteDimensional K E] [inst_8 : ProperSpace E] (L : Submodule ℤ E)
[inst_9 : Discr... | true |
IsRelPrime.eq_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {α : Type u_1} [inst : Monoid α] (x y : α), IsRelPrime x y = ∀ ⦃d : α⦄, d ∣ x → d ∣ y → IsUnit d | true |
CategoryTheory.Limits.Bicones.ext._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {c c' : CategoryTheory.Limits.Bicone F}
(φ : c.pt ≅ c'.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp (c.ι j) φ.hom = c'.ι j) →
∀ (j : J), CategoryTheory.CategoryS... | false |
PNat.instMetricSpace._proof_19 | Mathlib.Topology.Instances.PNat | autoParam (uniformity ℕ+ = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε})
PseudoMetricSpace.uniformity_dist._autoParam | false |
Std.IterM.Equiv.toIter | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α₁ α₂ β : Type u_1} [inst : Std.Iterator α₁ Id β] [inst_1 : Std.Iterator α₂ Id β] {ita : Std.IterM Id β}
{itb : Std.IterM Id β}, ita.Equiv itb → ita.toIter.Equiv itb.toIter | true |
WType.Natα.recOn | Mathlib.Data.W.Constructions | {motive : WType.Natα → Sort u} → (t : WType.Natα) → motive WType.Natα.zero → motive WType.Natα.succ → motive t | false |
LinearIsometryEquiv.strictConvexSpace_iff | Mathlib.Analysis.Convex.LinearIsometry | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedField 𝕜] [inst_1 : PartialOrder 𝕜]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F]
(e : E ≃ₗᵢ[𝕜] F), StrictConvexSpace 𝕜 E ↔ StrictConvexSpace 𝕜 F | true |
AffineIsometryEquiv.coeFn_injective | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | true |
instInhabitedCliffordAlgebra | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (Q : QuadraticForm R M) → Inhabited (CliffordAlgebra Q) | true |
Std.TreeMap.Raw.getKey! | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited α] → Std.TreeMap.Raw α β cmp → α → α | true |
Real.Lp.fourierTransformCLM | Mathlib.Analysis.Fourier.FourierTransform | (V : Type u_1) →
(E : Type u_3) →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℂ E] →
[inst_2 : NormedAddCommGroup V] →
[inst_3 : InnerProductSpace ℝ V] →
[inst_4 : MeasurableSpace V] →
[inst_5 : BorelSpace V] →
[inst_6 : FiniteDimensional... | true |
lt_iff_exists_pos_add | Mathlib.Algebra.Order.Monoid.Unbundled.ExistsOfLE | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : Preorder α] [ExistsAddOfLE α] {a b : α} [AddLeftStrictMono α]
[AddLeftReflectLT α], a < b ↔ ∃ c, 0 < c ∧ a + c = b | true |
List.takeList | Batteries.Data.List.Basic | {α : Type u_1} → List α → List ℕ → List (List α) × List α | true |
CategoryTheory.Iso.isZero_iff | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (e : X ≅ Y),
CategoryTheory.Limits.IsZero X ↔ CategoryTheory.Limits.IsZero Y | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk._flat_ctor | Lean.DocString.Extension | Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) →
Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty) →
String → Array (Lean.Doc.Inline Lean.ElabInline) → Lean.VersoModuleDocs.DocFrame✝ | false |
CategoryTheory.ShortComplex.instModuleHom._proof_8 | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_3} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(a : R) (x y : S₁ ⟶ S₂), a • (x + y) = a • x + a • y | false |
_private.Mathlib.Topology.Algebra.Nonarchimedean.Basic.0.NonarchimedeanRing.mul_subset._simp_1_4 | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
Projectivization.Subspace.spanCarrier.of | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{S : Set (Projectivization K V)}, ∀ x ∈ S, Projectivization.Subspace.spanCarrier S x | true |
CategoryTheory.Limits.FintypeCat.jointly_surjective | Mathlib.CategoryTheory.Limits.FintypeCat | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] [CategoryTheory.FinCategory J]
(F : CategoryTheory.Functor J FintypeCat) (t : CategoryTheory.Limits.Cocone F) (h : CategoryTheory.Limits.IsColimit t)
(x : t.pt.obj), ∃ j y, (CategoryTheory.ConcreteCategory.hom (t.ι.app j)) y = x | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AddAndFinalizeContext.elabs' | Lean.Elab.MutualInductive | Lean.Elab.Command.AddAndFinalizeContext✝ → Array Lean.Elab.Command.InductiveElabStep2 | true |
Profinite.NobelingProof.spanCone_isLimit.match_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} (motive : (Finset I)ᵒᵖ → Prop) (x : (Finset I)ᵒᵖ),
(∀ (s : Finset I), motive (Opposite.op s)) → motive x | false |
List.zipIdx.eq_2 | Init.Data.List.Impl | ∀ {α : Type u} (x : ℕ) (a : α) (l : List α), (a :: l).zipIdx x = (a, x) :: l.zipIdx (x + 1) | true |
_private.Mathlib.Algebra.Homology.Augment.0.CochainComplex.augment.match_1.eq_3 | Mathlib.Algebra.Homology.Augment | ∀ (motive : ℕ → ℕ → Sort u_1) (x x_1 : ℕ) (h_1 : Unit → motive 0 1) (h_2 : (i j : ℕ) → motive i.succ j.succ)
(h_3 : (x x_2 : ℕ) → motive x x_2),
(x = 0 → x_1 = 1 → False) →
(∀ (i j : ℕ), x = i.succ → x_1 = j.succ → False) →
(match x, x_1 with
| 0, 1 => h_1 ()
| i.succ, j.succ => h_2 i j
... | true |
_private.Mathlib.Analysis.Analytic.Order.0.AnalyticAt.analyticOrderAt_sub_eq_one_of_deriv_ne_zero._simp_1_3 | Mathlib.Analysis.Analytic.Order | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | false |
Vector.findFinIdx?_congr | Init.Data.Vector.Find | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {xs ys : Vector α n},
xs = ys → Vector.findFinIdx? p xs = Vector.findFinIdx? p ys | true |
CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker_hom_right | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : a ⟶ c)
[inst_1 : CategoryTheory.Bicategory.HasLeftKanExtension f g] {x : B} (h : c ⟶ x)
[inst_2 : CategoryTheory.Bicategory.Lan.CommuteWith f g h],
(CategoryTheory.Bicategory.Lan.CommuteWith.lanCompIsoWhisker f g h).hom.right =
C... | true |
Std.Internal.Async.IO.AsyncRead.read | Std.Internal.Async.IO | {α β : Type} → [self : Std.Internal.Async.IO.AsyncRead α β] → α → Std.Internal.IO.Async.Async β | true |
Std.DTreeMap.Raw.get_eq_get_get? | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h : t.WF) {a : α} {h' : a ∈ t}, t.get a h' = (t.get? a).get ⋯ | true |
CategoryTheory.MorphismProperty.Over.pullbackCongr.eq_1 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y : T} {f : X ⟶ Y} [inst_2 : P.HasPullbacksAlong f]
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] {g : X ⟶ Y} (h : f = g),
CategoryTheory.Mor... | true |
MeasureTheory.measureReal_union₀'._auto_3 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | false |
CategoryTheory.SpectralSequence.recOn | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{motive : CategoryTheory.SpectralSequence C c r₀ → Sort u} →
(t : CategoryTheory.SpectralSequence C c r₀) ... | false |
IntermediateField.toAlgebra._proof_3 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_1} [inst : Field L], SubsemiringClass (Subsemiring L) L | false |
Subsemiring.instModuleSubtypeMem._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R' : Type u_2} {α : Type u_1} [inst : Semiring R'] [inst_1 : AddCommMonoid α] [inst_2 : Module R' α] (m : α),
0 • m = 0 | false |
Module.FinitePresentation.linearEquivMapExtendScalars_symm_apply | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (S : Submonoid R) [inst_5 : Module.FinitePresentation R M]
(f : M →ₗ[R] N),
(Module.FinitePresentation.linearEquivMapExtendScalars S).symm
((IsLo... | true |
EStateM.instReprResult.match_1 | Init.Control.EState | {ε σ α : Type u_1} →
(motive : EStateM.Result ε σ α → ℕ → Sort u_2) →
(x : EStateM.Result ε σ α) →
(x_1 : ℕ) →
((e : ε) → (a : σ) → (prec : ℕ) → motive (EStateM.Result.error e a) prec) →
((a : α) → (a_1 : σ) → (prec : ℕ) → motive (EStateM.Result.ok a a_1) prec) → motive x x_1 | false |
Ideal.eq_zero_of_polynomial_mem_map_range | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal (Polynomial R)) (x : ↥((Ideal.Quotient.mk I).comp Polynomial.C).range),
Polynomial.C x ∈ Ideal.map (Polynomial.mapRingHom ((Ideal.Quotient.mk I).comp Polynomial.C).rangeRestrict) I → x = 0 | true |
CategoryTheory.TwoSquare.guitartExact_iff_isConnected_downwards | Mathlib.CategoryTheory.GuitartExact.Basic | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃... | true |
Std.TreeSet.Raw.instInhabited | Std.Data.TreeSet.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → Inhabited (Std.TreeSet.Raw α cmp) | true |
Filter.Realizer.ne_bot_iff | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {f : Filter α} (F : f.Realizer), f ≠ ⊥ ↔ ∀ (a : F.σ), (F.F.f a).Nonempty | true |
ContinuousLinearMap.flipₗᵢ._proof_2 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ (𝕜 : Type u_1) (Fₗ : Type u_3) (Gₗ : Type u_2) [inst : SeminormedAddCommGroup Fₗ] [inst_1 : SeminormedAddCommGroup Gₗ]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedSpace 𝕜 Fₗ] [inst_4 : NormedSpace 𝕜 Gₗ],
SMulCommClass 𝕜 𝕜 (Fₗ →L[𝕜] Gₗ) | false |
LinearIsometry.extend.eq_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_3} [inst : RCLike 𝕜] {V : Type u_7} [inst_1 : NormedAddCommGroup V] [inst_2 : InnerProductSpace 𝕜 V]
[inst_3 : FiniteDimensional 𝕜 V] {S : Submodule 𝕜 V} (L : ↥S →ₗᵢ[𝕜] V),
L.extend =
{
toLinearMap :=
L.toLinearMap ∘ₗ ↑S.orthogonalProjection +
(L.rangeᗮ.subtypeₗᵢ.comp... | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.TauPackage.lastStep_nonempty._simp_1_5 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | false |
Left.neg_nonpos_iff._simp_1 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] {a : α}, (-a ≤ 0) = (0 ≤ a) | false |
AddCon.instInhabited.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M], AddCon.instInhabited = { default := addConGen emptyRelation } | true |
Lean.MessageData.toString | Lean.Message | Lean.MessageData → BaseIO String | true |
_private.Mathlib.Tactic.ReduceModChar.0.Tactic.ReduceModChar.normNegCoeffMul._proof_1 | Mathlib.Tactic.ReduceModChar | ∀ {u : Lean.Level} {α : Q(Type u)} (_instRing : Q(Ring «$α»)) (sα : Q(AddMonoidWithOne «$α»)),
«$_instRing».toAddGroupWithOne.toAddMonoidWithOne =Q «$sα» | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.