name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SimpleGraph.Walk.head_support._proof_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {a b : V} (p : G.Walk a b), p.support ≠ [] | null | false |
CategoryTheory.SimplicialObject.Splitting.toNondegComplex_fromNondegComplex_assoc | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject C} (s : X.Splitting)
[inst_1 : CategoryTheory.Preadditive C] {Z : ChainComplex C ℕ}
(h : AlgebraicTopology.AlternatingFaceMapComplex.obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp s.toNondegComplex (CategoryTheory.... | null | true |
CategoryTheory.Functor.Monoidal.toUnit_ε | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X : C),
CategoryTheory.Categor... | null | true |
Filter.rcomap'_sets | Mathlib.Order.Filter.Partial | ∀ {α : Type u} {β : Type v} (r : SetRel α β) (f : Filter β),
(Filter.rcomap' r f).sets = SetRel.image {(s, t) | r.preimage s ⊆ t} f.sets | null | true |
Set.image2_iInter_subset_right | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_5} (f : α → β → γ) (s : Set α) (t : ι → Set β),
Set.image2 f s (⋂ i, t i) ⊆ ⋂ i, Set.image2 f s (t i) | null | true |
AddMonoidHom.mulRight₃._proof_2 | Mathlib.Algebra.Ring.Associator | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (x y : R),
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft (x + y)) =
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft x) + AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft y) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_32 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p₁ : G.Walk u v},
¬p₁.Nil → ∀ (i : ℕ), i = p₁.length → i - 1 < p₁.support.tail.length | null | false |
SimpleGraph.Walk.getVert_comp_val_eq_get_support | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.getVert ∘ Fin.val = p.support.get | null | true |
CategoryTheory.Limits.weightedLim._proof_2 | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C]
[inst_2 : ∀ (W : CategoryTheory.Functor J (Type u_5)), W.HasWeightedLimObj C]
{X Y : (CategoryTheory.Functor J (Type u_5))ᵒᵖ} (g : X ⟶ Y) ⦃X_1 Y_1 : CategoryTheory.Functor J C⦄ (f : X_1 ⟶ ... | null | false |
UniformSpace.Completion.isDenseInducing_coe | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α], IsDenseInducing UniformSpace.Completion.coe' | null | true |
CategoryTheory.Functor.instLaxMonoidalMonMapAddMon._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : CategoryTheory.BraidedCategory C]
[inst_5 : CategoryThe... | null | false |
instFinitePresentationForall | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : Ring R] {ι : Type u_2} [Finite ι], Module.FinitePresentation R (ι → R) | null | true |
AffineIsometry.norm_map | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_4} {P : Type u_7} {P₂ : Type u_8} [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 : PseudoMe... | null | true |
Lean.IR.CollectMaps.collectDecl | Lean.Compiler.IR.EmitUtil | Lean.IR.Decl → Lean.IR.CollectMaps.Collector | null | true |
IsLocalization.tensorProductEquivOfMapIncludeRight._proof_9 | Mathlib.RingTheory.Localization.BaseChange | ∀ (R : Type u_4) (S : Type u_1) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {A : Type u_2}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] (B : Type u_3) [inst_5 : CommSemiring B] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : IsScalarTower R A B], IsScalarTower S (TensorProdu... | null | false |
Finset.instGradeMinOrder_nat | Mathlib.Data.Finset.Grade | {α : Type u_1} → GradeMinOrder ℕ (Finset α) | null | true |
ZeroAtInftyContinuousMap.instFunLike | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : Zero β] → FunLike (ZeroAtInftyContinuousMap α β) α β | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) (c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.dvdTight c₁ c₂) = 1 + sizeOf c₁ + sizeOf c₂ | null | true |
ValuationRing.commGroupWithZero._proof_9 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_1) [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K]
(a b : ValuationRing.ValueGroup A K), a / b = a * b⁻¹ | null | false |
HOrElse.ctorIdx | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → HOrElse α β γ → ℕ | null | false |
AddCon.comap_eq | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {c : AddCon M} {f : N →+ M},
AddCon.comap ⇑f ⋯ c = AddCon.ker (c.mk'.comp f) | Given an `AddMonoid` homomorphism `f : N → M` and an additive congruence relation
`c` on `M`, the additive congruence relation induced on `N` by `f` equals the kernel of `c`'s
quotient homomorphism composed with `f`. | true |
Lean.Elab.Structural.RecArgCandidates.noConfusionType | Lean.Elab.PreDefinition.Structural.FindRecArg | Sort u → Lean.Elab.Structural.RecArgCandidates → Lean.Elab.Structural.RecArgCandidates → Sort u | null | false |
Finmap.insert | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → [DecidableEq α] → (a : α) → β a → Finmap β → Finmap β | Insert a key-value pair into a finite map, replacing any existing pair with
the same key. | true |
CategoryTheory.delabOf | Mathlib.CategoryTheory.ConcreteCategory.Notation | Lean.PrettyPrinter.Delaborator.Delab | Delaborate `FooCat.of … X` to `↧X`.
Tag `FooCat.of` with this to make it print using the `↧` notation:
```
@[app_delab FooCat.of] meta def FooCat.delabOf := CategoryTheory.delabOf
```
This falls back to `delabApp`, so that `FooCat.of X` doesn't get printed as `{ carrier := X, … }`
by `delabStructureInstance` even if d... | true |
Polynomial.fourierCoeff_toAddCircle | Mathlib.Analysis.Polynomial.Fourier | ∀ (p : Polynomial ℂ) (n : ℤ), fourierCoeff (⇑(Polynomial.toAddCircle p)) n = if 0 ≤ n then p.coeff n.natAbs else 0 | The `n`th Fourier coefficient of a polynomial is the coefficient of `X ^ n`, or
zero if `n < 0`. | true |
Std.Internal.List.Const.getValueD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {fallback : β} {f : α → β → Bool} {l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l →
∀ {k : α},
Std.Internal.List.getValueD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getValue? k l).pfilter fun v h => f ... | null | true |
Matrix.nondegenerate_iff_det_ne_zero | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} [inst : Fintype n] {A : Type u_4} [inst_1 : CommRing A] [IsDomain A] {M : Matrix n n A}
[inst_3 : DecidableEq n], M.Nondegenerate ↔ M.det ≠ 0 | null | true |
AlgebraicGeometry.StructureSheaf.const_mul | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R A : Type u} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (f₁ f₂ : A) (g₁ g₂ : R)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) (hu₁ : U ≤ PrimeSpectrum.basicOpen g₁)
(hu₂ : U ≤ PrimeSpectrum.basicOpen g₂),
AlgebraicGeometry.StructureSheaf.const f₁ g₁ U hu₁ * Algebr... | null | true |
IsCoercive.continuousLinearEquivOfBilin | Mathlib.Analysis.InnerProductSpace.LaxMilgram | {V : Type u} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] → [CompleteSpace V] → {B : V →L[ℝ] V →L[ℝ] ℝ} → IsCoercive B → V ≃L[ℝ] V | The Lax-Milgram equivalence of a coercive bounded bilinear operator:
for all `v : V`, `continuousLinearEquivOfBilin B v` is the unique element `V`
such that `continuousLinearEquivOfBilin B v, w⟫ = B v w`.
The Lax-Milgram theorem states that this is a continuous equivalence.
| true |
Bundle.Pretrivialization.linearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : Semiring R] →
[inst_1 : TopologicalSpace F] →
[inst_2 : TopologicalSpace B] →
[inst_3 : AddCommMonoid F] →
[inst_4 : Module R F] →
[inst_5 : (x : B) →... | A pretrivialization for a vector bundle defines linear equivalences between the
fibers and the model space. | true |
HasSubset.Subset.trans | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [UsesSetNotationForOrder α] [inst : Preorder α] {a b c : α}, a ⊆ b → b ⊆ c → a ⊆ c | **Alias** of `subset_trans`.
---
Set notation form of `le_trans` | true |
Units.mul_right_inj | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) {b c : α}, ↑a * b = ↑a * c ↔ b = c | null | true |
Derivation.liftOfSurjective.congr_simp | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : CommRing M]
[inst_3 : Algebra R A] [inst_4 : Algebra R M] {F : Type u_4} [inst_5 : FunLike F A M] [inst_6 : AlgHomClass F R A M]
{f f_1 : F} (e_f : f = f_1) (hf : Function.Surjective ⇑f) ⦃d d_1 : Derivation R A A⦄... | null | true |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Bilinear___macroRules_RingTheory_LinearMap_termμ_1 | Mathlib.Algebra.Algebra.Bilinear | Lean.Macro | null | false |
ProbabilityTheory.Kernel.borelMarkovFromReal.congr_simp | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {mα : MeasurableSpace α} (Ω : Type u_5) [inst : Nonempty Ω] [inst_1 : MeasurableSpace Ω]
[inst_2 : StandardBorelSpace Ω] (η η_1 : ProbabilityTheory.Kernel α ℝ),
η = η_1 → ProbabilityTheory.Kernel.borelMarkovFromReal Ω η = ProbabilityTheory.Kernel.borelMarkovFromReal Ω η_1 | null | true |
Equiv.pemptyArrowEquivPUnit | Mathlib.Logic.Equiv.Defs | (α : Sort u_1) → (PEmpty.{u_2} → α) ≃ PUnit.{u} | The sort of maps from `PEmpty` is equivalent to `PUnit`. | true |
CategoryTheory.Cat.FreeRefl.lift | Mathlib.CategoryTheory.Category.ReflQuiv | {V : Type u_1} →
[inst : CategoryTheory.ReflQuiver V] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_2} D] →
V ⥤rq D → CategoryTheory.Functor (CategoryTheory.Cat.FreeRefl V) D | Constructor for functors from `FreeRefl`.
(See also `lift'` for which the data is unbundled.) | true |
PerfectClosure.instNeg | Mathlib.FieldTheory.PerfectClosure | (K : Type u) →
[inst : CommRing K] → (p : ℕ) → [inst_1 : Fact (Nat.Prime p)] → [inst_2 : CharP K p] → Neg (PerfectClosure K p) | null | true |
CategoryTheory.LocalizerMorphism.RightResolution._sizeOf_1 | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | null | false |
AddSubsemigroup.coe_op | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (x : AddSubsemigroup M), ↑x.op = AddOpposite.unop ⁻¹' ↑x | null | true |
Polynomial.mapRingHom_comp_C | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S),
(Polynomial.mapRingHom f).comp Polynomial.C = Polynomial.C.comp f | null | true |
CategoryTheory.instBicategoryMonoidalSingleObj._proof_6 | Mathlib.CategoryTheory.Bicategory.SingleObj | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{a b : CategoryTheory.MonoidalSingleObj C} {f g : C} (η : f ⟶ g),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) η =
CategoryTheory.CategoryStruct.c... | null | false |
_private.Init.Data.List.Basic.0.List.getLastD.match_1.eq_1 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → α → Sort u_2) (a₀ : α) (h_1 : (a₀ : α) → motive [] a₀)
(h_2 : (a : α) → (as : List α) → (x : α) → motive (a :: as) x),
(match [], a₀ with
| [], a₀ => h_1 a₀
| a :: as, x => h_2 a as x) =
h_1 a₀ | null | true |
VectorBundleCore.moduleFiber._proof_3 | 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_4} (Z : VectorBundleCore R B F ι) (x : B)
(x_1 y : R) (b : Z.Fiber x), (x_1 * y) • b = x_1 • y • b | null | false |
Aesop.Script.Tactic.sTactic? | Aesop.Script.Tactic | Aesop.Script.Tactic → Option Aesop.Script.STactic | null | true |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.recommendedSpellingByNameExt.match_1 | Lean.Parser.Term.Doc | (motive : Lean.Parser.Term.Doc.RecommendedSpelling × Array Lean.Name → Sort u_1) →
(x : Lean.Parser.Term.Doc.RecommendedSpelling × Array Lean.Name) →
((rec : Lean.Parser.Term.Doc.RecommendedSpelling) → (xs : Array Lean.Name) → motive (rec, xs)) → motive x | null | false |
Real.convexOn_log_Gamma | Mathlib.Analysis.SpecialFunctions.Gamma.BohrMollerup | ConvexOn ℝ (Set.Ioi 0) (Real.log ∘ Real.Gamma) | null | true |
Array.beq_eq_decide | Init.Data.Array.DecidableEq | ∀ {α : Type u_1} [inst : BEq α] (xs ys : Array α),
(xs == ys) = if h : xs.size = ys.size then decide (∀ (i : ℕ) (h' : i < xs.size), (xs[i] == ys[i]) = true) else false | null | true |
CategoryTheory.Localization.Monoidal.functorCoreMonoidalOfComp | Mathlib.CategoryTheory.Localization.Monoidal.Functor | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
[inst_3 : CategoryTheory.MonoidalCategory C] →
[inst_4 : Category... | Monoidal structure on `F`, given that `F` lifts along `L` to a monoidal functor `G`,
where `L` is a monoidal localization functor.
| true |
SimpleGraph.le_chromaticNumber_iff_coloring | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} {n : ℕ}, ↑n ≤ G.chromaticNumber ↔ ∀ (m : ℕ) (a : G.Coloring (Fin m)), n ≤ m | null | true |
Subgroup.Commensurable.eq_1 | Mathlib.GroupTheory.Commensurable | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), H.Commensurable K = (H.IsFiniteRelIndex K ∧ K.IsFiniteRelIndex H) | null | true |
Unitization.instNonAssocRing._proof_9 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalNonAssocRing A] [inst_2 : Module R A],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Std.Iter.toIter_toIterM | Init.Data.Iterators.Basic | ∀ {α β : Type w} (it : Std.Iter β), it.toIterM.toIter = it | null | true |
LinearIsometry.strictConvexSpace_range | 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]
[StrictConvexSpace 𝕜 E] (e : E →ₗᵢ[𝕜] F), StrictConvexSpace 𝕜 ↥(↑e).range | null | true |
monotoneOn_of_le_add_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : One α]
[inst_4 : SuccAddOrder α] [IsSuccArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMax a → a ∈ s → a + 1 ∈ s → f a ≤ f (a + 1)) → MonotoneOn f s | null | true |
Lean.Environment.Visibility._sizeOf_inst | Lean.Environment | SizeOf Lean.Environment.Visibility | null | false |
ContinuousAlternatingMap.ofSubsingleton_toAlternatingMap | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ (R : Type u_1) (M : Type u_2) (N : Type u_4) {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : Subsingleton ι] (i : ι) (f : M →L[R] N),
((ContinuousAlternating... | null | true |
Std.Time.TimeZone.instReprDaylightSavingRule | Std.Time.Zoned.RecurringRule | Repr Std.Time.TimeZone.DaylightSavingRule | null | true |
definition._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_1} →
{𝕜 : Type u_3} →
[inst : RCLike 𝕜] →
{E : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[Fintype ι] →
[FiniteDimensional 𝕜 E] →
{n : ℕ} →
Module.finrank 𝕜 E = n →
... | null | false |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusion | ProofWidgets.Component.Basic | {P : Sort u} →
{t t' : ProofWidgets.RpcEncodablePacket✝} →
t = t' →
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Component.Basic.2277670097._hygCtx._hyg.1.noConfusionType P t t' | null | false |
Lean.guardMsgsPositions | Init.Notation | Lean.ParserDescr | Position reporting for `#guard_msgs`:
- `positions := true` will report the positions of messages with the line numbers computed
relative to the line of the `#guard_msgs` token, e.g.
```
@ +3:7...+4:2
info: <message>
```
Note that the reported column is absolute.
- `positions := false` (the default) will no... | true |
subset_tangentConeAt_prod_left | Mathlib.Analysis.Calculus.TangentCone.Prod | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [ContinuousAdd E] [ContinuousConstSMul 𝕜 E] [inst_6 : AddCommGroup F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [ContinuousAdd F] [ContinuousConstSMul 𝕜 F]... | The tangent cone of a product contains the tangent cone of its left factor. | true |
AlgebraicGeometry.Scheme.kerAdjunction_counit_app | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ (Y : AlgebraicGeometry.Scheme) (f : (CategoryTheory.Over Y)ᵒᵖ),
Y.kerAdjunction.counit.app f =
(CategoryTheory.Over.homMk (AlgebraicGeometry.Scheme.Hom.toImage (Opposite.unop f).hom) ⋯).op | null | true |
ZFSet.card_empty | Mathlib.SetTheory.ZFC.Cardinal | ∅.card = 0 | null | true |
SeparatelyContinuousMul.rec | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : SeparatelyContinuousMul M → Sort u} →
((continuous_const_mul : ∀ {a : M}, Continuous fun x => a * x) →
(continuous_mul_const : ∀ {a : M}, Continuous fun x => x * a) → motive ⋯) →
(t : SeparatelyContinuo... | null | false |
Subring.mem_toSubsemiring._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Subring R} {x : R}, (x ∈ s.toSubsemiring) = (x ∈ s) | null | false |
Lean.Syntax.ident.inj | Init.Core | ∀ {info : Lean.SourceInfo} {rawVal : Substring.Raw} {val : Lean.Name} {preresolved : List Lean.Syntax.Preresolved}
{info_1 : Lean.SourceInfo} {rawVal_1 : Substring.Raw} {val_1 : Lean.Name}
{preresolved_1 : List Lean.Syntax.Preresolved},
Lean.Syntax.ident info rawVal val preresolved = Lean.Syntax.ident info_1 rawV... | null | true |
CliffordAlgebra.reverse_mem_evenOdd_iff | Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) {x : CliffordAlgebra Q} {n : ZMod 2},
CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n ↔ x ∈ CliffordAlgebra.evenOdd Q n | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.rec | Lean.Meta.LetToHave | {motive : Lean.Meta.LetToHave.State✝ → Sort u} →
((count : ℕ) →
(results : Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝) →
motive { count := count, results := results }) →
(t : Lean.Meta.LetToHave.State✝) → motive t | null | false |
instSemigroupWithZeroShrink._proof_2 | Mathlib.Algebra.GroupWithZero.Shrink | ∀ {α : Type u_2} [inst : Small.{u_1, u_2} α] [inst_1 : SemigroupWithZero α] (a : Shrink.{u_1, u_2} α), a * 0 = 0 | null | false |
QuadraticAlgebra.algebraMap_norm_eq_mul_star | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} {a b : R} [inst : CommRing R] (z : QuadraticAlgebra R a b),
(algebraMap R (QuadraticAlgebra R a b)) (QuadraticAlgebra.norm z) = z * star z | null | true |
Module.DirectLimit.addCommGroup._proof_12 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] [inst_2 : DecidableEq ι] (G : ι → Type u_3)
[inst_3 : (i : ι) → AddCommGroup (G i)] [inst_4 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
(a b : Module.DirectLimit G f), a + b = b + a | null | false |
_private.Mathlib.Order.Filter.Bases.Finite.0.Filter.hasBasis_generate._simp_1_1 | Mathlib.Order.Filter.Bases.Finite | ∀ {α : Type u} {s : Set (Set α)} {U : Set α}, (U ∈ Filter.generate s) = ∃ t ⊆ s, t.Finite ∧ ⋂₀ t ⊆ U | null | false |
HahnSeries.orderTop_embDomain | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ' : Type u_2} {R : Type u_3} [inst : Zero R] [inst_1 : PartialOrder Γ'] {Γ : Type u_5} [inst_2 : LinearOrder Γ]
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).orderTop = WithTop.map (⇑f) x.orderTop | null | true |
orthogonalFamily_iff_pairwise | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {V : ι → Submodule 𝕜 E},
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) ↔ Pairwise (Function.onFun (fun x1 x2 => x1 ⟂ x2) V) | null | true |
ProofWidgets.MakeEditLinkProps.ctorIdx | ProofWidgets.Component.MakeEditLink | ProofWidgets.MakeEditLinkProps → ℕ | null | false |
Int.zsmul_eq_mul | Mathlib.Algebra.Group.Int.Defs | ∀ (n a : ℤ), n • a = n * a | null | true |
_private.Lean.Elab.PreDefinition.Structural.FindRecArg.0.Lean.Elab.Structural.nonIndicesFirst.match_1 | Lean.Elab.PreDefinition.Structural.FindRecArg | (motive : Array Lean.Elab.Structural.RecArgInfo × Array Lean.Elab.Structural.RecArgInfo → Sort u_1) →
(x : Array Lean.Elab.Structural.RecArgInfo × Array Lean.Elab.Structural.RecArgInfo) →
((indices nonIndices : Array Lean.Elab.Structural.RecArgInfo) → motive (indices, nonIndices)) → motive x | null | false |
MeromorphicOn.neg | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → MeromorphicOn (-f) U | null | true |
List.nil_lt_cons | Init.Data.List.Lex | ∀ {α : Type u_1} [inst : LT α] (a : α) (l : List α), [] < a :: l | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.instBEqMon.beq.match_1.eq_1 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Sort u_1)
(h_1 : Unit → motive Lean.Grind.CommRing.Mon.unit Lean.Grind.CommRing.Mon.unit)
(h_2 :
(a : Lean.Grind.CommRing.Power) →
(a_1 : Lean.Grind.CommRing.Mon) →
(b : Lean.Grind.CommRing.Power) →
(b_1 : Lean.Grind.CommRin... | null | true |
enorm_mul_le' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ESeminormedMonoid E] (a b : E), ‖a * b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ | null | true |
CategoryTheory.Bicategory.postcomposing._proof_2 | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] (a b c : B) {X Y : b ⟶ c} (η : X ⟶ Y) ⦃X_1 Y_1 : a ⟶ b⦄
(f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Bicategory.postcomp a X).map f)
(CategoryTheory.Bicategory.whiskerLeft Y_1 η) =
CategoryTheory.CategoryStruct.comp (CategoryThe... | null | false |
Finset.Ioi_nonempty | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α], (Finset.Ioi a).Nonempty ↔ ¬IsMax a | null | true |
ContinuousStar.rec | Mathlib.Topology.Algebra.Star | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : Star R] →
{motive : ContinuousStar R → Sort u} →
((continuous_star : Continuous star) → motive ⋯) → (t : ContinuousStar R) → motive t | null | false |
ValuativeRel.valueSetoid._proof_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : ValuativeRel R],
Equivalence fun x x_1 =>
match x with
| (x, s) =>
match x_1 with
| (y, t) => x * ↑t ≤ᵥ y * ↑s ∧ y * ↑s ≤ᵥ x * ↑t | null | false |
ContRepresentation.Equiv.refl_apply | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Monoid G] [inst_1 : Ring R] [inst_2 : AddCommGroup V]
[inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V] {ρ : ContRepresentation R G V}
(v : V), (ContRepresentation.Equiv.refl ρ) v = v | null | true |
Std.LawfulOrderLT | Init.Data.Order.Classes | (α : Type u) → [LT α] → [LE α] → Prop | This typeclass states that the synthesized `LT α` instance is compatible with the `LE α`
instance. This means that `LT.lt a b` holds if and only if `a` is less or equal to `b` according
to the `LE α` instance, but `b` is not less or equal to `a`.
`LawfulOrderLT α` automatically entails that `LT α` is asymmetric: `a < ... | true |
LinearGrowth.tendsto_atTop_of_linearGrowthInf_natCast_pos | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {v : ℕ → ℕ}, (LinearGrowth.linearGrowthInf fun n => ↑(v n)) ≠ 0 → Filter.Tendsto v Filter.atTop Filter.atTop | null | true |
IsTotallySeparated.isTotallyDisconnected | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α}, IsTotallySeparated s → IsTotallyDisconnected s | **Alias** of `isTotallyDisconnected_of_isTotallySeparated`. | true |
Convexity.ConvexSpace.convexCombination_single | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R : Type u} {X : Type v} {inst₁ : PartialOrder R} {inst₂ : Semiring R} {inst₃ : IsStrictOrderedRing R}
[self : Convexity.ConvexSpace R X] (x : X), Convexity.sConvexComb (Convexity.StdSimplex.single x) = x | **Alias** of `Convexity.ConvexSpace.sConvexComb_single`.
---
A convex combination of a single point is that point. | true |
LinearMap.smulRight_zero | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {S : Type u_3} {M : Type u_4} {M₁ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] [inst_5 : Semiring S] [inst_6 : Module R S]
[inst_7 : Module S M] [inst_8 : IsScalarTower R S M] (f : M₁ →ₗ[R] S), f.smulRight 0 = 0 | null | true |
ApplicativeTransformation.mk.sizeOf_spec | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} [inst : Applicative F] {G : Type u → Type w} [inst_1 : Applicative G]
[inst_2 : (a : Type u) → SizeOf (F a)] [inst_3 : (a : Type u) → SizeOf (G a)] (app : (α : Type u) → F α → G α)
(preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x)
(preserves_seq' : ∀ {α β : Type u} (x : F... | null | true |
DirectLimit.instDivisionSemiring._proof_15 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {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 : Nonempty ι]
[inst_5 : (... | null | false |
toLexMulEquiv.eq_1 | Mathlib.Algebra.Order.Group.Equiv | ∀ (α : Type u_1) [inst : Mul α], toLexMulEquiv α = { toEquiv := toLex, map_mul' := ⋯ } | null | true |
ContDiffAt.snd' | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {f : F → G} {x : E} ... | Precomposing `f` with `Prod.snd` is `C^n` at `(x, y)` | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_19 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (k' : α) (v' : β k'),
Std.DTreeMap.Internal.Impl.leaf.size - 1 ≤
(Std.DTreeMap.Internal.Impl.inner 1 k' v' Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf).size | null | false |
IsSelfAdjoint.toReal_spectralRadius_eq_norm | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] (a : A),
autoParam (IsSelfAdjoint a) IsSelfAdjoint.toReal_spectralRadius_eq_norm._auto_1 → (spectralRadius ℝ a).toReal = ‖a‖ | null | true |
AlgebraicGeometry.Scheme.JointlySurjective.recOn | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | {K : CategoryTheory.Precoverage AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.Scheme.JointlySurjective K → Sort u_1} →
(t : AlgebraicGeometry.Scheme.JointlySurjective K) →
((exists_eq : ∀ {X : AlgebraicGeometry.Scheme}, ∀ S ∈ K.coverings X, ∀ (x : ↥X), ∃ Y g, S g ∧ x ∈ Set.range ⇑g) →
mo... | null | false |
contMDiffWithinAt_iff_of_mem_source' | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.