name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Set.biInter_insert | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {β : Type u_2} (a : α) (s : Set α) (t : α → Set β), ⋂ x ∈ insert a s, t x = t a ∩ ⋂ x ∈ s, t x | null | true |
MeasureTheory.Content.is_add_left_invariant_innerContent | Mathlib.MeasureTheory.Measure.Content | ∀ {G : Type w} [inst : TopologicalSpace G] (μ : MeasureTheory.Content G) [inst_1 : AddGroup G]
[inst_2 : SeparatelyContinuousAdd G],
(∀ (g : G) {K : TopologicalSpace.Compacts G}, μ (TopologicalSpace.Compacts.map (fun x => g + x) ⋯ K) = μ K) →
∀ (g : G) (U : TopologicalSpace.Opens G),
μ.innerContent ((Topo... | null | true |
Lean.Lsp.instFromJsonWorkDoneProgressParams.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.WorkDoneProgressParams | null | true |
Lean.MetavarDecl.lctx | Lean.MetavarContext | Lean.MetavarDecl → Lean.LocalContext | The local context containing the free variables that the mvar is permitted to depend upon. | true |
Std.Http.Protocol.H1.Error.other.inj | Std.Http.Protocol.H1.Error | ∀ {message message_1 : String},
Std.Http.Protocol.H1.Error.other message = Std.Http.Protocol.H1.Error.other message_1 → message = message_1 | null | true |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_5 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α), [] = xs → [x].isEmpty = true → xs ≠ [] | null | false |
homeomorphSphereProd._proof_7 | Mathlib.Analysis.Normed.Module.Ball.RadialEquiv | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] (r : ℝ), 0 < r → ∀ (x : ↑{0}ᶜ), 0 < ‖↑x‖ → ‖↑x‖ / r ∈ Set.Ioi 0 | null | false |
instLinearOrderedAddCommMonoidWithTopAdditiveOrderDual._proof_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] (a : Additive αᵒᵈ), ⊤ + a = ⊤ | null | false |
DirichletCharacter.Odd.eval_neg | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {S : Type u_2} [inst : CommRing S] {m : ℕ} (ψ : DirichletCharacter S m) (x : ZMod m), ψ.Odd → ψ (-x) = -ψ x | null | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.foldM.match_1.eq_1 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (motive : Option (α × Batteries.BinomialHeap.Imp.Heap α) → Sort u_2) (h_1 : none = none → motive none)
(h_2 : (hd : α) → (tl : Batteries.BinomialHeap.Imp.Heap α) → none = some (hd, tl) → motive (some (hd, tl))),
(match eq : none with
| none => h_1 eq
| some (hd, tl) => h_2 hd tl eq) =
h... | null | true |
Array.isEqvAux._f | Init.Data.Array.Basic | {α : Type u} →
(xs ys : Array α) →
xs.size = ys.size →
(α → α → Bool) → (x : ℕ) → Nat.below (motive := fun x => x ≤ xs.size → Bool) x → x ≤ xs.size → Bool | null | false |
Submodule.mk_eq_bot | 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]
(carrier : AddSubmonoid M) (smul_mem' : ∀ (c : R) {x : M}, x ∈ carrier.carrier → c • x ∈ carrier.carrier),
{ toAddSubmonoid := carrier, smul_mem' := smul_mem' } = ⊥ ↔ carrier = ⊥ | null | true |
List.mem_dropLast_of_mem_of_ne_getLast? | Mathlib.Data.List.Basic | ∀ {α : Type u} {l : List α} {a : α}, a ∈ l → some a ≠ l.getLast? → a ∈ l.dropLast | null | true |
Turing.TM2to1.tr_respects | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} [inst : DecidableEq K]
(M : Λ → Turing.TM2.Stmt Γ Λ σ),
StateTransition.Respects (Turing.TM2.step M) (Turing.TM1.step (Turing.TM2to1.tr M)) Turing.TM2to1.TrCfg | null | true |
Sat.Valuation.satisfies_fmla.recOn | Mathlib.Tactic.Sat.FromLRAT | {v : Sat.Valuation} →
{f : Sat.Fmla} →
{motive : v.satisfies_fmla f → Sort u} →
(t : v.satisfies_fmla f) → ((prop : ∀ c ∈ f, v.satisfies c) → motive ⋯) → motive t | null | false |
CategoryTheory.Limits.instHasKernelπ | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) (i : J)
[inst_2 : CategoryTheory.Limits.HasBiproduct f]
[CategoryTheory.Limits.HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)],
CategoryTheory.Limits.HasKernel (CategoryTheor... | null | true |
Lean.addDocString' | Lean.DocString.Add | Lean.Name → Lean.Syntax → Option (Lean.TSyntax `Lean.Parser.Command.docComment) → Lean.Elab.TermElabM Unit | Adds a docstring to the environment, if it is provided. If no docstring is provided, nothing
happens.
Whether the docstring is processed as Verso or as Markdown is determined by its syntax tree, which
reflects the `doc.verso` option at the docstring's parse site. To explicitly control whether the
docstring is in Vers... | true |
HahnSeries.SummableFamily.instSMul_1 | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{Γ' : Type u_2} →
{R : Type u_3} →
{V : Type u_4} →
{β : Type u_6} →
[inst : PartialOrder Γ] →
[inst_1 : PartialOrder Γ'] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid R] →
[SMulWithZero R V] →
... | null | true |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.mkIndCtorElim | Lean.Meta.Constructions.CtorElim | Lean.Name → Lean.MetaM Unit | null | true |
IsAlgebraic.mul | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [NoZeroDivisors R]
{a b : S}, IsAlgebraic R a → IsAlgebraic R b → IsAlgebraic R (a * b) | null | true |
Positive.isOrderedCancelMonoid | Mathlib.Algebra.Order.Positive.Ring | ∀ {R : Type u_2} [inst : CommSemiring R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R],
IsOrderedCancelMonoid { x // 0 < x } | If `R` is a nontrivial linear ordered commutative semiring, then `{x : R // 0 < x}` is a linear
ordered cancellative commutative monoid. | true |
IsConcreteLE.lt_iff_le_and_exists | Mathlib.Basic.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : Membership B A] [inst_1 : Preorder A] [IsConcreteLE A B] {p q : A},
p < q ↔ p ≤ q ∧ ∃ x ∈ q, x ∉ p | null | true |
Polynomial.monic_finprod_X_sub_C | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] {α : Type u_1} (b : α → R), (∏ᶠ (k : α), (Polynomial.X - Polynomial.C (b k))).Monic | null | true |
CategoryTheory.Functor.Elements.yoneda | Mathlib.CategoryTheory.Elements | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (A : C) → (CategoryTheory.yoneda.obj A).Elements | **Alias** of `CategoryTheory.Functor.Elements.initialYonedaObj`.
---
The initial object in the category of elements for a representable functor. In `isInitial` it is
shown that this is initial.
| true |
Std.Sat.AIG.of_isConstant | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {assign : α → Bool} {ref : aig.Ref}
{b : Bool}, aig.isConstant ref b = true → ⟦assign, { aig := aig, ref := ref }⟧ = b | null | true |
UniformSpace.Core.mk'._proof_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (U : Filter (α × α)), (∀ r ∈ U, ∀ (x : α), (x, x) ∈ r) → ∀ _r ∈ U, SetRel.id ⊆ _r | null | false |
_private.Mathlib.RingTheory.Trace.Basic.0.Algebra.trace_ne_zero._proof_1_1 | Mathlib.RingTheory.Trace.Basic | 1 ≠ 0 | null | false |
Batteries.PairingHeapImp.Heap._sizeOf_inst | Batteries.Data.PairingHeap | (α : Type u) → [SizeOf α] → SizeOf (Batteries.PairingHeapImp.Heap α) | null | false |
CategoryTheory.Span.SpanBicat.instCategoryHom._proof_3 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
{X Y : CategoryTheory.Span.SpanBicat C Wₗ Wᵣ} {X_1 Y_1 Z : CategoryTheory.Span Wₗ Wᵣ X.of Y.of} (φ : X_1.Hom Y_1)
(φ' : Y_1.Hom Z), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp φ.hom ... | null | false |
CategoryTheory.Comonad.ForgetCreatesLimits'.lambda | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
{T : CategoryTheory.Comonad C} →
{D : CategoryTheory.Functor J T.Coalgebra} →
(c : CategoryTheory.Limits.Cone (D.comp T.forget)) →
CategoryTh... | (Impl)
Define the map `λ : L ⟶ TL`, which will serve as the structure of the algebra on `L`, and
we will show is the limiting object. We use the cone constructed by `c` and the fact that
`T` preserves limits to produce this morphism.
| true |
Std.Internal.Parsec.manyCore | Std.Internal.Parsec.Basic | {α ι elem idx : Type} →
[inst : DecidableEq idx] →
[inst_1 : DecidableEq elem] →
[Std.Internal.Parsec.Input ι elem idx] → Std.Internal.Parsec ι α → Array α → Std.Internal.Parsec ι (Array α) | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.ISize.instHasModelBitVecNumBits | Init.Data.Range.Polymorphic.SInt | HasModel✝ ISize (BitVec System.Platform.numBits) | null | true |
CategoryTheory.Oplax.OplaxTrans.whiskerLeft_naturality_comp_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{G H : CategoryTheory.OplaxFunctor B C} (θ : CategoryTheory.Oplax.OplaxTrans G H) {a b c : B} {a' : C}
(f : a' ⟶ G.obj a) (g : a ⟶ b) (h : b ⟶ c) {Z : a' ⟶ H.obj c}
(h_1 :
CategoryTheory.CategoryStruct.co... | null | true |
CategoryTheory.Sieve.le_functorPushforward_pullback | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X : C} (R : CategoryTheory.Sieve X),
R ≤ CategoryTheory.Sieve.functorPullback F (CategoryTheory.Sieve.functorPushforward F R) | null | true |
prodEquivPiFinTwo_apply | Mathlib.Logic.Equiv.Fin.Basic | ∀ (α β : Type u), ⇑(prodEquivPiFinTwo α β) = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim) | null | true |
CategoryTheory.Functor.mapMonCompIso | Mathlib.CategoryTheory.Monoidal.Mon | {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] →
{E : Type u₃} →
[inst_4 : CategoryTheory.Cat... | The composition functor is also the composition on monoid objects. | true |
AffineEquiv.ofEq._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_2} {V₁ : Type u_3} {P₁ : Type u_1} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (S₁ S₂ : AffineSubspace k P₁), S₁ = S₂ → ↑S₁ = ↑S₂ | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.homologyIso_hom_comp_leftHomologyIso_inv | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology] (h : S.LeftHomologyData),
CategoryTheory.CategoryStruct.comp h.homologyIso.hom h.leftHomologyIso.inv = S.leftHomologyIso.inv | null | true |
_private.Mathlib.Algebra.Torsor.Basic.0.Set.one_mem_sdiv_iff._simp_1_2 | Mathlib.Algebra.Torsor.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SDiv α β] {s t : Set β} {a : α}, (a ∈ s /ₛ t) = ∃ x ∈ s, ∃ y ∈ t, x /ₛ y = a | null | false |
_private.Batteries.Data.Fin.Lemmas.0.Fin.find?_eq_some_iff._simp_1_1 | Batteries.Data.Fin.Lemmas | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Fin.zero_ne_one' | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} [NeZero n], 0 ≠ 1 | null | true |
Lean.IR.EmitLLVM.emitTag | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} →
Lean.LLVM.Builder llvmctx → Lean.IR.VarId → Lean.IR.IRType → Lean.IR.EmitLLVM.M llvmctx (Lean.LLVM.Value llvmctx) | null | true |
CategoryTheory.effectiveEpiStructIsColimitDescOfEffectiveEpiFamily._proof_1 | Mathlib.CategoryTheory.EffectiveEpi.Coproduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {α : Type u_3} (X : α → C)
(c : CategoryTheory.Limits.Cofan X) (hc : CategoryTheory.Limits.IsColimit c) (π : (a : α) → X a ⟶ B)
[inst_1 : CategoryTheory.EffectiveEpiFamily X π] {W : C} (e : c.pt ⟶ W)
(h :
∀ {Z : C} (g₁ g₂ : Z ⟶ c.pt),
... | null | false |
exists_mem_nhds_isClosed_subset | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [RegularSpace X] {x : X} {s : Set X},
s ∈ nhds x → ∃ t ∈ nhds x, IsClosed t ∧ t ⊆ s | null | true |
AddSubgroup.sup_eq_closure_add | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] (H K : AddSubgroup G), H ⊔ K = AddSubgroup.closure (↑H + ↑K) | null | true |
_private.Mathlib.Analysis.Convex.Between.0.wbtw_smul_vadd_smul_vadd_of_nonpos_of_nonneg._simp_1_1 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_9} {P : Type u_10} {inst : AddSemigroup G} [self : AddSemigroupAction G P] (g₁ g₂ : G) (p : P),
g₁ +ᵥ g₂ +ᵥ p = (g₁ + g₂) +ᵥ p | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.createModulePreDiscrTree | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} →
Lean.Core.Context →
Lean.NameGenerator →
Lean.Environment →
(Lean.Name →
Lean.ConstantInfo →
Lean.MetaM (List (α × List (Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry)))) →
BaseIO (Lean.Meta.RefinedDiscrTree.InitResults✝ α) | null | true |
CategoryTheory.Limits.pullback.snd_of_mono | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPullback f g] [CategoryTheory.Mono f],
CategoryTheory.Mono (CategoryTheory.Limits.pullback.snd f g) | The pullback of a monomorphism is a monomorphism | true |
HNNExtension.NormalWord.ReducedWord.noConfusionType | Mathlib.GroupTheory.HNNExtension | Sort u →
{G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} →
HNNExtension.NormalWord.ReducedWord G A B →
{G' : Type u_1} →
[inst' : Group G'] → {A' B' : Subgroup G'} → HNNExtension.NormalWord.ReducedWord G' A' B' → Sort u | null | false |
CategoryTheory.hasColimitsOfShape_of_hasColimitsOfShape_createsColimitsOfShape | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (F : CategoryTheory.Functor C D)
[CategoryTheory.Limits.HasColimitsOfShape J D] [CategoryTheory.CreatesColimitsOfShape J F],
CategoryThe... | If `F` creates colimits of shape `J`, and `D` has colimits of shape `J`, then
`C` has colimits of shape `J`.
| true |
SSet.Edge.InvStruct.ofEq._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X : SSet} {x₀ x₁ y₀ y₁ : X.obj (Opposite.op { len := 0 })} {hom : SSet.Edge x₀ x₁} {hom' : SSet.Edge y₀ y₁},
hom.edge = hom'.edge → (SSet.Edge.id x₁).edge = (SSet.Edge.id y₁).edge | null | false |
instCommCStarAlgebraForall._proof_4 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → CommCStarAlgebra (A i)]
(a b c : (i : ι) → A i), (a + b) * c = a * c + b * c | null | false |
CategoryTheory.Pseudofunctor.mapComp_id_right_hom_app | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)),
(F.mapComp f (CategoryTheory.CategoryStruct.id b)).hom.toNatTrans.app X =
CategoryTheory.CategoryStruct.comp ((F.map₂ (CategoryTheory.Bicategory.rightUnitor f).ho... | null | true |
Finsupp.piecewise_support | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_12} [inst : Zero M] {P : α → Prop} [inst_1 : DecidablePred P] (f : Subtype P →₀ M)
(g : { a // ¬P a } →₀ M),
(f.piecewise g).support =
(Finset.map (Function.Embedding.subtype P) f.support).disjUnion
(Finset.map (Function.Embedding.subtype fun a => ¬P a) g.support) ⋯ | null | true |
_private.Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition.0.Submodule.rank_le_one_iff_isPrincipal._simp_1_4 | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Submodule R M}
{v₀ : M}, (s ≤ R ∙ v₀) = ∀ v ∈ s, ∃ r, r • v₀ = v | null | false |
Std.DTreeMap.Const.get?_union_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{k : α}, k ∉ t₁ → Std.DTreeMap.Const.get? (t₁ ∪ t₂) k = Std.DTreeMap.Const.get? t₂ k | null | true |
AlgebraicGeometry.StructureSheaf.sectionsSubmodule._proof_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} (M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
{a b : (x : ↥U) → AlgebraicGeometry.StructureSheaf.Localizations M ↑x},
a ∈ {f | (AlgebraicGeometry.StructureSheaf.isLocallyFraction R M).pred f... | null | false |
spinGroup.instStarSubtypeCliffordAlgebraMemSubmonoid._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {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 : ↥(spinGroup Q)), star ↑x ∈ spinGroup Q | null | false |
LinearMap.GeneralLinearGroup.ofLinearEquiv | Mathlib.LinearAlgebra.GeneralLinearGroup.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → (M ≃ₗ[R] M) → LinearMap.GeneralLinearGroup R M | An equivalence from `M` to itself determines an invertible linear map. | true |
SimpleGraph.edgeSet_map | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W) (G : SimpleGraph V),
(SimpleGraph.map (⇑f) G).edgeSet = ⇑f.sym2Map '' G.edgeSet | null | true |
IsLocalHom.mk | Mathlib.Algebra.Group.Units.Hom | ∀ {R : Type u_2} {S : Type u_3} {F : Type u_5} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : FunLike F R S] {f : F},
(∀ (a : R), IsUnit (f a) → IsUnit a) → IsLocalHom f | null | true |
_private.Mathlib.RingTheory.Radical.Basic.0.UniqueFactorizationMonoid.mem_primeFactors._simp_1_2 | Mathlib.RingTheory.Radical.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) | null | false |
MonoidAlgebra.counit_single | Mathlib.RingTheory.Coalgebra.MonoidAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] {X : Type u_3} [inst_2 : Module R A]
[inst_3 : Coalgebra R A] (x : X) (a : A), CoalgebraStruct.counit (MonoidAlgebra.single x a) = CoalgebraStruct.counit a | null | true |
unique_one | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u_1} [inst : Unique α] [inst_1 : One α], default = 1 | null | true |
Lean.Compiler.LCNF.UnreachableBranches.InterpContext.currFnIdx | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Compiler.LCNF.UnreachableBranches.InterpContext → ℕ | The index of the function we are currently operating on in `decls.`
| true |
BitVec.reduceRotateLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | Simplification procedure for rotate left on `BitVec`. | true |
BoxIntegral.TaggedPrepartition.isPartition_unionComplToSubordinate | Mathlib.Analysis.BoxIntegral.Partition.SubboxInduction | ∀ {ι : Type u_1} [inst : Fintype ι] {I : BoxIntegral.Box ι} (π₁ : BoxIntegral.TaggedPrepartition I)
(π₂ : BoxIntegral.Prepartition I) (hU : π₂.iUnion = ↑I \ π₁.iUnion) (r : (ι → ℝ) → ↑(Set.Ioi 0)),
(π₁.unionComplToSubordinate π₂ hU r).IsPartition | null | true |
SkewMonoidAlgebra.lift_unique' | Mathlib.Algebra.SkewMonoidAlgebra.Lift | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Monoid G] {A : Type u_4} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
(F : SkewMonoidAlgebra k G →ₐ[k] A), F = (SkewMonoidAlgebra.lift k G A) ((↑F).comp (SkewMonoidAlgebra.of k G)) | null | true |
AlternatingMap.constLinearEquivOfIsEmpty._proof_3 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {ι : Type u_3} {R' : Type u_4} {M'' : Type u_1} {N'' : Type u_2} [inst : CommSemiring R'] [inst_1 : AddCommMonoid M'']
[inst_2 : AddCommMonoid N''] [inst_3 : Module R' M''] [inst_4 : Module R' N''] [inst_5 : IsEmpty ι] (x : R')
(x_1 : N''), AlternatingMap.constOfIsEmpty R' M'' ι (x • x_1) = AlternatingMap.constOf... | null | false |
ZMod.val_ne_zero | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (a : ZMod n), a.val ≠ 0 ↔ a ≠ 0 | null | true |
Int.subNatNat_add | Init.Data.Int.Lemmas | ∀ (m n k : ℕ), Int.subNatNat (m + n) k = ↑m + Int.subNatNat n k | null | true |
CoalgEquivClass.toCoalgHomClass | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {F : Type u_5} {R : outParam (Type u_6)} {A : outParam (Type u_7)} {B : outParam (Type u_8)} {inst : CommSemiring R}
{inst_1 : AddCommMonoid A} {inst_2 : AddCommMonoid B} {inst_3 : Module R A} {inst_4 : Module R B}
{inst_5 : CoalgebraStruct R A} {inst_6 : CoalgebraStruct R B} {inst_7 : EquivLike F A B}
[self : ... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.Literal.mk.inj | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ {n : ℕ} {value : BitVec n} {n_1 : ℕ} {value_1 : BitVec n_1},
{ n := n, value := value } = { n := n_1, value := value_1 } → n = n_1 ∧ value ≍ value_1 | null | true |
instDecidableEqDyadic.decEq._proof_4 | Init.Data.Dyadic.Basic | ∀ (n k : ℤ) (hn : n % 2 = 1), ¬Dyadic.ofOdd n k hn = Dyadic.zero | null | false |
IsSimpleModule.casesOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSimpleModule R M → Sort u} →
(t : IsSimpleModule R M) → ([toIsSimpleOrder : IsSimpleOrder (Submodule R M)] → motive ⋯) → motive t | null | false |
AlgebraicClosure.instGroupWithZero._proof_9 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (n : ℕ) (a : AlgebraicClosure k), a ^ ↑n.succ = a ^ ↑n * a) DivInvMonoid.zpow_succ'._autoParam | null | false |
NormedCommGroup.toENormedCommMonoid.eq_1 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : NormedCommGroup E],
NormedCommGroup.toENormedCommMonoid =
{ toESeminormedMonoid := NormedGroup.toENormedMonoid.toESeminormedMonoid, mul_comm := ⋯, enorm_eq_zero := ⋯ } | null | true |
PartOrd.ofHom_hom | Mathlib.Order.Category.PartOrd | ∀ {X Y : PartOrd} (f : X ⟶ Y), PartOrd.ofHom (PartOrd.Hom.hom f) = f | null | true |
Lean.Parser.equalA | Init.Guard | Lean.ParserDescr | Alpha-eq matching for `guard_expr` | true |
small_neg | Mathlib.Algebra.Group.Pointwise.Set.Small | ∀ {α : Type u_1} (s : Set α) [inst : InvolutiveNeg α] [Small.{u, u_1} ↑s], Small.{u, u_1} ↑(-s) | null | true |
Std.Http.Protocol.H1.Writer.State.closed.sizeOf_spec | Std.Http.Protocol.H1.Writer | sizeOf Std.Http.Protocol.H1.Writer.State.closed = 1 | null | true |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.expandNamespacedDeclaration._regBuiltin.Lean.Elab.Command.expandNamespacedDeclaration.declRange_5 | Lean.Elab.Declaration | IO Unit | null | false |
EuclideanGeometry.Sphere.sOppSide_faceOpposite_secondInter_of_mem_interior_faceOpposite | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {n : ℕ} [inst_4 : NeZero n]
{sx : Affine.Simplex ℝ P n} {i : Fin (n + 1)},
sx.points i ∈ s →
(∀ (j : Fin (n + 1)), dist (sx.po... | If the point passed to `secondInter` is a vertex of a simplex, lying on the sphere, and all
vertices lie on or inside the sphere, and the vector passed to `secondInter` is given by a
subtraction involving that vertex and a point in the interior of the opposite face, the given
vertex and the result of `secondInter` are ... | true |
subset_absConvexHull | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E}, s ⊆ (absConvexHull 𝕜) s | null | true |
AddSubgroup.instUniqueOfSubsingleton._proof_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] [Subsingleton G] (a : AddSubgroup G), a = default | null | false |
IsAddCentral.right_assoc | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Add M] {z : M}, IsAddCentral z → ∀ (a b : M), a + b + z = a + (b + z) | associative property for right addition | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.updateAppMap | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.Meta.Grind.GoalM Unit | Given an application `e` of the form `f a_1 ... a_n`,
adds entry `f ↦ e` to `appMap`. Recall that `appMap` is a multi-map.
| true |
Lean.Core.SavedState.snapshotTasks._inherited_default | Lean.CoreM | Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree) | null | false |
Lean.Widget.RpcEncodablePacket.mk.«_@».Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1.noConfusion | Lean.Widget.InteractiveGoal | {P : Sort u} →
{hyps type ctx : Lean.Json} →
{userName? : Option Lean.Json} →
{goalPrefix mvarId : Lean.Json} →
{isInserted? isRemoved? : Option Lean.Json} →
{hyps' type' ctx' : Lean.Json} →
{userName?' : Option Lean.Json} →
{goalPrefix' mvarId' : Lean.Json} →
... | null | false |
Ideal.instInhabitedCotangent | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u_1} → [inst : CommRing R] → (I : Ideal R) → Inhabited I.Cotangent | null | true |
Std.Tactic.BVDecide.BVExpr.eval_arithShiftRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {a : ℕ} {lhs : Std.Tactic.BVDecide.BVExpr a} {a_1 : ℕ}
{rhs : Std.Tactic.BVDecide.BVExpr a_1},
Std.Tactic.BVDecide.BVExpr.eval assign (lhs.arithShiftRight rhs) =
(Std.Tactic.BVDecide.BVExpr.eval assign lhs).sshiftRight' (Std.Tactic.BVDecide.BVExpr.eval assign r... | null | true |
Cardinal.toENat_nat | Mathlib.SetTheory.Cardinal.ENat | ∀ (n : ℕ), Cardinal.toENat ↑n = ↑n | null | true |
Std.Async.UDP.Socket.ctorIdx | Std.Async.UDP | Std.Async.UDP.Socket → ℕ | null | false |
ContMDiffOn.smul | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | true |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_iff_length_isChain_interleave._simp_1_6 | Mathlib.Data.List.Interleave | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
AlgebraicGeometry.IsAffineOpen.comap_primeIdealOf_appLE | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {x : ↥X} (U : Y.Opens) (hU : AlgebraicGeometry.IsAffineOpen U)
(V : X.Opens) (hV : AlgebraicGeometry.IsAffineOpen V) (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U)
(hx : x ∈ V),
PrimeSpectrum.comap (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.appLE f U V... | null | true |
Multiplicative.leftCancelMonoid._proof_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : AddLeftCancelMonoid α], IsLeftCancelMul (Multiplicative α) | null | false |
instFintypeSymbol.match_5 | Mathlib.Computability.Language | (T : Type u_1) →
(N : Type u_2) →
(motive : Symbol T N → Sort u_3) →
(x : Symbol T N) → ((a : T) → motive (Symbol.terminal a)) → ((a : N) → motive (Symbol.nonterminal a)) → motive x | null | false |
Std.TreeSet.toList_ric._auto_1 | Std.Data.TreeSet.Slice | Lean.Syntax | null | false |
contDiffOn_succ_iff_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞},
UniqueDiffOn 𝕜 s →
(ContDiffOn 𝕜 (n + 1) f s ↔
Differentiabl... | A function is `C^(n + 1)` on a domain with unique derivatives if and only if it is
differentiable there, and its derivative (expressed with `fderivWithin`) is `C^n`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.