name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
instBEqAlignment | Mathlib.Util.FormatTable | BEq Alignment |
UInt16.reduceLE._regBuiltin.UInt16.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.167 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
Polynomial.support_C | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {a : R}, a ≠ 0 → (Polynomial.C a).support = {0} |
CategoryTheory.unmop_comp | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp f g).unmop = CategoryTheory.CategoryStruct.comp f.unmop g.unmop |
CategoryTheory.Localization.instLifting₃Lift₃ | Mathlib.CategoryTheory.Localization.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{D₁ : Type u_6} →
{D₂ : Type u_7} →
{D₃ : Type u_8} →
{E : Type u_13} →
[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} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_6} D₁] →
[inst_4 : CategoryTheory.Category.{v_5, u_7} D₂] →
[inst_5 : CategoryTheory.Category.{v_6, u_8} D₃] →
[inst_6 : CategoryTheory.Category.{v_13, u_13} E] →
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ E))) →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{W₃ : CategoryTheory.MorphismProperty C₃} →
(hF : W₁.IsInvertedBy₃ W₂ W₃ F) →
(L₁ : CategoryTheory.Functor C₁ D₁) →
(L₂ : CategoryTheory.Functor C₂ D₂) →
(L₃ : CategoryTheory.Functor C₃ D₃) →
[inst_7 : L₁.IsLocalization W₁] →
[inst_8 : L₂.IsLocalization W₂] →
[inst_9 : L₃.IsLocalization W₃] →
[inst_10 : W₁.ContainsIdentities] →
[inst_11 : W₂.ContainsIdentities] →
[inst_12 : W₃.ContainsIdentities] →
CategoryTheory.Localization.Lifting₃ L₁ L₂ L₃ W₁ W₂ W₃ F
(CategoryTheory.Localization.lift₃ F hF L₁ L₂ L₃) |
Std.ExtDTreeMap.Const.insertManyIfNewUnit_cons | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k : α},
Std.ExtDTreeMap.Const.insertManyIfNewUnit t (k :: l) =
Std.ExtDTreeMap.Const.insertManyIfNewUnit (t.insertIfNew k ()) l |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.ground_diff_subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, M.E \ X ⊆ M.E |
Sym2.Mem.decidable._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x a b : α), Subsingleton (Decidable (x ∈ s(a, b))) |
Lean.Order.FlatOrder.rel.rec | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {motive : (x y : Lean.Order.FlatOrder b) → x.rel y → Prop},
(∀ {x : Lean.Order.FlatOrder b}, motive b x ⋯) →
(∀ {x : Lean.Order.FlatOrder b}, motive x x ⋯) → ∀ {x y : Lean.Order.FlatOrder b} (t : x.rel y), motive x y t |
PiTensorProduct.instAddCommGroup | Mathlib.LinearAlgebra.PiTensorProduct | {ι : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
{s : ι → Type u_3} →
[inst_1 : (i : ι) → AddCommGroup (s i)] →
[inst_2 : (i : ι) → Module R (s i)] → AddCommGroup (PiTensorProduct R fun i => s i) |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.lineCommentPosition? | Lean.Server.FileWorker.SignatureHelp | (s : String) → Option s.Pos |
CategoryTheory.MorphismProperty.Comma.mapRight | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(L : CategoryTheory.Functor A T) →
{P : CategoryTheory.MorphismProperty T} →
{Q : CategoryTheory.MorphismProperty A} →
{W : CategoryTheory.MorphismProperty B} →
[inst_3 : Q.IsMultiplicative] →
[inst_4 : W.IsMultiplicative] →
{R₁ R₂ : CategoryTheory.Functor B T} →
(r : R₁ ⟶ R₂) →
(∀ (X : CategoryTheory.MorphismProperty.Comma L R₁ P Q W),
P (CategoryTheory.CategoryStruct.comp X.hom (r.app X.right))) →
CategoryTheory.Functor (CategoryTheory.MorphismProperty.Comma L R₁ P Q W)
(CategoryTheory.MorphismProperty.Comma L R₂ P Q W) |
TopologicalSpace.PositiveCompacts.coe_toCompacts | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.PositiveCompacts α), ↑s.toCompacts = ↑s |
PerfectClosure.instCommRing._proof_13 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p], ↑0 = 0 |
Filter.seq_eq_filter_seq | Mathlib.Order.Filter.Map | ∀ {α β : Type u} (f : Filter (α → β)) (g : Filter α), f <*> g = f.seq g |
Fin2.last._unsafe_rec | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 (n + 1) |
MeasureTheory.eLpNorm_count_lt_top | Mathlib.MeasureTheory.Function.LpSeminorm.Count | ∀ {α : Type u_1} {ε : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : α → ε} {p : ENNReal} [Finite α],
p ≠ 0 → (MeasureTheory.eLpNorm f p MeasureTheory.Measure.count < ⊤ ↔ ∀ (i : α), ‖f i‖ₑ < ⊤) |
_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_le_count_add_one._proof_1_2 | Mathlib.Data.Bool.Count | ∀ (b x : Bool) (l : List Bool),
List.count b (x :: l) + 2 ≤ (List.filter (fun x => decide (x = !b)) (x :: l)).length →
List.count b (x :: l) + 1 < (List.findIdxs (fun x => decide (x = !b)) (x :: l)).length |
_private.Mathlib.Topology.UniformSpace.Ultra.Basic.0.IsTransitiveRel.comp_subset_self.match_1_1 | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} {s : SetRel X X} (fst snd : X) (motive : (fst, snd) ∈ s.comp s → Prop) (x : (fst, snd) ∈ s.comp s),
(∀ (w : X) (hxz : (fst, w) ∈ s) (hzy : (w, snd) ∈ s), motive ⋯) → motive x |
WellFoundedLT.conditionallyCompleteLinearOrderBot._proof_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [i₁ : LinearOrder α] [h : WellFoundedLT α], WellFounded fun x1 x2 => x1 < x2 |
CategoryTheory.SmallObject.SuccStruct.iterationFunctor | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.SmallObject.SuccStruct C →
(J : Type w) →
[inst_1 : LinearOrder J] →
[OrderBot J] →
[SuccOrder J] →
[WellFoundedLT J] → [CategoryTheory.Limits.HasIterationOfShape J C] → CategoryTheory.Functor J C |
Lean.Compiler.LCNF.PullLetDecls.withNewScope | Lean.Compiler.LCNF.PullLetDecls | {α : Type} → Lean.Compiler.LCNF.PullLetDecls.PullM α → Lean.Compiler.LCNF.PullLetDecls.PullM α |
WithCStarModule.zero_fst | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_3} {F : Type u_4} [inst : AddCommGroup E] [inst_1 : AddCommGroup F], 0.1 = 0 |
Lean.initFn._@.Lean.Compiler.ExternAttr.4197872175._hygCtx._hyg.2 | Lean.Compiler.ExternAttr | IO (Lean.ParametricAttribute Lean.ExternAttrData) |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_38 | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 : Turing.ToPartrec.Code), ¬a.case a_1 = Turing.ToPartrec.Code.succ |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC.0.Lean.Meta.Grind.Arith.Cutsat.getAssignmentExt?.match_10 | Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC | (motive : Option Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo → Sort u_1) →
(x : Option Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) →
((info : Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) → motive (some info)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) → motive x) → motive x |
NonUnitalSubsemiring.center.instNonUnitalCommSemiring._proof_4 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocSemiring R] (a : ↥(NonUnitalSubsemiring.center R)), a * 0 = 0 |
Equiv.symm_comp_eq | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : γ → α) (g : γ → β), ⇑e.symm ∘ g = f ↔ g = ⇑e ∘ f |
AlgEquiv.map_mul' | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (self : A ≃ₐ[R] B) (x y : A),
self.toFun (x * y) = self.toFun x * self.toFun y |
HasProd.sum | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_4} {β : Type u_5} {M : Type u_6} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] [ContinuousMul M]
{f : α ⊕ β → M} {a b : M}, HasProd (f ∘ Sum.inl) a → HasProd (f ∘ Sum.inr) b → HasProd f (a * b) |
Equiv.Perm.SameCycle.of_zpow_right | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}, f.SameCycle x ((f ^ n) y) → f.SameCycle x y |
WithLp.instProdT0Space | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [T0Space α]
[T0Space β], T0Space (WithLp p (α × β)) |
Polynomial.natSepDegree_X_sub_C_pow | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} [inst : Field F] {x : F} {n : ℕ},
((Polynomial.X - Polynomial.C x) ^ n).natSepDegree = if n = 0 then 0 else 1 |
List.head?_dropWhile_not.match_1 | Init.Data.List.TakeDrop | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive x |
CategoryTheory.Pseudofunctor.DescentData.Hom.noConfusionType | Mathlib.CategoryTheory.Sites.Descent.DescentData | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{D₁ D₂ : F.DescentData f} →
D₁.Hom D₂ →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{F' : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete C'ᵒᵖ) CategoryTheory.Cat} →
{ι' : Type t} →
{S' : C'} →
{X' : ι' → C'} →
{f' : (i : ι') → X' i ⟶ S'} → {D₁' D₂' : F'.DescentData f'} → D₁'.Hom D₂' → Sort u_1 |
AddMonoidAlgebra.singleAddHom_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] (m : M) (r : R),
(AddMonoidAlgebra.singleAddHom m) r = AddMonoidAlgebra.single m r |
Relation.SymmGen.trans_antisymmRel | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b c : α} [inst : Preorder α],
Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a b →
AntisymmRel (fun x1 x2 => x1 ≤ x2) b c → Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a c |
ContinuousLinearMap.hasMFDerivAt | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(f : E →L[𝕜] E') {x : E}, HasMFDerivAt (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') (⇑f) x f |
Std.Tactic.BVDecide.BVExpr.eval_const | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {w : ℕ} {val : BitVec w},
Std.Tactic.BVDecide.BVExpr.eval assign (Std.Tactic.BVDecide.BVExpr.const val) = val |
CategoryTheory.ObjectProperty.limitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] (X : C), P X → P.limitsClosure J X |
zero_lt_one | Mathlib.Algebra.Order.ZeroLEOne | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1], 0 < 1 |
AddCircle.openPartialHomeomorphCoe._proof_10 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] (a : 𝕜) [inst_2 : TopologicalSpace 𝕜],
ContinuousOn (⇑(QuotientAddGroup.mk' (AddSubgroup.zmultiples p))) (Set.Ioo a (a + p)) |
TensorProduct.AlgebraTensorModule.homTensorHomMap | Mathlib.LinearAlgebra.TensorProduct.Tower | (R : Type uR) →
(A : Type uA) →
(B : Type uB) →
(M : Type uM) →
(N : Type uN) →
(P : Type uP) →
(Q : Type uQ) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
[inst_5 : AddCommMonoid M] →
[inst_6 : Module R M] →
[inst_7 : Module A M] →
[inst_8 : IsScalarTower R A M] →
[inst_9 : AddCommMonoid N] →
[inst_10 : Module R N] →
[inst_11 : AddCommMonoid P] →
[inst_12 : Module R P] →
[inst_13 : Module A P] →
[inst_14 : IsScalarTower R A P] →
[inst_15 : AddCommMonoid Q] →
[inst_16 : Module R Q] →
[inst_17 : Module B P] →
[inst_18 : IsScalarTower R B P] →
[inst_19 : SMulCommClass A B P] →
TensorProduct R (M →ₗ[A] P) (N →ₗ[R] Q) →ₗ[B]
TensorProduct R M N →ₗ[A] TensorProduct R P Q |
AlgebraicGeometry.IsLocalIso.eq_iInf | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | @AlgebraicGeometry.IsLocalIso = ⨅ P, ⨅ (_ : P.ContainsIdentities), ⨅ (_ : AlgebraicGeometry.IsZariskiLocalAtSource P), P |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_eq_prod_roots_sub._simp_1_3 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R}, q.Monic → (p %ₘ q = 0) = (q ∣ p) |
SSet.PtSimplex.MulStruct.δ_castSucc_castSucc_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op (SimplexCategory.mk 0))} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) self.map = g.map |
Std.instNonemptySync_1 | Std.Sync.Channel | ∀ {α : Type}, Nonempty (Std.Channel.Sync α) |
Polynomial.fiberEquivQuotient | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(f : Polynomial R →ₐ[R] S) →
Function.Surjective ⇑f →
(p : Ideal R) →
[inst_3 : p.IsPrime] →
p.Fiber S ≃ₐ[p.ResidueField]
Polynomial p.ResidueField ⧸
Ideal.map (Polynomial.mapRingHom (algebraMap R p.ResidueField)) (RingHom.ker ↑f) |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_2 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True |
Lean.Lsp.instToJsonReferenceContext.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → Lean.Json |
LeanSearchClient.just_loogle_cmd | LeanSearchClient.LoogleSyntax | Lean.ParserDescr |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.mkH1OfIsTrivial._simp_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) |
AddOreLocalization.addOreSetComm_oreSubtra | Mathlib.GroupTheory.OreLocalization.OreSet | ∀ {R : Type u_2} [inst : AddCommMonoid R] (S : AddSubmonoid R) (r : R) (s : ↥S), AddOreLocalization.oreSubtra r s = s |
Complex.exp_neg | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), Complex.exp (-x) = (Complex.exp x)⁻¹ |
RatFunc.num_mul_eq_mul_denom_iff | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K} {p q : Polynomial K},
q ≠ 0 →
(x.num * q = p * x.denom ↔
x = (algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) |
Std.TreeMap.Raw.Equiv.insertIfNew | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (k : α) (v : β), (t₁.insertIfNew k v).Equiv (t₂.insertIfNew k v) |
Condensed.isoFinYoneda._proof_3 | Mathlib.Condensed.Discrete.Colimit | ∀ (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u_1 + 1))) [inst : CategoryTheory.Limits.PreservesFiniteProducts F]
{X Y : FintypeCatᵒᵖ} (x : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((FintypeCat.toProfinite.op.comp F).map x)
((fun X => Condensed.isoFinYonedaComponents F (FintypeCat.toProfinite.obj (Opposite.unop X))) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X => Condensed.isoFinYonedaComponents F (FintypeCat.toProfinite.obj (Opposite.unop X))) X).hom
((Condensed.finYoneda F).map x) |
Prod.instOmegaCompletePartialOrder._proof_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_1} {β : Type u_2} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(x : OmegaCompletePartialOrder.Chain (α × β)) (x_1 : α × β),
(∀ (i : ℕ), x i ≤ x_1) → (Prod.ωSupImpl x).1 ≤ x_1.1 ∧ (Prod.ωSupImpl x).2 ≤ x_1.2 |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.extract.go₁_cons_addChar._simp_1_4 | Batteries.Data.String.Lemmas | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) |
VonNeumannAlgebra.mem_commutant_iff._simp_1 | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
{S : VonNeumannAlgebra H} {z : H →L[ℂ] H}, (z ∈ S.commutant) = ∀ g ∈ S, g * z = z * g |
Nucleus.instHImp._proof_7 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (m n : Nucleus X) (y : X), m (m y ⇨ n y) ⇨ n (m y ⇨ n y) = m y ⇨ n y |
Subsemigroup.toAddSubsemigroup._proof_3 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M] (S : AddSubsemigroup (Additive M)) {a b : M},
a ∈ S.carrier → b ∈ S.carrier → a + b ∈ S.carrier |
ContinuousMultilinearMap.apply._proof_2 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_1) {ι : Type u_2} (E : ι → Type u_3) (F : Type u_4) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopologicalAddGroup F] [inst_8 : ContinuousConstSMul 𝕜 F] (m : (i : ι) → E i) (x : 𝕜)
(x_1 : ContinuousMultilinearMap 𝕜 E F), (x • x_1) m = (x • x_1) m |
Aesop.GoalRef.checkAndMarkUnprovable | Aesop.Tree.State | Aesop.GoalRef → BaseIO Unit |
CategoryTheory.CatEnriched.instBicategory._proof_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_2} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b c d : CategoryTheory.CatEnriched C}
(f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) |
Std.HashMap.Raw.getElem?_alter_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k : α} {f : Option β → Option β}, m.WF → (m.alter k f)[k]? = f m[k]? |
CategoryTheory.IsMonoidalLeftDistrib.mk | Mathlib.CategoryTheory.Distributive.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C],
autoParam
(∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair)
(CategoryTheory.MonoidalCategory.tensorLeft X))
CategoryTheory.IsMonoidalLeftDistrib.preservesBinaryCoproducts_tensorLeft._autoParam →
CategoryTheory.IsMonoidalLeftDistrib C |
Std.HashMap.Raw.getKey?_eq_some_of_contains | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α],
m.WF → ∀ {k : α}, m.contains k = true → m.getKey? k = some k |
IsLowerModularLattice.inf_covBy_of_covBy_sup | Mathlib.Order.ModularLattice | ∀ {α : Type u_2} {inst : Lattice α} [self : IsLowerModularLattice α] {a b : α}, a ⋖ a ⊔ b → a ⊓ b ⋖ b |
Std.TreeMap.contains_minKey | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp]
{he : t.isEmpty = false}, t.contains (t.minKey he) = true |
LieModule.trivialIsNilpotent | Mathlib.Algebra.Lie.Nilpotent | ∀ (L : Type v) (M : Type w) [inst : LieRing L] [inst_1 : AddCommGroup M] [inst_2 : LieRingModule L M]
[LieModule.IsTrivial L M], LieModule.IsNilpotent L M |
IsConj.pow | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : Monoid α] {a b : α} (n : ℕ), IsConj a b → IsConj (a ^ n) (b ^ n) |
ComplexShape.instIsTruncLENatIntEmbeddingDownNat | Mathlib.Algebra.Homology.Embedding.Basic | ComplexShape.embeddingDownNat.IsTruncLE |
Function.Injective.mulAction.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} {β : Type u_6} [inst : Monoid M] [inst_1 : MulAction M α] [inst_2 : SMul M β]
(f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c • x) = c • f x),
Function.Injective.mulAction f hf smul = { toSMul := inst_2, mul_smul := ⋯, one_smul := ⋯ } |
Std.DTreeMap.Const.getThenInsertIfNew?_fst | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k : α}
{v : β}, (Std.DTreeMap.Const.getThenInsertIfNew? t k v).1 = Std.DTreeMap.Const.get? t k |
HasFiniteFPowerSeriesAt.comp | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : 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] {m n : ℕ} {g : F → G} {f : E → F}
{q : FormalMultilinearSeries 𝕜 F G} {p : FormalMultilinearSeries 𝕜 E F} {x : E},
HasFiniteFPowerSeriesAt g q (f x) m →
HasFiniteFPowerSeriesAt f p x n → 0 < n → HasFiniteFPowerSeriesAt (g ∘ f) (q.comp p) x (m * n) |
_private.Mathlib.RingTheory.Finiteness.Basic.0.Submodule.fg_pi._simp_1_1 | Mathlib.RingTheory.Finiteness.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M}, N.FG = ∃ S, S.Finite ∧ Submodule.span R S = N |
Convex.quasiconcaveOn_restrict | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {β : Type u_6} [inst_4 : Preorder β] {s : Set E} {f : E → β} {t : Set E},
QuasiconcaveOn 𝕜 s f → t ⊆ s → Convex 𝕜 t → QuasiconcaveOn 𝕜 t f |
MeasureTheory.NullMeasurable.congr | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β}
{μ : MeasureTheory.Measure α} {g : α → β},
MeasureTheory.NullMeasurable f μ → f =ᵐ[μ] g → MeasureTheory.NullMeasurable g μ |
_private.Init.Data.UInt.Lemmas.0.USize.toUInt64_eq_mod_usizeSize_iff._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a = b) = (a.toNat = b.toNat) |
Std.ExtDHashMap.getKey?_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.ExtDHashMap.filterMap f m).getKey? k = (m.getKey? k).pfilter fun x_2 h' => (f x_2 (m.get x_2 ⋯)).isSome |
_private.Mathlib.Combinatorics.Configuration.0.Configuration.ofField.instProjectivePlaneProjectivizationForallFinOfNatNatOfDecidableEq._simp_2 | Mathlib.Combinatorics.Configuration | ∀ {F : Type u_1} [inst : Field F] {m : Type u_2} [inst_1 : Fintype m] {v w : m → F} (hv : v ≠ 0) (hw : w ≠ 0),
(Projectivization.mk F v hv).orthogonal (Projectivization.mk F w hw) = (v ⬝ᵥ w = 0) |
initFn._@.Mathlib.Tactic.Attr.Register.612238087._hygCtx._hyg.25 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.Simp.SimprocExtension |
_private.Lean.Meta.ExprLens.0.Lean.Meta.lensAux._unsafe_rec | Lean.Meta.ExprLens | {M : Type → Type} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] → [Lean.MonadError M] → (Lean.Expr → M Lean.Expr) → List ℕ → Lean.Expr → M Lean.Expr |
DistribMulActionHom.ctorIdx | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
{inst : Monoid M} →
{N : Type u_2} →
{inst_1 : Monoid N} →
{φ : M →* N} →
{A : Type u_4} →
{inst_2 : AddMonoid A} →
{inst_3 : DistribMulAction M A} →
{B : Type u_5} → {inst_4 : AddMonoid B} → {inst_5 : DistribMulAction N B} → (A →ₑ+[φ] B) → ℕ |
Matrix.ext_iff_vecMul | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype m] {A B : Matrix m n α},
A = B ↔ ∀ (v : m → α), Matrix.vecMul v A = Matrix.vecMul v B |
WeierstrassCurve.ext | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | ∀ {R : Type u} {x y : WeierstrassCurve R}, x.a₁ = y.a₁ → x.a₂ = y.a₂ → x.a₃ = y.a₃ → x.a₄ = y.a₄ → x.a₆ = y.a₆ → x = y |
IsBaseChange.basis_repr_comp_apply | Mathlib.RingTheory.TensorProduct.IsBaseChangeFree | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {V : Type u_3}
[inst_3 : AddCommMonoid V] [inst_4 : Module R V] {W : Type u_4} [inst_5 : AddCommMonoid W] [inst_6 : Module R W]
[inst_7 : Module S W] [inst_8 : IsScalarTower R S W] {ι : Type u_5} {ε : V →ₗ[R] W} (b : Module.Basis ι R V)
(ibc : IsBaseChange S ε) (v : V) (i : ι), ((IsBaseChange.basis b ibc).repr (ε v)) i = (algebraMap R S) ((b.repr v) i) |
Metric.cthickening_of_nonpos | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ}, δ ≤ 0 → ∀ (E : Set α), Metric.cthickening δ E = closure E |
ContinuousAlternatingMap.nnnorm_ofSubsingleton_id | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ (𝕜 : Type u) (F : Type wF) {ι : Type v} [inst : Fintype ι] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 F] [inst_4 : Subsingleton ι] [Nontrivial F] (i : ι),
‖(ContinuousAlternatingMap.ofSubsingleton 𝕜 F F i) (ContinuousLinearMap.id 𝕜 F)‖₊ = 1 |
Order.Coframe.MinimalAxioms.noConfusion | Mathlib.Order.CompleteBooleanAlgebra | {P : Sort u_1} →
{α : Type u} →
{t : Order.Coframe.MinimalAxioms α} →
{α' : Type u} →
{t' : Order.Coframe.MinimalAxioms α'} → α = α' → t ≍ t' → Order.Coframe.MinimalAxioms.noConfusionType P t t' |
_private.Mathlib.AlgebraicGeometry.ResidueField.0.AlgebraicGeometry.Scheme.SpecToEquivOfField._proof_11 | Mathlib.AlgebraicGeometry.ResidueField | ∀ (K : Type u_1) [inst : Field K] (X : AlgebraicGeometry.Scheme) (f : (x : ↥X) × (X.residueField x ⟶ CommRingCat.of K)),
(X.fromSpecResidueField f.fst) ((AlgebraicGeometry.Spec.map f.snd) (IsLocalRing.closedPoint K)) = f.fst |
CategoryTheory.IsSeparating.isSeparator_coproduct | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {β : Type w}
{f : β → C} [inst_2 : CategoryTheory.Limits.HasCoproduct f],
(CategoryTheory.ObjectProperty.ofObj f).IsSeparating → CategoryTheory.IsSeparator (∐ f) |
Finset.disjoint_insert_right._simp_1 | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u_2} [inst : DecidableEq α] {s t : Finset α} {a : α}, Disjoint s (insert a t) = (a ∉ s ∧ Disjoint s t) |
CategoryTheory.Comma.final_snd | Mathlib.CategoryTheory.Comma.Final | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) [CategoryTheory.IsFiltered A] [CategoryTheory.IsFiltered B] [R.Final],
(CategoryTheory.Comma.snd L R).Final |
EuclideanGeometry.reflection_vadd_smul_vsub_orthogonalProjection | Mathlib.Geometry.Euclidean.Projection | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : MetricSpace P] [inst_4 : NormedAddTorsor V P] {s : AffineSubspace 𝕜 P}
[inst_5 : Nonempty ↥s] [inst_6 : s.direction.HasOrthogonalProjection] {p₁ : P} (p₂ : P) (r : 𝕜),
p₁ ∈ s →
(EuclideanGeometry.reflection s) (r • (p₂ -ᵥ ↑((EuclideanGeometry.orthogonalProjection s) p₂)) +ᵥ p₁) =
-(r • (p₂ -ᵥ ↑((EuclideanGeometry.orthogonalProjection s) p₂))) +ᵥ p₁ |
KaehlerDifferential.kerTotal_map | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
(B : Type u_3) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra A B]
[inst_7 : Algebra S B] [inst_8 : Algebra R B] [IsScalarTower R A B] [IsScalarTower R S B],
Function.Surjective ⇑(algebraMap A B) →
Submodule.map (Finsupp.mapRange.linearMap (Algebra.linearMap A B) ∘ₗ Finsupp.lmapDomain A A ⇑(algebraMap A B))
(KaehlerDifferential.kerTotal R A) ⊔
Submodule.span A (Set.range fun x => fun₀ | (algebraMap S B) x => 1) =
Submodule.restrictScalars A (KaehlerDifferential.kerTotal S B) |
Std.Do.SPred.down_pure | Std.Do.SPred.Laws | ∀ {φ : Prop}, ⌜φ⌝.down = φ |
Std.Broadcast.instReprError.repr | Std.Sync.Broadcast | Std.Broadcast.Error → ℕ → Std.Format |
QuadraticAlgebra.instAlgebra._proof_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {S : Type u_2} {a b : R} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra S R]
(s : S) (z : QuadraticAlgebra R a b),
{ toFun := fun s => QuadraticAlgebra.C ((algebraMap S R) s), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ }
s *
z =
z *
{ toFun := fun s => QuadraticAlgebra.C ((algebraMap S R) s), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
map_add' := ⋯ }
s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.