name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LieAlgebra.Orthogonal.typeBEquivSo'._proof_2 | Mathlib.Algebra.Lie.Classical | ∀ (l : Type u_1) (R : Type u_2) [inst : DecidableEq l] [inst_1 : CommRing R] [inst_2 : Fintype l] [Invertible 2],
↑(skewAdjointMatricesLieSubalgebra
((Matrix.reindexAlgEquiv R R (Equiv.sumAssoc PUnit.{1} l l))
(LieAlgebra.Orthogonal.indefiniteDiagonal (Unit ⊕ l) l R))) =
↑(skewAdjointMatricesLie... | null | false |
TopCat.LocalPredicate.ctorIdx | Mathlib.Topology.Sheaves.LocalPredicate | {X : TopCat} → {T : ↑X → Type u_1} → TopCat.LocalPredicate T → ℕ | null | false |
Real.decidableLT | Mathlib.Basic.Real.Basic | (a b : ℝ) → Decidable (a < b) | null | true |
CategoryTheory.MonoOver.topLEPullbackSelf._proof_2 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : C} (f : A ⟶ B) [inst_1 : CategoryTheory.Mono f],
CategoryTheory.CategoryStruct.comp ⊤.arrow
((CategoryTheory.MonoOver.forget B).obj (CategoryTheory.MonoOver.mk f)).hom =
CategoryTheory.CategoryStruct.comp ⊤.arrow
((CategoryTheory.Mo... | null | false |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.ctorIdx | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | Lean.Meta.Grind.Arith.CommRing.RingM.Context → ℕ | null | false |
_private.Mathlib.Tactic.Translate.Expr.0.Mathlib.Tactic.Translate.applyReplacementFun.visitApp.match_15 | Mathlib.Tactic.Translate.Expr | (motive : Option Mathlib.Tactic.Translate.TranslationInfo → Sort u_1) →
(__x : Option Mathlib.Tactic.Translate.TranslationInfo) →
((n₁ : Lean.Name) →
(reorder : Mathlib.Tactic.Translate.Reorder) →
(relevantArg : Mathlib.Tactic.Translate.RelevantArg) →
(unfold : Bool) →
... | null | false |
div_le_comm₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {G₀ : Type u_3} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a b c : G₀},
0 < b → 0 < c → (a / b ≤ c ↔ a / c ≤ b) | null | true |
Lean.Meta.Sym.CongrInfo.congrTheorem.injEq | Lean.Meta.Sym.SymM | ∀ (thm thm_1 : Lean.Meta.CongrTheorem),
(Lean.Meta.Sym.CongrInfo.congrTheorem thm = Lean.Meta.Sym.CongrInfo.congrTheorem thm_1) = (thm = thm_1) | null | true |
WeierstrassCurve.Projective.equation_some | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (a b : R),
W'.Equation ![a, b, 1] ↔ W'.toAffine.Equation a b | null | true |
IsDenseInducing.toIsInducing | Mathlib.Topology.DenseEmbedding | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {i : α → β},
IsDenseInducing i → Topology.IsInducing i | null | true |
WithBot.WithTop.completeLinearOrder._proof_5 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] (a : WithBot (WithTop α)), a ⇨ ⊥ = aᶜ | null | false |
MeasureTheory.Measure.IsComplete.casesOn | Mathlib.MeasureTheory.Measure.NullMeasurable | {α : Type u_2} →
{x : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} →
{motive : μ.IsComplete → Sort u} →
(t : μ.IsComplete) → ((out' : ∀ (s : Set α), μ s = 0 → MeasurableSet s) → motive ⋯) → motive t | null | false |
CochainComplex.HomComplex.Cochain.rightUnshift_rightShift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain K L n) (a n' : ℤ) (hn' : n' + a = n),
(γ.rightShift a n' hn').rightUnshift n hn' = γ | null | true |
_private.Init.Data.Array.Basic.0.Array.takeWhile.go._unary.eq_def | Init.Data.Array.Basic | ∀ {α : Type u} (p : α → Bool) (as : Array α) (_x : (_ : ℕ) ×' Array α),
Array.takeWhile.go._unary✝ p as _x =
PSigma.casesOn _x fun i acc =>
if h : i < as.size then
have a := as[i];
if p a = true then Array.takeWhile.go._unary✝ p as ⟨i + 1, acc.push a⟩ else acc
else acc | null | false |
_private.Mathlib.RingTheory.Regular.ProjectiveDimension.0.ModuleCat.projectiveDimension_quotient_eq_add_length_of_isWeaklyRegular._simp_1_3 | Mathlib.RingTheory.Regular.ProjectiveDimension | ∀ {α : Type u_1} {b : α} {l : List α} {a : α}, (a ∈ b :: l) = (a = b ∨ a ∈ l) | null | false |
MeasureTheory.VectorMeasure.IntegrableOn.empty._simp_1 | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.VectorMeasure X F} {f : X → E},
MeasureTheory.Integrable f (μ.restrict ∅).variation = True | null | false |
Matrix.instModuleForall | Mathlib.LinearAlgebra.Matrix.Action | {n : Type u_1} →
{R : Type u_2} → [inst : Fintype n] → [inst_1 : DecidableEq n] → [inst_2 : Semiring R] → Module (Matrix n n R) (n → R) | null | true |
Circle.instDistribMulAction | Mathlib.Analysis.Complex.Circle | {M : Type u_3} → [inst : AddMonoid M] → [DistribMulAction ℂ M] → DistribMulAction Circle M | null | true |
Polynomial.Chebyshev.T_ne_zero | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R] (n : ℤ) [IsDomain R] [NeZero 2], Polynomial.Chebyshev.T R n ≠ 0 | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.contains_iff_exists_mem_beq._simp_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {xs : Array α} {a : α}, (xs.contains a = true) = ∃ a' ∈ xs, (a == a') = true | null | false |
Lean.Lsp.instToJsonPlainGoal | Lean.Data.Lsp.Extra | Lean.ToJson Lean.Lsp.PlainGoal | null | true |
CategoryTheory.Monad.monadicOfHasPreservesGSplitCoequalizersOfReflectsIsomorphisms._proof_2 | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {G : CategoryTheory.Functor D C} [G.ReflectsIsomorphisms]
[CategoryTheory.Monad.HasCoequalizerOfIsSplitPair G] [CategoryTheory.Monad.PreservesColimitOfIsSplitPair G],
CategoryTheory.Monad.... | null | false |
RBTree.RBNode.Stream.toList.eq_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (t : RBTree.RBNode.Stream α), t.toList = RBTree.RBNode.Stream.foldr (fun x1 x2 => x1 :: x2) t [] | null | true |
Lean.PrettyPrinter.Delaborator.delabLazyBinop | Lean.PrettyPrinter.Delaborator.Builtins | ℕ →
(Lean.Term → Lean.Term → Lean.PrettyPrinter.Delaborator.DelabM Lean.Term) →
Lean.PrettyPrinter.Delaborator.DelabM Lean.Term | Delaborates a function application of the form `f ... x (fun _ : Unit => y)`. | true |
CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim._proof_4 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_5} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_6, u_5} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [CategoryTheory.Limits.HasLimitsOfShape J C]
[inst_4 : CategoryTh... | null | false |
AlgHom.liftOfSurjective._proof_3 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], RingHomClass (A →ₐ[R] B) A B | null | false |
SimpleGraph.Walk.bypass._unsafe_rec | Mathlib.Combinatorics.SimpleGraph.Paths | {V : Type u} → {G : SimpleGraph V} → [DecidableEq V] → {u v : V} → G.Walk u v → G.Walk u v | null | false |
BoxIntegral.Box.coe_mk' | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (l u : ι → ℝ), ↑(BoxIntegral.Box.mk' l u) = Set.univ.pi fun i => Set.Ioc (l i) (u i) | null | true |
_private.Mathlib.Algebra.Order.Ring.Unbundled.Rat.0.Rat.num_nonpos._simp_1_1 | Mathlib.Algebra.Order.Ring.Unbundled.Rat | ∀ {a b : ℤ}, (a ≤ b) = (a < b ∨ a = b) | null | false |
CategoryTheory.Comma._sizeOf_inst | Mathlib.CategoryTheory.Comma.Basic | {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) →
... | null | false |
UniformConvergenceCLM.nhds_zero_eq_of_basis | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | null | true |
Aesop.CasesTarget'._sizeOf_1 | Aesop.RuleTac.Cases | Aesop.CasesTarget' → ℕ | null | false |
MeasureTheory.AEStronglyMeasurable.integral_condExpKernel | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {F : Type u_2} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] [inst_2 : NormedAddCommGroup F] {f : Ω → F}
[inst_3 : NormedSpace ℝ F],
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory... | null | true |
Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData.rec | Lean.Elab.Tactic.Omega.Core | {motive : Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData → Sort u} →
((var : ℕ) →
(irrelevant : List Lean.Elab.Tactic.Omega.Fact) →
(lowerBounds upperBounds : List (Lean.Elab.Tactic.Omega.Fact × ℤ)) →
(lowerExact upperExact : Bool) →
motive
{ var := var, irrelevant... | null | false |
AddCon.comap | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} →
{N : Type u_2} →
[inst : Add M] → [inst_1 : Add N] → (f : M → N) → (∀ (x y : M), f (x + y) = f x + f y) → AddCon N → AddCon M | Given types with additions `M, N` and an additive congruence relation `c` on `N`,
an addition-preserving map `f : M → N` induces an additive congruence relation on `f`'s domain
defined by '`x ≈ y` iff `f(x)` is related to `f(y)` by `c`.' | true |
Eq.congr_simp | Init.Data.Nat.Fold | ∀ {α : Sort u_1} (a a_1 : α), a = a_1 → ∀ (a_2 a_3 : α), a_2 = a_3 → (a = a_2) = (a_1 = a_3) | null | true |
CategoryTheory.Functor.sum_map_inl | Mathlib.CategoryTheory.Sums.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C D)
{a a' : ... | null | true |
MulEquiv.ofLeftInverse_apply | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N) {g : N → M}
(h : Function.LeftInverse g ⇑f) (a : M), (MulEquiv.ofLeftInverse f h) a = f.srangeRestrict a | null | true |
_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₃._sparseCasesOn_5 | Aesop.Util.EqualUpToIds | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) → (Nat.hasNotBit 1028 t.ctorIdx → motive t) → motive t | null | false |
UInt8.toUInt64_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), (a * b).toUInt64 = a.toUInt64 * b.toUInt64 % 256 | null | true |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.basis_ne_zero._simp_1_3 | Mathlib.LinearAlgebra.Lagrange | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∏ x ∈ s, f x ≠ 0) = ∀ a ∈ s, f a ≠ 0 | null | false |
Std.Rxc.IsAlwaysFinite.ofMap | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : LE α] [inst_3 : LE β] [Std.Rxc.IsAlwaysFinite β] (f : Std.PRange.UpwardEnumerable.Map α β) [f.PreservesLE],
Std.Rxc.IsAlwaysFinite α | null | true |
inf_sdiff_right | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a ⊓ a \ b = a \ b | null | true |
_private.Init.Data.Range.Polymorphic.BitVec.0.BitVec.instRxcLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.BitVec | ∀ {n : ℕ} {x y : BitVec n}, (x < y) = (x.toNat < y.toNat) | null | false |
ContinuousMap.instNormedRing._proof_16 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_2} [inst_2 : NormedRing R]
(a b : C(α, R)), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
CategoryTheory.MorphismProperty.Over.pullbackMapHomPullback._proof_9 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P Q : CategoryTheory.MorphismProperty T} {X Z : T}
[CategoryTheory.Limits.HasPullbacks T] (fg : X ⟶ Z) (A : P.Over Q Z), CategoryTheory.Limits.HasPullback A.hom fg | null | false |
Lean.IR.JoinPointId._sizeOf_inst | Lean.Compiler.IR.Basic | SizeOf Lean.IR.JoinPointId | null | false |
Rep.tateNorm_eq | Mathlib.RepresentationTheory.Homological.TateCohomology.Basic | ∀ {R G : Type u} [inst : CommRing R] [inst_1 : Group G] [inst_2 : Fintype G] (M : Rep.{u, u, u} R G),
M.tateNorm = ModuleCat.ofHom ((Finsupp.lsum R) fun x => LinearMap.pi fun x => M.ρ.norm) | null | true |
FormalMultilinearSeries.coeff._proof_1 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], ContinuousAdd 𝕜 | null | false |
Lean.Grind.CommRing.Poly.insert.go._sunfold | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | false |
RingInvo.mk.inj | Mathlib.RingTheory.RingInvo | ∀ {R : Type u_2} {inst : Semiring R} {toRingEquiv : R ≃+* Rᵐᵒᵖ}
{involution' : ∀ (x : R), MulOpposite.unop (toRingEquiv.toFun (MulOpposite.unop (toRingEquiv.toFun x))) = x}
{toRingEquiv_1 : R ≃+* Rᵐᵒᵖ}
{involution'_1 : ∀ (x : R), MulOpposite.unop (toRingEquiv_1.toFun (MulOpposite.unop (toRingEquiv_1.toFun x))) = ... | null | true |
Std.IterM.Step.toPure_yield | Init.Data.Iterators.Basic | ∀ {α β : Type w} [inst : Std.Iterator α Id β] {it it' : Std.IterM Id β} {out : β}
{h : it.IsPlausibleStep (Std.IterStep.yield it' out)},
Std.IterM.Step.toPure ⟨Std.IterStep.yield it' out, h⟩ = Std.PlausibleIterStep.yield it'.toIter out h | null | true |
PartOrdEmb.coconeOfPredicateSet._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {α : PartOrdEmb} (P : Set ↑α → Prop) ⦃X Y : Subtype P⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((PartOrdEmb.functorOfPredicateSet P).map f)
(PartOrdEmb.ofHom (OrderEmbedding.subtype fun x => x ∈ ↑Y)) =
CategoryTheory.CategoryStruct.comp (PartOrdEmb.ofHom (OrderEmbedding.subtype fun x => x ∈ ↑X))
... | null | false |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (x : Lean.Grind.AC.Var) (c₁ : Lean.Meta.Grind.AC.EqCnstr),
sizeOf (Lean.Meta.Grind.AC.EqCnstrProof.superpose_head_idempotent x c₁) = 1 + sizeOf x + sizeOf c₁ | null | true |
String.lt_trans | Init.Data.String.Lemmas.StringOrder | ∀ {a b c : String}, a < b → b < c → a < c | null | true |
CategoryTheory.Localization.homEquiv_trans | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C : Type u_1} {D₁ : Type u_5} {D₂ : Type u_6} {D₃ : Type u_7} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_5, u_5} D₁] [inst_2 : CategoryTheory.Category.{v_6, u_6} D₂]
[inst_3 : CategoryTheory.Category.{v_7, u_7} D₃] (W : CategoryTheory.MorphismProperty C)
(L₁ : CategoryTh... | null | true |
CategoryTheory.SpectralSequence.Hom.hom | Mathlib.Algebra.Homology.SpectralSequence.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
E.Hom E' →
(r : ℤ) →
(... | the morphism of homological complexes between the `r`th pages | true |
Lean.Parser.mkParserOfConstant | Lean.Parser.Extension | Lean.Parser.ParserCategories → Lean.Name → Lean.ImportM (Bool × Lean.Parser.Parser) | null | true |
MeasureTheory.condExp_congr_ae_trim | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → E}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] (hm : m ≤ m₀),
f =ᵐ[μ] g → μ[f | m] =ᵐ[μ.trim hm] μ[g | m] | null | true |
CategoryTheory.MorphismProperty.LeftFraction.mk | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} → {X Y Y' : C} → (X ⟶ Y') → (s : Y ⟶ Y') → W s → W.LeftFraction X Y | null | true |
_private.Mathlib.Data.Fintype.Card.0.Fintype.card_fin_lt_of_le.match_1_3 | Mathlib.Data.Fintype.Card | {m : ℕ} → (motive : Fin m → Sort u_1) → (x : Fin m) → ((i : ℕ) → (hi : i < m) → motive ⟨i, hi⟩) → motive x | null | false |
TensorProduct.mapL_comp_commIsometry | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {H : Type u_5} [inst : RCLike 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
[inst_4 : InnerProductSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G]
[inst_7 : NormedAdd... | null | true |
Int.Internal.Linear.Poly.norm._unsafe_rec | Init.Data.Int.Linear | Int.Internal.Linear.Poly → Int.Internal.Linear.Poly | null | false |
instProperSMul | Mathlib.Topology.Algebra.ProperAction.Torsor | ∀ {V : Type u_1} {P : Type u_2} [inst : Group V] [inst_1 : Torsor V P] [inst_2 : TopologicalSpace V]
[inst_3 : TopologicalSpace P] [IsTopologicalTorsor P], ProperSMul V P | If `P` is a topological torsor over `V`, the action of `V` on `P` is proper. | true |
_private.Mathlib.CategoryTheory.FiberedCategory.Fibered.0.CategoryTheory.Functor.IsFibered.isStronglyCartesian_of_exists_isCartesian.match_1_2 | Mathlib.CategoryTheory.FiberedCategory.Fibered | ∀ {𝒮 : Type u_1} {𝒳 : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_3} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {a b : 𝒳} (φ : a ⟶ b) {c : 𝒳}
(φ' : c ⟶ b) (g : p.obj c ⟶ p.obj a) (π : c ⟶ a)
(motive : p.IsHomLift g π ∧ CategoryTheory.CategoryStruct.comp π φ =... | null | false |
CategoryTheory.uliftTrivial | Mathlib.CategoryTheory.Types.Basic | (V : Type u) → ULift.{u, u} V ≅ V | The isomorphism between a `Type` which has been `ULift`ed to the same universe,
and the original type.
| true |
ContextFreeRule.reverse_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {N : Type u_2} (r : ContextFreeRule T N), r.reverse.reverse = r | null | true |
_private.Init.Data.List.MinMaxIdx.0.List.exists_getElem_eq_of_drop_eq_cons._proof_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {xs : List α} {k : ℕ}, ¬k < xs.length → ¬xs.length ≤ k → False | null | false |
AntitoneOn.quasiconvexOn | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : PartialOrder β] [inst_6 : Module 𝕜 E] [PosSMulMono 𝕜 E]
{s : Set E} {f : E → β}, AntitoneOn f s → Convex 𝕜 s → QuasiconvexOn 𝕜 s f | null | true |
Set.mem_sdiff._simp_1 | Mathlib.Data.Set.Operations | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
_private.Mathlib.FieldTheory.ChevalleyWarning.0.char_dvd_card_solutions_of_add_lt._simp_1_1 | Mathlib.FieldTheory.ChevalleyWarning | ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) = (p false ∧ p true) | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Break.runK.match_1.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | null | true |
Matrix.submatrix | Mathlib.LinearAlgebra.Matrix.Defs | {l : Type u_1} →
{m : Type u_2} → {n : Type u_3} → {o : Type u_4} → {α : Type v} → Matrix m n α → (l → m) → (o → n) → Matrix l o α | Given maps `(r : l → m)` and `(c : o → n)` reindexing the rows and columns of
a matrix `M : Matrix m n α`, the matrix `M.submatrix r c : Matrix l o α` is defined
by `(M.submatrix r c) i j = M (r i) (c j)` for `(i,j) : l × o`.
Note that the total number of row and columns does not have to be preserved. | true |
_private.Mathlib.Algebra.MvPolynomial.Coeff.0.MvPolynomial.coeff_linearCombination_X_pow_of_eq | Mathlib.Algebra.MvPolynomial.Coeff | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R] {s : σ →₀ ℕ} (a : σ →₀ R) {n : ℕ},
(s.sum fun x m => m) = n →
((Finsupp.linearCombination R MvPolynomial.X) a ^ n).coeff s = ↑s.multinomial * s.prod fun r m => a r ^ m | null | true |
Monovary.div_left₀ | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Semifield α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : LinearOrder β] {f₁ f₂ : ι → α} {g : ι → β},
0 ≤ f₁ → StrongLT 0 f₂ → Monovary f₁ g → Antivary f₂ g → Monovary (f₁ / f₂) g | null | true |
CategoryTheory.Localization.SmallShiftedHom.mk₀.congr_simp | 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] (m₀ : M) (hm₀ : m₀ = 0) (f f_1 : X ⟶ Y),
f = f_1 →
... | null | true |
Std.TreeSet.Raw.min!_le_min!_erase | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → ∀ {k : α}, (t.erase k).isEmpty = false → (cmp t.min! (t.erase k).min!).isLE = true | null | true |
zpowGroupHom_apply | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (n : ℤ) (x : α), (zpowGroupHom n) x = x ^ n | null | true |
SimpleGraph.IsContained.girth_le | Mathlib.Combinatorics.SimpleGraph.Girth | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {G' : SimpleGraph β},
G.IsContained G' → ¬G.IsAcyclic → G'.girth ≤ G.girth | null | true |
cfc | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | {R : Type u_3} →
{A : Type u_4} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : MetricSpace R] →
[inst_3 : IsTopologicalSemiring R] →
[inst_4 : ContinuousStar R] →
[inst_5 : TopologicalSpace A] →
[in... | This is the *continuous functional calculus* of an element `a : A` applied to bare functions.
When either `a` does not satisfy the predicate `p` (i.e., `a` is not `IsStarNormal`,
`IsSelfAdjoint`, or `0 ≤ a` when `R` is `ℂ`, `ℝ`, or `ℝ≥0`, respectively), or when `f : R → R` is
not continuous on the spectrum of `a`, then... | true |
Polynomial.Bivariate.swap_C | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (f : Polynomial R),
Polynomial.Bivariate.swap (Polynomial.C f) = Polynomial.map Polynomial.C f | null | true |
CochainComplex.shiftEval._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (n i i' : ℤ), n + i = i' → i + { as := n }.as = i' | null | false |
MonoidHomClass.isometry_iff_norm | Mathlib.Analysis.Normed.Group.Uniform | ∀ {𝓕 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F]
[inst_2 : FunLike 𝓕 E F] [MonoidHomClass 𝓕 E F] (f : 𝓕), Isometry ⇑f ↔ ∀ (x : E), ‖f x‖ = ‖x‖ | null | true |
Bool.fintype._proof_1 | Mathlib.Data.Fintype.Defs | {true, false}.Nodup | null | false |
Std.DTreeMap.Internal.Impl.getKeyLT_eq_getEntryLT | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] {t : Std.DTreeMap.Internal.Impl α β} {k : α}
{hto : t.Ordered} {he : ∃ a ∈ t, compare a k = Ordering.lt},
Std.DTreeMap.Internal.Impl.getKeyLT k t hto he = (Std.DTreeMap.Internal.Impl.getEntryLT k t hto he).fst | null | true |
CategoryTheory.TransfiniteCompositionOfShape.mk.injEq | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{X Y : C} {f : X ⟶ Y} [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J] (F : CategoryTheory.Functor J C)
(isoBot : F.obj ⊥ ≅ X)
(isWellOrderContinuous :
autoParam F.IsWellOrderContinuous Catego... | null | true |
Aesop.Percent.toFloat | Aesop.Percent | Aesop.Percent → Float | null | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mapDomain_comapDomain_nat_add_one._simp_1_3 | Mathlib.Data.Finsupp.Basic | ∀ {n : ℕ}, (0 < n) = (n ≠ 0) | null | false |
AddMonoidAlgebra.coeff_mapDomainRingEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} {N : Type u_7} [inst : Semiring R] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N) (x : AddMonoidAlgebra R M),
((AddMonoidAlgebra.mapDomainRingEquiv R e) x).coeff = Finsupp.equivMapDomain (↑e) x.coeff | null | true |
Set.zero_nonempty | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α], Set.Nonempty 0 | null | true |
ProbabilityTheory.cdf_gammaMeasure_eq_lintegral | Mathlib.Probability.Distributions.Gamma | ∀ {a r : ℝ},
0 < a →
0 < r →
∀ (x : ℝ),
↑(ProbabilityTheory.cdf (ProbabilityTheory.gammaMeasure a r)) x =
(∫⁻ (x : ℝ) in Set.Iic x, ProbabilityTheory.gammaPDF a r x).toReal | null | true |
Lean.Meta.Sym.Pattern._sizeOf_inst | Lean.Meta.Sym.Pattern | SizeOf Lean.Meta.Sym.Pattern | null | false |
Array.firstM | Init.Data.Array.Basic | {β : Type v} → {α : Type u} → {m : Type v → Type w} → [Alternative m] → (α → m β) → Array α → m β | Maps `f` over the array and collects the results with `<|>`. The result for the end of the array is
`failure`.
Examples:
* `#[[], [1, 2], [], [2]].firstM List.head? = some 1`
* `#[[], [], []].firstM List.head? = none`
* `#[].firstM List.head? = none`
| true |
Std.Rco.HasRcoIntersection.noConfusion | Init.Data.Range.Polymorphic.PRange | {P : Sort u} →
{α : Type w} →
{t : Std.Rco.HasRcoIntersection α} →
{α' : Type w} →
{t' : Std.Rco.HasRcoIntersection α'} → α = α' → t ≍ t' → Std.Rco.HasRcoIntersection.noConfusionType P t t' | null | false |
LatticeHom.id_apply | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} [inst : Lattice α] (a : α), (LatticeHom.id α) a = a | null | true |
Lean.instInhabitedLBool.default | Lean.Data.LBool | Lean.LBool | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic.0.Real.sin_pi_div_two._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ {R : Type u} [inst : NonAssocRing R] [NoZeroDivisors R] {a : R}, (a * a = 1) = (a = 1 ∨ a = -1) | null | false |
CategoryTheory.Limits.WalkingMultispan.functorExt._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMultispan J) C}
(left :
(i : J.L) →
F.obj (CategoryTheory.Limits.WalkingMultispan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.le... | null | false |
coheightZeroSetOrderIsoIrreducibleComponents._proof_4 | Mathlib.Topology.KrullDimension | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T0Space X],
{x | Order.coheight x = 0} = {x | Maximal ⊤ x} →
(↑{x | Order.coheight x = 0} ≃o ↑{s | Maximal (fun x => IsClosed x ∧ IsIrreducible x) s}) =
(↑{x | Maximal ⊤ x} ≃o ↑{s | Maximal (fun x => IsClosed x ∧ IsIrreducible x) s}) | null | false |
TensorProduct.equivFinsuppOfBasisLeft_apply_tmul | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : DecidableEq ι]
(ℬ : Module.Basis ι R M) (m : M) (n : N),
(TensorProduct.equivFinsuppOfBasisLeft ℬ) (m ⊗ₜ[R] n) = Finsupp... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.