name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Submodule._aux_Mathlib_Analysis_InnerProductSpace_Orthogonal___unexpand_Submodule_IsOrtho_1 | Mathlib.Analysis.InnerProductSpace.Orthogonal | Lean.PrettyPrinter.Unexpander |
_private.Lean.Replay.0.Lean.Environment.Replay.checkPostponedConstructors._sparseCasesOn_1 | Lean.Replay | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t |
Lean.Meta.Sym.State.inferType._default | Lean.Meta.Sym.SymM | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Expr |
Matroid.cRk_closure_congr | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {X Y : Set α} [M.InvariantCardinalRank], M.closure X = M.closure Y → M.cRk X = M.cRk Y |
Nat.dfold_add._auto_5 | Init.Data.Nat.Fold | Lean.Syntax |
Lean.Json.json_ | Lean.Data.Json.Elab | Lean.ParserDescr |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.State.mk.injEq | Lean.Compiler.LCNF.ExplicitRC | ∀ (liveVars liveVars_1 : Lean.Compiler.LCNF.LiveVars✝),
({ liveVars := liveVars } = { liveVars := liveVars_1 }) = (liveVars = liveVars_1) |
Fintype.toOrderBot._proof_1 | Mathlib.Data.Fintype.Order | ∀ (α : Type u_1) [inst : Fintype α] (a : α), ∃ x, x ∈ Finset.univ |
mem_const_vsub_affineSegment | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P),
p -ᵥ z ∈ affineSegment R (p -ᵥ x) (p -ᵥ y) ↔ z ∈ affineSegment R x y |
IO.CancelToken.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.CancelToken} → t = t' → IO.CancelToken.noConfusionType P t t' |
TopologicalSpace.OpenNhdsOf.instDistribLattice._proof_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {x_1 y : TopologicalSpace.OpenNhdsOf x},
x_1.toOpens ≤ y.toOpens ↔ x_1.toOpens ≤ y.toOpens |
QuadraticMap.linMulLin.congr_simp | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] [inst_4 : Module R A] [inst_5 : SMulCommClass R A A]
[inst_6 : IsScalarTower R A A] (f f_1 : M →ₗ[R] A),
f = f_1 → ∀ (g g_1 : M →ₗ[R] A), g = g_1 → QuadraticMap.linMulLin f g = QuadraticMap.linMulLin f_1 g_1 |
_private.Std.Data.DTreeMap.Internal.Zipper.0.Std.DTreeMap.Internal.Impl.pruneLE.eq_1 | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (lowerBound : α),
Std.DTreeMap.Internal.Impl.pruneLE✝ Std.DTreeMap.Internal.Impl.leaf lowerBound = Std.DTreeMap.Internal.Impl.leaf |
Std.DTreeMap.Const.contains_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{f : Option β → Option β},
(Std.DTreeMap.Const.alter t k f).contains k' =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).isSome else t.contains k' |
SetRel.IsCover.anti | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {U : SetRel X X} {s t N : Set X}, s ⊆ t → U.IsCover t N → U.IsCover s N |
_private.Mathlib.RingTheory.Etale.Field.0.Algebra.FormallyEtale.of_isSeparable._simp_1_1 | Mathlib.RingTheory.Etale.Field | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) |
Filter.Eventually.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∀ᶠ (x : α) in f, q x |
PiTensorProduct.definition._proof_2._@.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.2741663271._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (G : Type (max u_3 u_1 u_2)) (x : SeminormedAddCommGroup G)
(x_1 : NormedSpace 𝕜 G), ContinuousConstSMul 𝕜 G |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_6 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u_2} [inst : Norm α] [inst_1 : Mul α] [NormMulClass α] (a b : α), ‖a‖ * ‖b‖ = ‖a * b‖ |
real_inner_div_norm_mul_norm_eq_neg_one_iff | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] (x y : F),
inner ℝ x y / (‖x‖ * ‖y‖) = -1 ↔ x ≠ 0 ∧ ∃ r < 0, y = r • x |
PFunctor.M.dest_mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} (x : ↑F F.M), (PFunctor.M.mk x).dest = x |
Lean.SubExpr.Pos.pushNthBindingDomain | Lean.SubExpr | ℕ → Lean.SubExpr.Pos → Lean.SubExpr.Pos |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.getFalseProof? | Lean.Meta.Tactic.Grind.Split | Lean.MVarId → Lean.MetaM (Option Lean.Expr) |
Std.ExtTreeMap.maxKey_eq_iff_mem_and_forall | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {he : t ≠ ∅} {km : α}, t.maxKey he = km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp k km).isLE = true |
AlgebraNorm.algebraNormClass | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_1} [inst : SeminormedCommRing R] {S : Type u_2} [inst_1 : Ring S] [inst_2 : Algebra R S],
AlgebraNormClass (AlgebraNorm R S) R S |
Lean.Compiler.LCNF.ToMonoM.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ToMono | ∀ (typeParams : Lean.FVarIdHashSet), sizeOf { typeParams := typeParams } = 1 + sizeOf typeParams |
LieAlgebra.hasTrivialRadical_iff | Mathlib.Algebra.Lie.Semisimple.Defs | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieAlgebra.HasTrivialRadical R L ↔ LieAlgebra.radical R L = ⊥ |
IsSelfAdjoint.cfc_arg | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u : A), IsSelfAdjoint (cfc (Complex.ofReal ∘ Complex.arg) u) |
Fin.tail_vecCons | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {n : ℕ} (x : α) (t : Fin n → α), Fin.tail (Matrix.vecCons x t) = t |
WittVector.IsocrystalHom.mk.inj | Mathlib.RingTheory.WittVector.Isocrystal | ∀ {p : ℕ} {inst : Fact (Nat.Prime p)} {k : Type u_1} {inst_1 : CommRing k} {inst_2 : CharP k p}
{inst_3 : PerfectRing k p} {V : Type u_2} {inst_4 : AddCommGroup V} {inst_5 : WittVector.Isocrystal p k V}
{V₂ : Type u_3} {inst_6 : AddCommGroup V₂} {inst_7 : WittVector.Isocrystal p k V₂}
{toLinearMap : V →ₗ[FractionRing (WittVector p k)] V₂}
{frob_equivariant :
∀ (x : V),
(WittVector.Isocrystal.frobenius p k) (toLinearMap x) = toLinearMap ((WittVector.Isocrystal.frobenius p k) x)}
{toLinearMap_1 : V →ₗ[FractionRing (WittVector p k)] V₂}
{frob_equivariant_1 :
∀ (x : V),
(WittVector.Isocrystal.frobenius p k) (toLinearMap_1 x) =
toLinearMap_1 ((WittVector.Isocrystal.frobenius p k) x)},
{ toLinearMap := toLinearMap, frob_equivariant := frob_equivariant } =
{ toLinearMap := toLinearMap_1, frob_equivariant := frob_equivariant_1 } →
toLinearMap = toLinearMap_1 |
DirectLimit.instGroupWithZero._proof_16 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : (i : ι) → GroupWithZero (G i)] [∀ (i j : ι) (h : i ≤ j), MonoidWithZeroHomClass (T h) (G i) (G j)] (n : ℕ)
(x x_1 : ι) (x_2 : x ≤ x_1) (x_3 : G x), (f x x_1 x_2) (x_3 ^ Int.negSucc n) = (f x x_1 x_2) x_3 ^ Int.negSucc n |
Lean.Meta.LazyDiscrTree.MatchResult.push | Lean.Meta.LazyDiscrTree | {α : Type} → Lean.Meta.LazyDiscrTree.MatchResult α → ℕ → Array α → Lean.Meta.LazyDiscrTree.MatchResult α |
Std.DHashMap.Internal.Raw₀.getKey_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : (a : α) → β a → Bool} {k : α} (h : (↑m).WF)
{h' : (Std.DHashMap.Internal.Raw₀.filter f m).contains k = true},
(Std.DHashMap.Internal.Raw₀.filter f m).getKey k h' = m.getKey k ⋯ |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.rintroContinue.loop._unsafe_rec | Lean.Elab.Tactic.RCases | {α : Type} →
Lean.Syntax →
Lean.TSyntaxArray `rintroPat →
Option Lean.Term →
(Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α) →
ℕ → Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → α → Lean.Elab.TermElabM α |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.upShadow_compls._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {𝒜 : Finset (Finset α)} {t : Finset α},
(t ∈ 𝒜.upShadow) = ∃ s ∈ 𝒜, ∃ a ∉ s, insert a s = t |
CentroidHom.toEndRingHom_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ (α : Type u_5) [inst : NonUnitalNonAssocSemiring α] (f : CentroidHom α), (CentroidHom.toEndRingHom α) f = f.toEnd |
IntermediateField.eq_of_le_of_finrank_eq | Mathlib.FieldTheory.IntermediateField.Algebraic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F E : IntermediateField K L}
[FiniteDimensional K ↥E], F ≤ E → Module.finrank K ↥F = Module.finrank K ↥E → F = E |
Std.Internal.IO.Async.EAsync.ofTask | Std.Internal.Async.Basic | {ε α : Type} → Std.Internal.IO.Async.ETask ε α → Std.Internal.IO.Async.EAsync ε α |
HomotopicalAlgebra.instHasTwoOutOfThreePropertyFullSubcategoryWeakEquivalences | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{P : CategoryTheory.ObjectProperty C} [(HomotopicalAlgebra.weakEquivalences C).HasTwoOutOfThreeProperty],
(HomotopicalAlgebra.weakEquivalences P.FullSubcategory).HasTwoOutOfThreeProperty |
Lean.Grind.ISize.natCast | Init.GrindInstances.Ring.SInt | NatCast ISize |
CategoryTheory.SingleFunctors.shiftIso_zero_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] (F : CategoryTheory.SingleFunctors C D A) (a : A) (X : C),
(F.shiftIso 0 a a ⋯).hom.app X = (CategoryTheory.shiftFunctorZero D A).hom.app ((F.functor a).obj X) |
LieModule.maxTrivEquiv._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} {N : Type u_4} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[inst_10 : LieModule R L N] (e : M ≃ₗ⁅R,L⁆ N) (m : ↥(LieModule.maxTrivSubmodule R L M)),
(LieModule.maxTrivHom e.symm.toLieModuleHom) ((LieModule.maxTrivHom e.toLieModuleHom) m) = m |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_eq_getKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
_private.Lean.Compiler.IR.Checker.0.Lean.IR.Checker.checkExpr.match_4 | Lean.Compiler.IR.Checker | (motive : Lean.IR.Expr → Sort u_1) →
(e : Lean.IR.Expr) →
((f : Lean.IR.FunId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.pap f ys)) →
((x : Lean.IR.VarId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.ap x ys)) →
((f : Lean.IR.FunId) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.fap f ys)) →
((c : Lean.IR.CtorInfo) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.ctor c ys)) →
((n : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.reset n x)) →
((x : Lean.IR.VarId) →
(i : Lean.IR.CtorInfo) →
(updtHeader : Bool) → (ys : Array Lean.IR.Arg) → motive (Lean.IR.Expr.reuse x i updtHeader ys)) →
((xty : Lean.IR.IRType) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.box xty x)) →
((x : Lean.IR.VarId) → motive (Lean.IR.Expr.unbox x)) →
((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.proj i x)) →
((i : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.uproj i x)) →
((n offset : ℕ) → (x : Lean.IR.VarId) → motive (Lean.IR.Expr.sproj n offset x)) →
((x : Lean.IR.VarId) → motive (Lean.IR.Expr.isShared x)) →
((v : String) → motive (Lean.IR.Expr.lit (Lean.IR.LitVal.str v))) →
((v : Lean.IR.LitVal) → motive (Lean.IR.Expr.lit v)) → motive e |
Set.vsub_iUnion | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {β : Type u_3} {ι : Sort u_5} [inst : VSub α β] (s : Set β) (t : ι → Set β),
s -ᵥ ⋃ i, t i = ⋃ i, s -ᵥ t i |
WithTop.forall_ne_top | Mathlib.Order.WithBot | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), x ≠ ⊤ → p x) ↔ ∀ (x : α), p ↑x |
CategoryTheory.Limits.coneOfConeCurry_pt | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
(G : CategoryTheory.Functor (J × K) C) {D : CategoryTheory.Limits.DiagramOfCones (CategoryTheory.Functor.curry.obj G)}
(Q : (j : J) → CategoryTheory.Limits.IsLimit (D.obj j)) (c : CategoryTheory.Limits.Cone G),
(CategoryTheory.Limits.coneOfConeCurry G Q c).pt = c.pt |
ExistsContDiffBumpBase.y_eq_one_of_mem_closedBall | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] {D : ℝ} {x : E},
0 < D → x ∈ Metric.closedBall 0 (1 - D) → ExistsContDiffBumpBase.y D x = 1 |
ModuleCat.ExtendRestrictScalarsAdj.Counit.map._proof_3 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_3} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {Y : ModuleCat S} (s : S)
(r : R) (y : ↑Y), s • r • y = f r • s • y |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_exists_annihilator._simp_1_2 | Mathlib.RingTheory.Support | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T |
FermatLastTheoremForThreeGen.Solution'.noConfusionType | Mathlib.NumberTheory.FLT.Three | Sort u →
{K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} →
FermatLastTheoremForThreeGen.Solution' hζ →
{K' : Type u_1} →
[inst' : Field K'] →
{ζ' : K'} → {hζ' : IsPrimitiveRoot ζ' 3} → FermatLastTheoremForThreeGen.Solution' hζ' → Sort u |
Left.self_le_neg | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftMono α] {a : α}, a ≤ 0 → a ≤ -a |
_private.Init.Data.Array.Find.0.Array.getElem_zero_flatten.proof._simp_1_2 | Init.Data.Array.Find | ∀ {l : List ℕ}, (0 < l.sum) = ∃ x ∈ l, 0 < x |
meromorphicAt_of_meromorphicOrderAt_ne_zero | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {x : 𝕜}, meromorphicOrderAt f x ≠ 0 → MeromorphicAt f x |
TopologicalSpace.Compacts.mem_singleton | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x y : α), x ∈ {y} ↔ x = y |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_B._simp_1_2 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {X : Type u} {α : Type u_1} [inst : TopologicalSpace X] {s : Set α} {f : α → Set X},
(∀ i ∈ s, IsOpen (f i)) → IsOpen (⋃ i ∈ s, f i) = True |
Nat.le_of_ble_eq_true | Init.Prelude | ∀ {n m : ℕ}, n.ble m = true → n ≤ m |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}) (motive : { x // x ∈ Set.Iio o } → Sort u_2) (x : Ordinal.{u_1}) (property : x ∈ Set.Iio o)
(h_1 : (x : Ordinal.{u_1}) → (property : x ∈ Set.Iio o) → motive ⟨x, property⟩),
(match ⟨x, property⟩ with
| ⟨x, property⟩ => h_1 x property) =
h_1 x property |
CategoryTheory.WithTerminal.equivComma_functor_map_left_app | 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]
{X Y : CategoryTheory.Functor (CategoryTheory.WithTerminal C) D} (η : X ⟶ Y) (X_1 : C),
(CategoryTheory.WithTerminal.equivComma.functor.map η).left.app X_1 = η.app (CategoryTheory.WithTerminal.incl.obj X_1) |
SimpleGraph.EdgeLabeling.compRight_get | Mathlib.Combinatorics.SimpleGraph.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {K' : Type u_4} {C : G.EdgeLabeling K} (f : K → K') (x y : V)
(h : G.Adj x y), (C.compRight f).get x y h = f (C.get x y h) |
BoolRing.instCategory._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y : BoolRing} (f : X.Hom Y), { hom' := { hom' := RingHom.id ↑Y }.hom'.comp f.hom' } = f |
CochainComplex.singleFunctors.eq_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C],
CochainComplex.singleFunctors C =
{ functor := fun n => HomologicalComplex.single C (ComplexShape.up ℤ) n,
shiftIso := fun n a a' ha' =>
CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => CategoryTheory.eqToIso ⋯) ⋯) ⋯,
shiftIso_zero := ⋯, shiftIso_add := ⋯ } |
TopologicalSpace.Clopens.exists_finset_eq_sup_prod | Mathlib.Topology.ClopenBox | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y]
[CompactSpace X] (W : TopologicalSpace.Clopens (X × Y)), ∃ I, W = I.sup fun i => i.1 ×ˢ i.2 |
Subalgebra.mulMap_comm | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
(A B : Subalgebra R S), B.mulMap A = (A.mulMap B).comp ↑(Algebra.TensorProduct.comm R ↥B ↥A) |
instSliceableByteArrayNatByteSlice_3 | Std.Data.ByteSlice | Std.Roc.Sliceable ByteArray ℕ ByteSlice |
SSet.stdSimplex.faceRepresentableBy._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory}
(f : j ⟶ SimplexCategory.mk m),
∀
x ∈
Finset.image
⇑(SimplexCategory.Hom.toOrderHom
(SSet.stdSimplex.objEquiv
(SSet.stdSimplex.objMk
((OrderHom.Subtype.val fun x => x ∈ S).comp
(e.toOrderEmbedding.toOrderHom.comp (SimplexCategory.Hom.toOrderHom f))))))
⊤,
x ∈ S |
Std.DHashMap.Raw.get?_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → (m₁ ∩ m₂).get? k = m₁.get? k |
IsAddLeftRegular.all | Mathlib.Algebra.Group.Defs | ∀ {R : Type u_2} [inst : Add R] [IsLeftCancelAdd R] (g : R), IsAddLeftRegular g |
stdSimplex.instUniqueElemForall._proof_1 | Mathlib.Analysis.Convex.StdSimplex | ∀ {S : Type u_1} [inst : Semiring S] [inst_1 : PartialOrder S] {X : Type u_2} [IsOrderedRing S] (x : X), 0 ≤ 1 x |
WeierstrassCurve.Jacobian.Equation.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) (P : Fin 3 → R),
W'.Equation P = ((MvPolynomial.eval P) W'.polynomial = 0) |
Int.fdiv_eq_ediv_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b : ℤ}, 0 ≤ b → a.fdiv b = a / b |
AddMonoidAlgebra.semiring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid M] (x : AddMonoidAlgebra R M),
npowRecAuto 0 x = 1 |
Lean.findField? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.Name |
Std.DTreeMap.Internal.Impl.size_balanceR | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β} (hlb : l.Balanced)
(hrb : r.Balanced) (hlr : Std.DTreeMap.Internal.Impl.BalanceLPrecond r.size l.size),
(Std.DTreeMap.Internal.Impl.balanceR k v l r hlb hrb hlr).size = l.size + 1 + r.size |
AList.toFinmap_entries | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (s : AList β), s.toFinmap.entries = ↑s.entries |
SpectralMap.coe_id | Mathlib.Topology.Spectral.Hom | ∀ (α : Type u_2) [inst : TopologicalSpace α], ⇑(SpectralMap.id α) = id |
Matrix.toEuclideanLin_apply_piLp_toLp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_3} [inst : RCLike 𝕜] {m : Type u_7} {n : Type u_8} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix m n 𝕜) (v : n → 𝕜), (Matrix.toEuclideanLin M) (WithLp.toLp 2 v) = WithLp.toLp 2 (M.mulVec v) |
DifferentiableOn.isConservativeOn | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : ℂ → E} {U : Set ℂ},
DifferentiableOn ℂ f U → Complex.IsConservativeOn f U |
_private.Mathlib.Analysis.Asymptotics.TVS.0.Asymptotics.isLittleOTVS_iff_isLittleO._simp_1_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖ |
Nat.add_sub_add_right | Init.Data.Nat.Basic | ∀ (n k m : ℕ), n + k - (m + k) = n - m |
_private.Lean.Compiler.LCNF.Probing.0.Lean.Compiler.LCNF.Probe.getLetValues.match_1 | Lean.Compiler.LCNF.Probing | (pu : Lean.Compiler.LCNF.Purity) →
(motive : Unit × Array (Lean.Compiler.LCNF.LetValue pu) → Sort u_1) →
(__discr : Unit × Array (Lean.Compiler.LCNF.LetValue pu)) →
((fst : Unit) → (res : Array (Lean.Compiler.LCNF.LetValue pu)) → motive (fst, res)) → motive __discr |
Std.Iterators.Types.DropWhile.dropping | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} → Std.Iterators.Types.DropWhile α m β P → Bool |
EuclideanSpace.inner_single_right | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] (i : ι) (a : 𝕜)
(v : EuclideanSpace 𝕜 ι), inner 𝕜 v (EuclideanSpace.single i a) = a * (starRingEnd ((fun x => 𝕜) i)) (v.ofLp i) |
_private.Mathlib.Data.ENNReal.Inv.0.ENNReal.exists_mem_Ico_zpow._simp_1_1 | Mathlib.Data.ENNReal.Inv | ∀ {r : NNReal}, (↑r = 0) = (r = 0) |
Aesop.RuleStats.mk._flat_ctor | Aesop.Stats.Basic | Aesop.DisplayRuleName → Aesop.Nanos → Bool → Aesop.RuleStats |
Aesop.GoalData.ctorIdx | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → ℕ |
_private.Mathlib.Algebra.Order.Ring.Int.0.Nat.exists_add_mul_eq_of_gcd_dvd_of_mul_pred_le.match_1_1 | Mathlib.Algebra.Order.Ring.Int | ∀ (q n : ℕ) (motive : q ∣ n → Prop) (x : q ∣ n), (∀ (b : ℕ) (eq : n = q * b), motive ⋯) → motive x |
_private.Init.Internal.Order.Lemmas.0.Array.mapM.map.eq_def | Init.Internal.Order.Lemmas | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ) (bs : Array β),
Array.mapM.map✝ f as i bs =
if hlt : i < as.size then do
let __do_lift ← f as[i]
Array.mapM.map✝¹ f as (i + 1) (bs.push __do_lift)
else pure bs |
CategoryTheory.Presieve.HasPairwisePullbacks.casesOn | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{R : CategoryTheory.Presieve X} →
{motive : R.HasPairwisePullbacks → Sort u} →
(t : R.HasPairwisePullbacks) →
((has_pullbacks :
∀ {Y Z : C} {f : Y ⟶ X}, R f → ∀ {g : Z ⟶ X}, R g → CategoryTheory.Limits.HasPullback f g) →
motive ⋯) →
motive t |
CategoryTheory.Comma.equivProd_functor_obj | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (a : CategoryTheory.Comma L R),
(CategoryTheory.Comma.equivProd L R).functor.obj a = (a.left, a.right) |
Array.scanrM.loop._unary | Batteries.Data.Array.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} →
[Monad m] →
(α → β → m β) → (as : Array α) → ℕ → (_ : β) ×' (start : ℕ) ×' (_ : start ≤ as.size) ×' Array β → m (Array β) |
Subsemigroup.coe_comap | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (S : Subsemigroup N) (f : M →ₙ* N),
↑(Subsemigroup.comap f S) = ⇑f ⁻¹' ↑S |
MvPolynomial.coeffs_C | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : DecidableEq R] (r : R),
(MvPolynomial.C r).coeffs = if r = 0 then ∅ else {r} |
Nat.sqrt.lt_iter_succ_sq | Mathlib.Data.Nat.Sqrt | ∀ (n guess : ℕ), n < (guess + 1) * (guess + 1) → n < (Nat.sqrt.iter n guess + 1) * (Nat.sqrt.iter n guess + 1) |
_private.Init.Data.Range.Polymorphic.Int.0.Std.PRange.instLawfulUpwardEnumerableInt._proof_3 | Init.Data.Range.Polymorphic.Int | ∀ (n : ℕ) (a : ℤ), ¬a + ↑(n + 1) = a + ↑n + 1 → False |
ExteriorAlgebra.map._proof_1 | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N) (x : M), 0 (f.toFun x) = 0 (f.toFun x) |
WithOne.coe_inv._simp_2 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} [inst : Inv α] (a : α), (↑a)⁻¹ = ↑a⁻¹ |
hasSum_of_isLUB_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {ι : Type u_1} {α : Type u_3} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α]
[inst_3 : TopologicalSpace α] [OrderTopology α] {f : ι → α} (i : α),
(∀ (i : ι), 0 ≤ f i) → IsLUB (Set.range fun s => ∑ i ∈ s, f i) i → HasSum f i |
IsLocalization.bot_lt_comap_prime | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[IsLocalization M S] [IsDomain R],
M ≤ nonZeroDivisors R → ∀ (p : Ideal S) [hpp : p.IsPrime], p ≠ ⊥ → ⊥ < Ideal.comap (algebraMap R S) p |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence.0.EisensteinSeries.eisensteinSeries_tendstoLocallyUniformly._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {p : Filter ι} [LocallyCompactSpace α],
TendstoLocallyUniformly F f p = ∀ (K : Set α), IsCompact K → TendstoUniformlyOn F f p K |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.