name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Filter.image_mem_map_iff | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {s : Set α},
Function.Injective m → (m '' s ∈ Filter.map m f ↔ s ∈ f) |
Std.Time.Hour.Offset.ofDays | Std.Time.Date.Basic | Std.Time.Day.Offset → Std.Time.Hour.Offset |
one_sub_goldConj | Mathlib.NumberTheory.Real.GoldenRatio | 1 - Real.goldenRatio = Real.goldenConj |
Polynomial.coeff_mul_add_eq_of_natDegree_le | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {df dg : ℕ} {f g : Polynomial R},
f.natDegree ≤ df → g.natDegree ≤ dg → (f * g).coeff (df + dg) = f.coeff df * g.coeff dg |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.get_EStateM._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) |
Units.Simps.val_inv.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), Units.Simps.val_inv u = ↑u⁻¹ |
Int8.toInt16_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int8), (a ^^^ b).toInt16 = a.toInt16 ^^^ b.toInt16 |
_private.Init.Data.Array.Erase.0.Array.eraseIdx_set._proof_3 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α} {hi : i < xs.size} {j : ℕ}, j < i → ¬i - 1 < xs.size - 1 → False |
Nat.add_div | Init.Data.Nat.Div.Lemmas | ∀ {a b c : ℕ}, 0 < c → (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0 |
CategoryTheory.Limits.binaryFanZeroRightIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryFan X 0),
CategoryTheory.CategoryStruct.comp ((fun s => s.fst) s) (CategoryTheory.CategoryStruct.id X) = s.fst |
Iff.mpr | Init.Core | ∀ {a b : Prop}, (a ↔ b) → b → a |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_25 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] [inst_1 : LawfulBEq ι] (a : ι) (l : List ι) (n : ℕ) (hi : n + 1 < (a :: l).length)
(w : ι) (h_5 : ((a :: l)[n + 1] == w) = true), (List.findIdxs (fun x => x == w) (a :: l))[0] < (a :: l).length |
Matrix.kroneckerMap_zero_left | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
[inst : Zero α] [inst_1 : Zero γ] (f : α → β → γ),
(∀ (b : β), f 0 b = 0) → ∀ (B : Matrix n p β), Matrix.kroneckerMap f 0 B = 0 |
_private.Lean.Level.0.Lean.Level.isExplicitSubsumedAux | Lean.Level | Array Lean.Level → ℕ → ℕ → Bool |
_private.Lean.Meta.Sym.Simp.App.0.Lean.Meta.Sym.Simp.simpUsingCongrThm | Lean.Meta.Sym.Simp.App | Lean.Expr → Lean.Meta.CongrTheorem → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.ofRestrict | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X : TopCat} (Y : AlgebraicGeometry.LocallyRingedSpace) {f : X ⟶ ↑Y.toPresheafedSpace}
(hf : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion (Y.ofRestrict hf) |
DividedPowers.coincide_on_smul | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {a : A} (hI : DividedPowers I) {J : Ideal A}
(hJ : DividedPowers J) {n : ℕ}, a ∈ I • J → hI.dpow n a = hJ.dpow n a |
_private.Qq.Macro.0.Qq.Impl.quoteLCtx.match_1 | Qq.Macro | (motive : MProd (Array Lean.Expr) Lean.LocalContext → Sort u_1) →
(r : MProd (Array Lean.Expr) Lean.LocalContext) →
((assignments : Array Lean.Expr) → (quotedCtx : Lean.LocalContext) → motive ⟨assignments, quotedCtx⟩) → motive r |
List.filterMapM.loop._sunfold | Init.Data.List.Control | {m : Type u → Type v} → [Monad m] → {α : Type w} → {β : Type u} → (α → m (Option β)) → List α → List β → m (List β) |
List.MergeSort.Internal.splitRevInTwo_fst._proof_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} {n : ℕ} (l : { l // l.length = n }),
(↑(List.MergeSort.Internal.splitInTwo l).1).reverse.length = (n + 1) / 2 |
Lean.Meta.Sym.Offset.num.elim | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) → t.ctorIdx = 0 → ((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) → motive t |
CategoryTheory.Subgroupoid.instTop._proof_1 | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u_2} [inst : CategoryTheory.Groupoid C] {c d : C} {p : c ⟶ d},
p ∈ Set.univ → CategoryTheory.Groupoid.inv p ∈ Set.univ |
differentiableWithinAt_comp_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (a : E),
DifferentiableWithinAt 𝕜 (fun x => f (x - a)) s x ↔ DifferentiableWithinAt 𝕜 f (-a +ᵥ s) (x - a) |
CochainComplex.ConnectData.d_negSucc | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m : ℕ),
h.d (Int.negSucc n) (Int.negSucc m) = K.d n m |
Lean.Meta.Grind.SplitDiagInfo.c | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.SplitDiagInfo → Lean.Expr |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.toIntInst | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Lean.Expr |
Matrix.frobenius_norm_replicateRow | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {α : Type u_5} {ι : Type u_7} [inst : Fintype m] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : m → α), ‖Matrix.replicateRow ι v‖ = ‖WithLp.toLp 2 v‖ |
AlgebraicGeometry.Scheme.Pullback.range_diagonal_subset_diagonalCoverDiagonalRange | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 : (i : 𝒰.I₀) → (CategoryTheory.Limits.pullback f (𝒰.f i)).OpenCover),
Set.range ⇑(CategoryTheory.Limits.pullback.diagonal f) ⊆
↑(AlgebraicGeometry.Scheme.Pullback.diagonalCoverDiagonalRange f 𝒰 𝒱) |
NonUnitalAlgebra.map_top | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] [inst_5 : IsScalarTower R A A]
[inst_6 : SMulCommClass R A A] (f : A →ₙₐ[R] B), NonUnitalSubalgebra.map f ⊤ = NonUnitalAlgHom.range f |
Lean.ImportArtifacts.size | Lean.Setup | Lean.ImportArtifacts → ℕ |
_private.Lean.Server.Requests.0.Lean.Server.chainLspRequestHandler.match_1 | Lean.Server.Requests | (motive : Option Lean.Json → Sort u_1) →
(x : Option Lean.Json) → (Unit → motive none) → ((response : Lean.Json) → motive (some response)) → motive x |
Lean.Elab.Tactic.MkSimpContextResult | Lean.Elab.Tactic.Simp | Type |
Lean.Linter.LinterOptions._sizeOf_1 | Lean.Linter.Basic | Lean.Linter.LinterOptions → ℕ |
AddGroupSeminorm.rec | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupSeminorm G → Sort u} →
((toFun : G → ℝ) →
(map_zero' : toFun 0 = 0) →
(add_le' : ∀ (r s : G), toFun (r + s) ≤ toFun r + toFun s) →
(neg' : ∀ (r : G), toFun (-r) = toFun r) →
motive { toFun := toFun, map_zero' := map_zero', add_le' := add_le', neg' := neg' }) →
(t : AddGroupSeminorm G) → motive t |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Type u_1} {s : Finset α} {m : Sym2 α}, (m ∈ s.sym2) = ∀ a ∈ m, a ∈ s |
Matroid.IsBasis.cardinalMk_le_cRk | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {I X : Set α}, M.IsBasis I X → Cardinal.mk ↑I ≤ M.cRk X |
Std.Rco.forIn'_eq_forIn'_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : LE α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_6 : Std.Rxo.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {γ : Type u} {init : γ} {m : Type u → Type w} [inst_8 : Monad m]
[LawfulMonad m] {f : (a : α) → a ∈ r → γ → m (ForInStep γ)},
forIn' r init f = forIn' r.toArray init fun a ha acc => f a ⋯ acc |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_38 | Mathlib.Computability.TMToPartrec | ∀ (k : Turing.PartrecToTM2.K') (s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ')
(q q_1 : Turing.PartrecToTM2.Λ'), Turing.PartrecToTM2.Λ'.push k s q = q_1.succ → False |
natCard_units_lt | Mathlib.RingTheory.Fintype | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] [Nontrivial M₀] [Finite M₀], Nat.card M₀ˣ < Nat.card M₀ |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastShiftLeft._proof_1_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftLeft | ∀ {w0 : ℕ} (idx n : ℕ), ¬0 ≤ n - 1 → False |
Fin.val_fin_le | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, ↑a ≤ ↑b ↔ a ≤ b |
Submodule.coe_matrix | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_14} {M : Type u_15} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (S : Submodule R M), ↑S.matrix = (↑S).matrix |
le_of_inf_eq | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b = a → a ≤ b |
Algebra.TensorProduct.basisAux._proof_4 | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R R A |
Lean.findParentProjStruct? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name |
CategoryTheory.Limits.WidePullbackShape.struct._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} {Z : CategoryTheory.Limits.WidePullbackShape J}, Z = none → none = Z |
Module.Flat.tensorSubmoduleAlgebraEquiv._proof_1 | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R A A |
Lean.Doc.instMonadStateOfInternalStateDocM | Lean.Elab.DocString | MonadStateOf Lean.Doc.InternalState Lean.Doc.DocM |
MeasureTheory.tendsto_setIntegral_of_L1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {ι : Type u_6} (f : α → G),
MeasureTheory.Integrable f μ →
∀ {F : ι → α → G} {l : Filter ι},
(∀ᶠ (i : ι) in l, MeasureTheory.Integrable (F i) μ) →
Filter.Tendsto (fun i => ∫⁻ (x : α), ‖F i x - f x‖ₑ ∂μ) l (nhds 0) →
∀ (s : Set α), Filter.Tendsto (fun i => ∫ (x : α) in s, F i x ∂μ) l (nhds (∫ (x : α) in s, f x ∂μ)) |
StarMul.noConfusion | Mathlib.Algebra.Star.Basic | {P : Sort u_1} →
{R : Type u} →
{inst : Mul R} →
{t : StarMul R} →
{R' : Type u} →
{inst' : Mul R'} → {t' : StarMul R'} → R = R' → inst ≍ inst' → t ≍ t' → StarMul.noConfusionType P t t' |
FractionalIdeal.absNorm_div_norm_eq_absNorm_div_norm | Mathlib.RingTheory.FractionalIdeal.Norm | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Module.Free ℤ R] [Module.Finite ℤ R]
{K : Type u_2} [inst_4 : CommRing K] [inst_5 : Algebra R K] [IsFractionRing R K]
{I : FractionalIdeal (nonZeroDivisors R) K} (a : ↥(nonZeroDivisors R)) (I₀ : Ideal R),
a • ↑I = Submodule.map (Algebra.linearMap R K) I₀ →
↑(Ideal.absNorm I.num) / ↑|(Algebra.norm ℤ) ↑I.den| = ↑(Ideal.absNorm I₀) / ↑|(Algebra.norm ℤ) ↑a| |
continuous_algebraMap_iff_smul | Mathlib.Topology.Algebra.Algebra | ∀ (R : Type u_1) (A : Type u) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : TopologicalSpace R] [inst_4 : TopologicalSpace A] [ContinuousMul A],
Continuous ⇑(algebraMap R A) ↔ Continuous fun p => p.1 • p.2 |
PMF.ofFinset.congr_simp | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} (f f_1 : α → ENNReal) (e_f : f = f_1) (s s_1 : Finset α) (e_s : s = s_1) (h : ∑ a ∈ s, f a = 1)
(h' : ∀ a ∉ s, f a = 0), PMF.ofFinset f s h h' = PMF.ofFinset f_1 s_1 ⋯ ⋯ |
Lean.LocalDeclKind | Lean.LocalContext | Type |
Subgroup.isRegularAtInfty_of_neg_one_mem | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] {𝒢 : Subgroup (GL (Fin 2) R)}, -1 ∈ 𝒢 → 𝒢.IsRegularAtInfty |
CategoryTheory.Functor.IsHomological | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | {C : Type u_1} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] →
CategoryTheory.Functor C A →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
[inst_4 : CategoryTheory.Preadditive C] →
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[CategoryTheory.Pretriangulated C] → [CategoryTheory.Abelian A] → Prop |
GromovHausdorff.auxGluing._proof_4 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ), Isometry (GromovHausdorff.optimalGHInjl (X n) (X (n + 1))) |
ENNReal.essSup_piecewise | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal} {s : Set α}
[inst : DecidablePred fun x => x ∈ s] {g : α → ENNReal},
MeasurableSet s → essSup (s.piecewise f g) μ = max (essSup f (μ.restrict s)) (essSup g (μ.restrict sᶜ)) |
toBoolAlg_zero | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α], toBoolAlg 0 = ⊥ |
Equiv.mulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.TransferInstance | ∀ (M₀ : Type u_2) {A : Type u_1} {B : Type u_3} (e : A ≃ B) [inst : MonoidWithZero M₀] [inst_1 : Zero B]
[inst_2 : MulActionWithZero M₀ B] (x y : M₀) (b : A), (x * y) • b = x • y • b |
IsLocalizedModule.mapExtendScalars | Mathlib.RingTheory.Localization.Module | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
{M' : Type u_3} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M'] →
[inst_3 : Module R M] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') →
[IsLocalizedModule S f] →
{N : Type u_4} →
{N' : Type u_5} →
[inst_6 : AddCommMonoid N] →
[inst_7 : AddCommMonoid N'] →
[inst_8 : Module R N] →
[inst_9 : Module R N'] →
(g : N →ₗ[R] N') →
[IsLocalizedModule S g] →
(Rₛ : Type u_6) →
[inst_11 : CommSemiring Rₛ] →
[inst_12 : Algebra R Rₛ] →
[inst_13 : Module Rₛ M'] →
[inst_14 : Module Rₛ N'] →
[IsScalarTower R Rₛ M'] →
[inst_16 : IsScalarTower R Rₛ N'] →
[IsLocalization S Rₛ] → (M →ₗ[R] N) →ₗ[R] M' →ₗ[Rₛ] N' |
Topology.IsClosed_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr |
_private.Mathlib.Data.Finset.Insert.0.Finset.insert_comm._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (s : Finset α), insert a (insert b s) = insert b (insert a s) |
Std.Tactic.BVDecide.BVExpr.WithCache.cache | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {α : Type u} →
{aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
Std.Tactic.BVDecide.BVExpr.WithCache α aig → Std.Tactic.BVDecide.BVExpr.Cache aig |
MonoidHom.FixedPointFree.commGroupOfInvolutive | Mathlib.GroupTheory.FixedPointFree | {F : Type u_1} →
{G : Type u_2} →
[inst : Group G] →
[inst_1 : FunLike F G G] →
[MonoidHomClass F G G] →
{φ : F} → [Finite G] → MonoidHom.FixedPointFree ⇑φ → Function.Involutive ⇑φ → CommGroup G |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_filter_eq_false_iff._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) |
mem_selfAdjointMatricesSubmodule' | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {n : Type u_5} [inst_1 : Fintype n] (J A : Matrix n n R₂)
[inst_2 : DecidableEq n], A ∈ selfAdjointMatricesSubmodule J ↔ J.IsSelfAdjoint A |
DirectLimit.instMulZeroOneClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → MulZeroOneClass (G i)]
[∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j),
MonoidHomClass (T h) (G i) (G j) |
RatFunc.ofFractionRing_eq | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : CommRing K] [inst_1 : IsDomain K],
RatFunc.ofFractionRing =
⇑(IsLocalization.algEquiv (nonZeroDivisors (Polynomial K)) (FractionRing (Polynomial K)) (RatFunc K)) |
TopCat.coconeOfCoconeForget._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] {F : CategoryTheory.Functor J TopCat}
(c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget TopCat))) (j j' : J) (φ : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (F.map φ) (TopCat.ofHom { toFun := c.ι.app j', continuous_toFun := ⋯ }) =
CategoryTheory.CategoryStruct.comp (TopCat.ofHom { toFun := c.ι.app j, continuous_toFun := ⋯ })
(((CategoryTheory.Functor.const J).obj
{ carrier := TopCat.coconePtOfCoconeForget c, str := TopCat.topologicalSpaceCoconePtOfCoconeForget c }).map
φ) |
Lean.LocalDecl.collectFVars | Lean.Meta.CollectFVars | Lean.LocalDecl → StateRefT' IO.RealWorld Lean.CollectFVars.State Lean.MetaM Unit |
Lean.Server.TransientWorkerILean.mk.injEq | Lean.Server.References | ∀ (moduleUri : Lean.Lsp.DocumentUri) (version : ℕ) (directImports : Lean.Server.DirectImports)
(isSetupFailure? : Option Bool) (refs : Lean.Lsp.ModuleRefs) (decls : Lean.Lsp.Decls)
(moduleUri_1 : Lean.Lsp.DocumentUri) (version_1 : ℕ) (directImports_1 : Lean.Server.DirectImports)
(isSetupFailure?_1 : Option Bool) (refs_1 : Lean.Lsp.ModuleRefs) (decls_1 : Lean.Lsp.Decls),
({ moduleUri := moduleUri, version := version, directImports := directImports, isSetupFailure? := isSetupFailure?,
refs := refs, decls := decls } =
{ moduleUri := moduleUri_1, version := version_1, directImports := directImports_1,
isSetupFailure? := isSetupFailure?_1, refs := refs_1, decls := decls_1 }) =
(moduleUri = moduleUri_1 ∧
version = version_1 ∧
directImports = directImports_1 ∧ isSetupFailure? = isSetupFailure?_1 ∧ refs = refs_1 ∧ decls = decls_1) |
RightPreLieAlgebra.instLeftPreLieAlgebraMulOpposite._proof_1 | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : RightPreLieRing L] [inst_2 : RightPreLieAlgebra R L],
IsScalarTower R Lᵐᵒᵖ Lᵐᵒᵖ |
CategoryTheory.Functor.RepresentableBy.yoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → (X : C) → (CategoryTheory.yoneda.obj X).RepresentableBy X |
Lean.Parser.Term.matchAltsWhereDecls.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
CategoryTheory.Localization.SmallShiftedHom.mk₀_comp_mk₀Inv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] {X Y : C}
[inst_3 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y]
[inst_4 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M Y Y]
[inst_5 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M Y X] [inst_6 : W.IsCompatibleWithShift M]
[inst_7 : W.RespectsIso] (m₀ : M) (hm₀ : m₀ = 0) (f : Y ⟶ X) (hf : W f),
(CategoryTheory.Localization.SmallShiftedHom.mk₀ W m₀ hm₀ f).comp
(CategoryTheory.Localization.SmallShiftedHom.mk₀Inv m₀ hm₀ f hf) ⋯ =
CategoryTheory.Localization.SmallShiftedHom.mk₀ W m₀ hm₀ (CategoryTheory.CategoryStruct.id Y) |
Matroid.Indep.isNonloop_of_mem | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.Indep I → e ∈ I → M.IsNonloop e |
MonoidAlgebra.liftNCRingHom_single | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R] (f : k →+* R)
(g : G →* R) (h_comm : ∀ (x : k) (y : G), Commute (f x) (g y)) (a : G) (b : k),
(MonoidAlgebra.liftNCRingHom f g h_comm) (MonoidAlgebra.single a b) = f b * g a |
AddGroupSeminorm.instSupSet._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (s : Set (AddGroupSeminorm E)),
BddAbove s → ∀ (x y : E), ⨆ p, ↑p (x + y) ≤ (⨆ p, ↑p x) + ⨆ p, ↑p y |
CategoryTheory.Bicategory.Adjunction.homEquiv₂._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c}
(α : CategoryTheory.CategoryStruct.comp g l ⟶ h),
(fun γ =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight γ l)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator h r l).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft h adj.counit)
(CategoryTheory.Bicategory.rightUnitor h).hom)))
((fun α =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft g adj.unit)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator g l r).inv
(CategoryTheory.Bicategory.whiskerRight α r))))
α) =
CategoryTheory.bicategoricalComp (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp g l))
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft g (CategoryTheory.Bicategory.whiskerRight adj.unit l))
(CategoryTheory.bicategoricalComp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight α (CategoryTheory.CategoryStruct.comp r l))
(CategoryTheory.Bicategory.whiskerLeft h adj.counit))
(CategoryTheory.CategoryStruct.id h))) |
Turing.TM2.Stmt.ctorElim | Mathlib.Computability.TuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(ctorIdx : ℕ) →
(t : Turing.TM2.Stmt Γ Λ σ) → ctorIdx = t.ctorIdx → Turing.TM2.Stmt.ctorElimType ctorIdx → motive t |
SimpleGraph.isEdgeReachable_two | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
G.IsEdgeReachable 2 u v ↔ ∀ (e : Sym2 V), (G.deleteEdges {e}).Reachable u v |
LeanSearchClient.initFn._@.LeanSearchClient.LoogleSyntax.2643959438._hygCtx._hyg.2 | LeanSearchClient.LoogleSyntax | IO (IO.Ref (Std.HashMap (String × ℕ) LeanSearchClient.LoogleResult)) |
HomogeneousLocalization.map._proof_11 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] (𝒜 : ι → σ)
[inst_5 : GradedRing 𝒜] {B : Type u_4} {τ : Type u_5} [inst_6 : CommRing B] [inst_7 : SetLike τ B]
[inst_8 : AddSubgroupClass τ B] (ℬ : ι → τ) [inst_9 : GradedRing ℬ] {P : Submonoid A} {Q : Submonoid B} (g : A →+* B)
(comap_le : P ≤ Submonoid.comap g Q) (hg : ∀ (i : ι), ∀ a ∈ 𝒜 i, g a ∈ ℬ i)
(q₁ q₂ : Quotient (Setoid.ker (HomogeneousLocalization.NumDenSameDeg.embedding 𝒜 P))),
Quotient.map' (fun x => { deg := x.deg, num := ⟨g ↑x.num, ⋯⟩, den := ⟨g ↑x.den, ⋯⟩, den_mem := ⋯ }) ⋯ (q₁ + q₂) =
Quotient.map' (fun x => { deg := x.deg, num := ⟨g ↑x.num, ⋯⟩, den := ⟨g ↑x.den, ⋯⟩, den_mem := ⋯ }) ⋯ q₁ +
Quotient.map' (fun x => { deg := x.deg, num := ⟨g ↑x.num, ⋯⟩, den := ⟨g ↑x.den, ⋯⟩, den_mem := ⋯ }) ⋯ q₂ |
CategoryTheory.sum.match_3 | Mathlib.CategoryTheory.Sums.Basic | (C : Type u_1) →
(D : Type u_2) →
(motive : C ⊕ D → Sort u_3) →
(X : C ⊕ D) → ((X : C) → motive (Sum.inl X)) → ((X : D) → motive (Sum.inr X)) → motive X |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.equalizerCondition_w._simp_1_2 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op |
List.chooseX.match_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (p : α → Prop) (l : α) (ls : List α) (x : α) (motive : x ∈ l :: ls ∧ p x → Prop)
(x_1 : x ∈ l :: ls ∧ p x), (∀ (o : x ∈ l :: ls) (h₂ : p x), motive ⋯) → motive x_1 |
IsGaloisGroup.fixedPoints_bot | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] [inst_5 : SMulCommClass G K L],
FixedPoints.intermediateField ↥⊥ = ⊤ |
exists_enorm_lt | Mathlib.Analysis.Normed.Group.Basic | ∀ (E : Type u_8) [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] [hbot : (nhdsWithin 0 {0}ᶜ).NeBot]
{c : ENNReal}, c ≠ 0 → ∃ x, x ≠ 0 ∧ ‖x‖ₑ < c |
CategoryTheory.Limits.biprod.braid_natural | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g)
(CategoryTheory.Limits.biprod.braiding Y W).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.braiding X Z).hom
(CategoryTheory.Limits.biprod.map g f) |
Module.End.rTensorAlgHom._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (M : Type u_3) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) |
Std.Tactic.BVDecide.BVPred.ExprPair._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred.ExprPair |
_private.Mathlib.Algebra.BigOperators.Field.0.Finset.dens_biUnion_le._simp_1_1 | Mathlib.Algebra.BigOperators.Field | ∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),
∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a |
SimpleGraph.Subgraph.neighborSet_subset_verts | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (G' : G.Subgraph) (v : V), G'.neighborSet v ⊆ G'.verts |
LieSubalgebra.coe_bracket_of_module | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{M : Type w} [inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] (x : ↥L') (m : M), ⁅x, m⁆ = ⁅↑x, m⁆ |
Lean.Meta.Grind.instHashableCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → UInt64 |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Cauchy.map_of_le._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : α → β} {m' : β → γ},
Filter.map (m' ∘ m) f = Filter.map m' (Filter.map m f) |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isEagerCasesCandidate.match_1 | Lean.Meta.Tactic.Grind.Intro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.le_degree._simp_1_2 | Mathlib.Data.Finsupp.Weight | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True |
ENNReal.div_le_iff_le_mul | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ 0 → (a / b ≤ c ↔ a ≤ c * b) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.