name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
DividedPowers.ideal_from_ringHom._proof_1 | Mathlib.RingTheory.DividedPowers.DPMorphism | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] {I : Ideal A} {J : Ideal B}
(hI : DividedPowers I) (hJ : DividedPowers J) {f : A →+* B},
Ideal.map f I ≤ J →
∀ {a b : A},
a ∈ {x | x ∈ I ∧ ∀ (n : ℕ), f (hI.dpow n x) = hJ.dpow n (f x)} →
b ∈ {x | x ∈ I ∧ ∀ (n : ℕ), f (hI.dpow n x) = hJ.dpow n (f x)} →
a + b ∈ {x | x ∈ I ∧ ∀ (n : ℕ), f (hI.dpow n x) = hJ.dpow n (f x)} |
CategoryTheory.Limits.colimitIsoSwapCompColim_hom_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(G : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (X : K),
(CategoryTheory.Limits.colimitIsoSwapCompColim G).hom.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation G X).hom
(CategoryTheory.Limits.colimMap (G.flipIsoCurrySwapUncurry.hom.app X)) |
Array.mem_map | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {xs : Array α}, b ∈ Array.map f xs ↔ ∃ a ∈ xs, f a = b |
Action.actionPUnitEquivalence | Mathlib.CategoryTheory.Action.Basic | {V : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} V] → Action V PUnit.{u_3 + 1} ≌ V |
Lean.Parser.Term.logNamedWarningAtMacro.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
CategoryTheory.WithTerminal.liftStar_inv | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z)
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x),
(CategoryTheory.WithTerminal.liftStar F M hM).inv = CategoryTheory.CategoryStruct.id Z |
StalkSkyscraperPresheafAdjunctionAuxs.counit_app | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v}
[inst_1 : CategoryTheory.Category.{u, v} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] (c : C),
(StalkSkyscraperPresheafAdjunctionAuxs.counit p₀).app c = (skyscraperPresheafStalkOfSpecializes p₀ c ⋯).hom |
Aesop.EqualUpToIds.Unsafe.localDeclsEqualUpToIdsCore | Aesop.Util.EqualUpToIds | Lean.LocalDecl → Lean.LocalDecl → ReaderT Aesop.EqualUpToIds.GoalContext Aesop.EqualUpToIdsM Bool |
ZeroAtInftyContinuousMap.instStar | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddMonoid β] → [inst_3 : StarAddMonoid β] → [ContinuousStar β] → Star (ZeroAtInftyContinuousMap α β) |
Fin.lt_of_lt_of_le | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b c : Fin n}, a < b → b ≤ c → a < c |
CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_leftAdjointMate_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.PrettyPrinter.Unexpander |
Std.Time.Weekday.instTransOrdOrdinal | Std.Time.Date.Unit.Weekday | Std.TransOrd Std.Time.Weekday.Ordinal |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise.0.Finpartition.equitabilise_aux._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) |
FormalMultilinearSeries.compContinuousLinearMap_apply | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} {G : Type x} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd F]
[inst_10 : ContinuousConstSMul 𝕜 F] [inst_11 : AddCommMonoid G] [inst_12 : Module 𝕜 G] [inst_13 : TopologicalSpace G]
[inst_14 : ContinuousAdd G] [inst_15 : ContinuousConstSMul 𝕜 G] (p : FormalMultilinearSeries 𝕜 F G) (u : E →L[𝕜] F)
(n : ℕ) (v : Fin n → E), (p.compContinuousLinearMap u n) v = (p n) (⇑u ∘ v) |
Lean.Compiler.LCNF.SpecState.mk.injEq | Lean.Compiler.LCNF.SpecInfo | ∀ (specInfo specInfo_1 : Lean.PHashMap Lean.Name Lean.Compiler.LCNF.SpecEntry),
({ specInfo := specInfo } = { specInfo := specInfo_1 }) = (specInfo = specInfo_1) |
AlgebraicGeometry.Scheme.AffineZariskiSite.relativeGluingData._proof_1 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {F : CategoryTheory.Functor X.AffineZariskiSiteᵒᵖ CommRingCat}
{α : (AlgebraicGeometry.Scheme.AffineZariskiSite.toOpensFunctor X).op.comp X.presheaf ⟶ F},
CategoryTheory.NatTrans.Coequifibered α →
CategoryTheory.NatTrans.Equifibered
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.rightOp α) AlgebraicGeometry.Scheme.Spec)
(AlgebraicGeometry.Scheme.AffineZariskiSite.restrictIsoSpec X).inv) |
LocallyConstant.instAddCommGroup._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup Y], ⇑0 = ⇑0 |
AddSubgroup.IsSubnormal.brecOn | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_2} [inst : AddGroup G] {motive : (a : AddSubgroup G) → a.IsSubnormal → Prop} {a : AddSubgroup G}
(t : a.IsSubnormal),
(∀ (a : AddSubgroup G) (t : a.IsSubnormal), AddSubgroup.IsSubnormal.below t → motive a t) → motive a t |
CategoryTheory.Limits.WalkingSpan.Hom.snd | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | CategoryTheory.Limits.WalkingSpan.zero ⟶ CategoryTheory.Limits.WalkingSpan.right |
Lean.Meta.SolveByElim.initFn._@.Lean.Meta.Tactic.SolveByElim.1979843508._hygCtx._hyg.2 | Lean.Meta.Tactic.SolveByElim | IO Unit |
FiniteField.frobeniusAlgEquiv_symm_apply | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) (R : Type u_2) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [inst_4 : ExpChar R p] [inst_5 : PerfectRing R p] (b : R),
(FiniteField.frobeniusAlgEquiv K R p).symm b = Function.surjInv ⋯ b |
ProfiniteGrp.limit | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] → CategoryTheory.Functor J ProfiniteGrp.{max v u} → ProfiniteGrp.{max v u} |
AddMonoidAlgebra.single_commute_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {r₁ r₂ : R} {m₁ m₂ : M} [inst_1 : Add M],
AddCommute m₁ m₂ → Commute r₁ r₂ → Commute (AddMonoidAlgebra.single m₁ r₁) (AddMonoidAlgebra.single m₂ r₂) |
Ordinal.veblen_zero_le_veblen_zero._simp_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ {o₁ o₂ : Ordinal.{u}}, (Ordinal.veblen o₁ 0 ≤ Ordinal.veblen o₂ 0) = (o₁ ≤ o₂) |
CategoryTheory.Limits.BinaryBicone.isBilimitOfKernelInl._proof_3 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(b : CategoryTheory.Limits.BinaryBicone X Y) (hb : CategoryTheory.Limits.IsLimit b.sndKernelFork) {T : C} (f : T ⟶ X)
(g : T ⟶ Y) (m : T ⟶ b.toCone.pt),
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Limits.BinaryFan.fst b.toCone) = f →
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Limits.BinaryFan.snd b.toCone) = g →
m = (fun {T} f g => CategoryTheory.CategoryStruct.comp f b.inl + CategoryTheory.CategoryStruct.comp g b.inr) f g |
Submodule.IsCompl.projection_apply_left | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q) (x : ↥p), (Submodule.IsCompl.projection hpq) ↑x = ↑x |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfAux.match_3 | Mathlib.Tactic.TermCongr | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(lhs rhs : Lean.Expr) →
((fn arg fn_1 arg_1 : Lean.Expr) → motive (fn.app arg) (fn_1.app arg_1)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(binderName_1 : Lean.Name) →
(binderType_1 body_1 : Lean.Expr) →
(binderInfo_1 : Lean.BinderInfo) →
motive (Lean.Expr.lam binderName binderType body binderInfo)
(Lean.Expr.lam binderName_1 binderType_1 body_1 binderInfo_1)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(binderName_1 : Lean.Name) →
(binderType_1 body_1 : Lean.Expr) →
(binderInfo_1 : Lean.BinderInfo) →
motive (Lean.Expr.forallE binderName binderType body binderInfo)
(Lean.Expr.forallE binderName_1 binderType_1 body_1 binderInfo_1)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) →
(declName_1 : Lean.Name) →
(type_1 value_1 body_1 : Lean.Expr) →
(nondep_1 : Bool) →
motive (Lean.Expr.letE declName type value body nondep)
(Lean.Expr.letE declName_1 type_1 value_1 body_1 nondep_1)) →
((data : Lean.MData) →
(lhs' : Lean.Expr) →
(data_1 : Lean.MData) →
(rhs' : Lean.Expr) → motive (Lean.Expr.mdata data lhs') (Lean.Expr.mdata data_1 rhs')) →
((n1 : Lean.Name) →
(i1 : ℕ) →
(e1 : Lean.Expr) →
(n2 : Lean.Name) →
(i2 : ℕ) → (e2 : Lean.Expr) → motive (Lean.Expr.proj n1 i1 e1) (Lean.Expr.proj n2 i2 e2)) →
((x x_1 : Lean.Expr) → motive x x_1) → motive lhs rhs |
_private.Mathlib.Order.LiminfLimsup.0.Filter.HasBasis.liminf_eq_ciSup_ciInf._simp_1_4 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u} (s : Set α), (∅ ⊆ s) = True |
AntivaryOn.neg_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : AddCommGroup β]
[inst_2 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
AntivaryOn f g s → MonovaryOn f (-g) s |
Finsupp.mem_supported | Mathlib.LinearAlgebra.Finsupp.Supported | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set α} (p : α →₀ M), p ∈ Finsupp.supported M R s ↔ ↑p.support ⊆ s |
Equiv.Perm.OnCycleFactors.coe_toPermHom | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (g : Equiv.Perm α) (k : ↥(Subgroup.centralizer {g}))
(c : ↥g.cycleFactorsFinset), ↑(((Equiv.Perm.OnCycleFactors.toPermHom g) k) c) = ↑k * ↑c * (↑k)⁻¹ |
Lean.Order.MonoBind.mk._flat_ctor | Init.Internal.Order.Basic | ∀ {m : Type u → Type v} [inst : Bind m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)],
(∀ {α β : Type u} {a₁ a₂ : m α} {f : α → m β},
Lean.Order.PartialOrder.rel a₁ a₂ → Lean.Order.PartialOrder.rel (a₁ >>= f) (a₂ >>= f)) →
(∀ {α β : Type u} {a : m α} {f₁ f₂ : α → m β},
(∀ (x : α), Lean.Order.PartialOrder.rel (f₁ x) (f₂ x)) → Lean.Order.PartialOrder.rel (a >>= f₁) (a >>= f₂)) →
Lean.Order.MonoBind m |
Lean.Exception.casesOn | Lean.Exception | {motive : Lean.Exception → Sort u} →
(t : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive t |
OrderIso.sumLexAssoc_symm_apply_inl | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : LE γ] (a : α),
(OrderIso.sumLexAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a) |
_private.Mathlib.MeasureTheory.Function.L1Space.Integrable.0.MeasureTheory.Integrable.real_toNNReal._simp_1_1 | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G},
(|a| ≤ b) = (-b ≤ a ∧ a ≤ b) |
Matroid.delete_eq_delete_iff | Mathlib.Combinatorics.Matroid.Minor.Delete | ∀ {α : Type u_1} {M : Matroid α} {D₁ D₂ : Set α}, M.delete D₁ = M.delete D₂ ↔ D₁ ∩ M.E = D₂ ∩ M.E |
BialgCat.hasForgetToCoalgebra._proof_3 | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {x x_1 : BialgCat R},
CoalgHomClass (x.carrier →ₐc[R] x_1.carrier) R x.carrier x_1.carrier |
Module.support | Mathlib.RingTheory.Support | (R : Type u_1) → (M : Type u_2) → [inst : CommRing R] → [inst_1 : AddCommGroup M] → [Module R M] → Set (PrimeSpectrum R) |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAux._proof_2 | Mathlib.RingTheory.AdicCompletion.Exactness | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_1} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : Type u_1} [inst_5 : AddCommGroup P]
[inst_6 : Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P} (hfg : Function.Exact ⇑f ⇑g) (hg : Function.Surjective ⇑g)
{k : ℕ} (x : AdicCompletion.AdicCauchySequence I N) (hker : ∀ (n : ℕ), g (↑x n) ∈ I ^ n • ⊤),
∃ y, ⋯.choose ∈ I ^ (k + 0) • ⊤ ∧ f y = ↑x (k + 0) - ⋯.choose |
SlashInvariantForm.quotientFunc | Mathlib.NumberTheory.ModularForms.NormTrace | {𝒢 ℋ : Subgroup (GL (Fin 2) ℝ)} →
{F : Type u_1} →
F →
[inst : FunLike F UpperHalfPlane ℂ] →
{k : ℤ} → [SlashInvariantFormClass F 𝒢 k] → ↥ℋ ⧸ 𝒢.subgroupOf ℋ → UpperHalfPlane → ℂ |
Lean.Server.Watchdog.ReferenceData.mk | Lean.Server.Watchdog | Lean.Server.ServerTask Unit →
Lean.Server.References →
Std.TreeMap Lean.Lsp.DocumentUri ℕ compare →
Array Lean.Server.Watchdog.WaitForILeanRequest → Lean.Server.Watchdog.ReferenceData |
Lean.Elab.InlayHintTextEdit.toLspTextEdit | Lean.Server.FileWorker.InlayHints | Lean.FileMap → Lean.Elab.InlayHintTextEdit → Lean.Lsp.TextEdit |
CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor_obj_left_left_as | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {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₃}
{R : CategoryTheory.Functor C₂ C₄} {B : CategoryTheory.Functor C₃ C₄} (w : CategoryTheory.TwoSquare T L R B)
{X₃ : C₃ᵒᵖ} {X₂ : C₂ᵒᵖ} (g : B.op.obj X₃ ⟶ R.op.obj X₂) (f : (w.op.StructuredArrowRightwards g)ᵒᵖ),
((CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor w g).obj f).left.left.as = PUnit.unit |
FiniteGaloisIntermediateField.instOrderBot._proof_1 | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(x : FiniteGaloisIntermediateField k K), ⊥ ≤ x.toIntermediateField |
LaurentPolynomial.toLaurent_support | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R),
(Polynomial.toLaurent f).support = Finset.map Nat.castEmbedding f.support |
Vector.lt_of_le_of_lt' | Init.Data.Vector.Lex | ∀ {α : Type u_1} {n : ℕ} [inst : LT α] [Std.Asymm fun x1 x2 => x1 < x2] [Std.Trichotomous fun x1 x2 => x1 < x2]
[Trans (fun x1 x2 => ¬x1 < x2) (fun x1 x2 => ¬x1 < x2) fun x1 x2 => ¬x1 < x2] {xs ys zs : Vector α n},
xs ≤ ys → ys < zs → xs < zs |
GenContFract.exists_conts_a_of_num | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} {n : ℕ} [inst : DivisionRing K] {A : K},
g.nums n = A → ∃ conts, g.conts n = conts ∧ conts.a = A |
Affine.Triangle.equilateral_iff_dist_01_eq_02_and_dist_01_eq_12 | Mathlib.Analysis.Normed.Affine.Simplex | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : PseudoMetricSpace P] [inst_3 : Module R V] [inst_4 : NormedAddTorsor V P] {t : Affine.Triangle R P},
Affine.Simplex.Equilateral t ↔
dist (t.points 0) (t.points 1) = dist (t.points 0) (t.points 2) ∧
dist (t.points 0) (t.points 1) = dist (t.points 1) (t.points 2) |
SupClosed.iSup_mem | Mathlib.Order.SupClosed | ∀ {ι : Sort u_1} {α : Type u_3} [inst : CompleteLattice α] {f : ι → α} {s : Set α} [Finite ι],
SupClosed s → ⊥ ∈ s → (∀ (i : ι), f i ∈ s) → ⨆ i, f i ∈ s |
_private.Mathlib.LinearAlgebra.SesquilinearForm.Basic.0.LinearMap.isPairSelfAdjoint_equiv._simp_1_3 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} {M₃ : Type u_8} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] [inst_5 : AddCommMonoid M₃]
[inst_6 : Module R M₃] {I : R →+* R} {B : M →ₗ[R] M →ₛₗ[I] M₃} {B' : M₁ →ₗ[R] M₁ →ₛₗ[I] M₃} {f : M →ₗ[R] M₁}
{g : M₁ →ₗ[R] M}, B.IsAdjointPair B' ⇑f ⇑g = (B' ∘ₗ f = B.compl₂ g) |
instMulSemiringActionSubtypeMemSubalgebraIntegralClosure._proof_6 | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ {G : Type u_3} {R : Type u_2} {K : Type u_1} [inst : CommRing R] [inst_1 : CommRing K] [inst_2 : Algebra R K]
[inst_3 : Group G] [inst_4 : MulSemiringAction G K] [inst_5 : SMulCommClass G R K] (g : G)
(x y : ↥(integralClosure R K)), g • (x * y) = g • x * g • y |
Lean.Parser.Termination.partialFixpoint.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Module.isPrincipal_submodule_iff.match_1_2 | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p : Submodule R M}
(a : ↥p) (m : M) (hm : m ∈ p) (motive : (∃ a_1, a_1 • a = ⟨m, hm⟩) → Prop) (x : ∃ a_1, a_1 • a = ⟨m, hm⟩),
(∀ (r : R) (hr : r • a = ⟨m, hm⟩), motive ⋯) → motive x |
seminormFromConst._proof_4 | Mathlib.Analysis.Normed.Unbundled.SeminormFromConst | ∀ {R : Type u_1} [inst : CommRing R] {c : R} {f : RingSeminorm R},
f 1 ≤ 1 →
f c ≠ 0 →
IsPowMul ⇑f → ∀ (x y : R), seminormFromConst' c f (x + y) ≤ seminormFromConst' c f x + seminormFromConst' c f y |
AlgebraicGeometry.Scheme.stalkMapIsoOfIsPullback._proof_5 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {P Y Z : AlgebraicGeometry.Scheme} {snd : P ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsOpenImmersion g] (p : ↥P),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap g (snd p)) |
openSegment_symm | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), openSegment 𝕜 x y = openSegment 𝕜 y x |
Int.le_refl | Init.Data.Int.Order | ∀ (a : ℤ), a ≤ a |
Set.mem_graphOn._simp_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x : α × β}, (x ∈ Set.graphOn f s) = (x.1 ∈ s ∧ f x.1 = x.2) |
Filter.eventually_all_finset._simp_1 | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Type u_2} (I : Finset ι) {l : Filter α} {p : ι → α → Prop},
(∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) = ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x |
Function.Injective.commMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : CommMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) → (∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n) → CommMonoid M₁ |
Std.DTreeMap.Internal.Impl.Const.minEntry?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v}, Std.DTreeMap.Internal.Impl.Const.minEntry? Std.DTreeMap.Internal.Impl.leaf = none |
CauSeq.const_inv | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {x : β} (hx : x ≠ 0),
CauSeq.const abv x⁻¹ = (CauSeq.const abv x).inv ⋯ |
Filter.map_eval_pi | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → Filter (α i)) [∀ (i : ι), (f i).NeBot] (i : ι),
Filter.map (Function.eval i) (Filter.pi f) = f i |
CategoryTheory.Limits.pullbackDiagonalMapIdIso._proof_13 | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{S T : C} (f : X ⟶ T) (g : Y ⟶ T) (i : T ⟶ S) [CategoryTheory.Limits.HasPullback f g],
CategoryTheory.Limits.HasPullback
(CategoryTheory.CategoryStruct.comp f
(CategoryTheory.inv (CategoryTheory.Limits.pullback.fst i (CategoryTheory.CategoryStruct.id S))))
(CategoryTheory.CategoryStruct.comp g
(CategoryTheory.inv (CategoryTheory.Limits.pullback.fst i (CategoryTheory.CategoryStruct.id S)))) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit_list._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Polynomial.aeval_eq_smeval | Mathlib.Algebra.Polynomial.Smeval | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : Semiring S] [inst_2 : Algebra R S] (x : S)
(p : Polynomial R), (Polynomial.aeval x) p = p.smeval x |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.eqvTypes._sparseCasesOn_1 | Lean.Compiler.LCNF.InferType | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((u : Lean.Level) → motive (Lean.Expr.sort u)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 1272 t.ctorIdx → motive t) → motive t |
Std.ExtHashMap.size_alter_eq_self_of_not_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∉ m → (f m[k]?).isNone = true → (m.alter k f).size = m.size |
NonemptyInterval.instPartialOrder | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : PartialOrder α] → PartialOrder (NonemptyInterval α) |
CategoryTheory.Pi.laxMonoidalPi'_μ | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : (i : I) → CategoryTheory.Functor D (C i)) [inst_4 : (i : I) → (F i).LaxMonoidal] (X Y : D) (i : I),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Functor.pi' F) X Y i =
CategoryTheory.Functor.LaxMonoidal.μ (F i) X Y |
Set.Nonempty.sigma_fst | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}, (s.sigma t).Nonempty → s.Nonempty |
HasLineDerivAt.le_of_lip' | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {v : E}
{f : E → F} {f' : F} {x₀ : E},
HasLineDerivAt 𝕜 f f' x₀ v → ∀ {C : ℝ}, 0 ≤ C → (∀ᶠ (x : E) in nhds x₀, ‖f x - f x₀‖ ≤ C * ‖x - x₀‖) → ‖f'‖ ≤ C * ‖v‖ |
AlgebraicGeometry.Scheme.IdealSheafData.instCompleteLattice._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (a b c : X.IdealSheafData), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c |
Int.Linear.Poly.insert._unsafe_rec | Init.Data.Int.Linear | ℤ → Int.Linear.Var → Int.Linear.Poly → Int.Linear.Poly |
Matrix.nnnorm_conjTranspose | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] [inst_3 : StarAddMonoid α] [NormedStarGroup α] (A : Matrix m n α),
‖A.conjTranspose‖₊ = ‖A‖₊ |
NumberField.mixedEmbedding.euclidean.toMixed | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | (K : Type u_1) →
[inst : Field K] →
[inst_1 : NumberField K] →
NumberField.mixedEmbedding.euclidean.mixedSpace K ≃L[ℝ] NumberField.mixedEmbedding.mixedSpace K |
_private.Batteries.Data.List.Lemmas.0.List.isSome_isPrefixOf?_eq_isPrefixOf.match_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Prop) (xs ys : List α),
(∀ (x : List α), motive [] x) →
(∀ (head : α) (tail : List α), motive (head :: tail) []) →
(∀ (head : α) (tail : List α) (head_1 : α) (tail_1 : List α), motive (head :: tail) (head_1 :: tail_1)) →
motive xs ys |
Aesop.PhaseSpec.phase | Aesop.Builder.Basic | Aesop.PhaseSpec → Aesop.PhaseName |
_private.Mathlib.Algebra.Group.Pointwise.Finset.Basic.0.Finset.isUnit_coe._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} {s : Finset α} {a : α}, (↑s = {a}) = (s = {a}) |
Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.casesOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {motive : Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval) →
((lo hi : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound) →
motive (Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.co lo hi)) →
((lo : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound) →
motive (Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.ci lo)) →
((hi : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound) →
motive (Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.io hi)) →
motive Lean.Meta.Grind.Arith.Cutsat.SymbolicIntInterval.ii → motive t |
Orientation.norm_div_cos_oangle_add_right_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖x‖ / (o.oangle x (x + y)).cos = ‖x + y‖ |
TemperedDistribution.delta_apply | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E) (f : SchwartzMap E ℂ),
(TemperedDistribution.delta x) f = f x |
_private.Mathlib.Analysis.Normed.Group.Pointwise.0.IsCompact.mul_closedBall_one._simp_1_1 | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a : α}, (a ∈ s * t) = ∃ x ∈ s, ∃ y ∈ t, x * y = a |
EquivLike.mk | Mathlib.Data.FunLike.Equiv | {E : Sort u_1} →
{α : outParam (Sort u_2)} →
{β : outParam (Sort u_3)} →
(coe : E → α → β) →
(inv : E → β → α) →
(∀ (e : E), Function.LeftInverse (inv e) (coe e)) →
(∀ (e : E), Function.RightInverse (inv e) (coe e)) →
(∀ (e g : E), coe e = coe g → inv e = inv g → e = g) → EquivLike E α β |
List.offDiag_singleton | Mathlib.Data.List.OffDiag | ∀ {α : Type u_1} (a : α), [a].offDiag = [] |
Std.DTreeMap.Internal.Impl.entryAtIdx?._sunfold | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β → ℕ → Option ((a : α) × β a) |
UpperSet.sdiff_singleton | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : UpperSet α) (a : α), s.sdiff {a} = s.erase a |
instStarMulWithConvMatrix | Mathlib.LinearAlgebra.Matrix.WithConv | {m : Type u_1} → {n : Type u_2} → {α : Type u_3} → [inst : Mul α] → [StarMul α] → StarMul (WithConv (Matrix m n α)) |
Nat.coprime_ordCompl | Mathlib.Data.Nat.Factorization.Basic | ∀ {n p : ℕ}, Nat.Prime p → n ≠ 0 → p.Coprime (n / p ^ n.factorization p) |
UniformSpace.Completion.instNormedFieldOfCompletableTopField._proof_2 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : NormedField A], Continuous fun x => ‖x.1‖ * ‖x.2‖ |
Pi.vaddCommClass' | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {M : Type u_2} {α : ι → Type u_4} {β : ι → Type u_5} [inst : (i : ι) → VAdd M (β i)]
[inst_1 : (i : ι) → VAdd (α i) (β i)] [∀ (i : ι), VAddCommClass M (α i) (β i)],
VAddCommClass M ((i : ι) → α i) ((i : ι) → β i) |
Set.image2_iUnion₂_right | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {ι : Sort u_5} {κ : ι → Sort u_8} (f : α → β → γ) (s : Set α)
(t : (i : ι) → κ i → Set β), Set.image2 f s (⋃ i, ⋃ j, t i j) = ⋃ i, ⋃ j, Set.image2 f s (t i j) |
Dynamic.mk | Init.Dynamic | {α : Type u_1} → [TypeName α] → α → Dynamic |
CategoryTheory.InjectiveResolution.Hom.noConfusionType | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} →
{I : CategoryTheory.InjectiveResolution Z} →
{Z' : C} →
{I' : CategoryTheory.InjectiveResolution Z'} →
{f : Z ⟶ Z'} →
I.Hom I' f →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst'_1 : CategoryTheory.Limits.HasZeroObject C'] →
[inst'_2 : CategoryTheory.Limits.HasZeroMorphisms C'] →
{Z' : C'} →
{I' : CategoryTheory.InjectiveResolution Z'} →
{Z'' : C'} →
{I'' : CategoryTheory.InjectiveResolution Z''} →
{f' : Z' ⟶ Z''} → I'.Hom I'' f' → Sort u_1 |
BitVec.fill_true | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, BitVec.fill w true = BitVec.allOnes w |
Std.Internal.List.keys_nil | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v}, Std.Internal.List.keys [] = [] |
USize.zero_and | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 &&& a = 0 |
DoubleCentralizer.instCoeTC | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u_1} →
{A : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] →
[inst_2 : NormedSpace 𝕜 A] →
[inst_3 : SMulCommClass 𝕜 A A] → [inst_4 : IsScalarTower 𝕜 A A] → CoeTC A (DoubleCentralizer 𝕜 A) |
CategoryTheory.Limits.Fork.isLimitForkPushoutEquivIsColimitForkOpPullback._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasPushout f f] [inst_2 : CategoryTheory.Limits.HasPullback f.op f.op],
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.pushoutIsoUnopPullback f f).op.symm ≪≫ CategoryTheory.eqToIso ⋯).hom
(CategoryTheory.Limits.pullback.snd f.op f.op) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f f).op
(CategoryTheory.Iso.refl (Opposite.op Y)).hom |
Finset.sum_set_coe | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] {f : ι → M} (s : Set ι) [inst_1 : Fintype ↑s],
∑ i, f ↑i = ∑ i ∈ s.toFinset, f i |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.