name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
exteriorPower.linearMap_ext_iff | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {n : ℕ} {M : Type u_1} {N : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {f g : ↥(⋀[R]^n M) →ₗ[R] N},
f = g ↔ f.compAlternatingMap (exteriorPower.ιMulti R n) = g.compAlternatingMap (exteriorPower.ιMulti R n) | null | true |
CliffordAlgebra.EquivEven.e0_mul_e0 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), CliffordAlgebra.EquivEven.e0 Q * CliffordAlgebra.EquivEven.e0 Q = -1 | null | true |
MeasureTheory.predictablePart | Mathlib.Probability.Martingale.Centering | {Ω : Type u_1} →
{E : Type u_2} →
[inst : NormedAddCommGroup E] →
[NormedSpace ℝ E] →
{m0 : MeasurableSpace Ω} → (ℕ → Ω → E) → MeasureTheory.Filtration ℕ m0 → MeasureTheory.Measure Ω → ℕ → Ω → E | Any `ℕ`-indexed stochastic process can be written as the sum of a martingale and a predictable
process. This is the predictable process. See `martingalePart` for the martingale. | true |
CategoryTheory.yonedaCommGrpGrpObj._proof_6 | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (G : CategoryTheory.CommGrp C) {X Y Z : (CategoryTheory.Grp C)ᵒᵖ}
(f : X ⟶ Y) (g : Y ⟶ Z),
CommGrpCat.ofHom
{ toFun := fun x => CategoryTheory.Cate... | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.add_eq_three_iff._proof_1_1 | Init.Data.Nat.Lemmas | ∀ {m n : ℕ}, ¬(m + n = 3 ↔ m = 0 ∧ n = 3 ∨ m = 1 ∧ n = 2 ∨ m = 2 ∧ n = 1 ∨ m = 3 ∧ n = 0) → False | null | false |
NonUnitalSubring.neg_mem | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] (s : NonUnitalSubring R) {x : R}, x ∈ s → -x ∈ s | A non-unital subring is closed under negation. | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
Lean.Grind.AC.SubsetResult.rec | Lean.Meta.Tactic.Grind.AC.Seq | {motive : Lean.Grind.AC.SubsetResult → Sort u} →
motive Lean.Grind.AC.SubsetResult.false →
motive Lean.Grind.AC.SubsetResult.exact →
((s : Lean.Grind.AC.Seq) → motive (Lean.Grind.AC.SubsetResult.strict s)) →
(t : Lean.Grind.AC.SubsetResult) → motive t | null | false |
_private.Batteries.Data.Array.Basic.0.Array.scanlMFast._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (stop : ℕ), (USize.ofNat (min stop as.size)).toNat ≤ as.size | null | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo.mk.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | ∀ {eToInt α he eToInt_1 α_1 he_1 : Lean.Expr},
{ eToInt := eToInt, α := α, he := he } = { eToInt := eToInt_1, α := α_1, he := he_1 } →
eToInt = eToInt_1 ∧ α = α_1 ∧ he = he_1 | null | true |
ContinuousMultilinearMap.instCompleteSpace | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | null | true |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux._proof_1_3 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (q : Ideal S) [inst_4 : q.IsPrime] [inst_5 : q.LiesOver p] (R' : Type u_1) (w : CommRing R')
(w_1 : Algebra R R') (P : Ideal R') (w_2 : P.IsPrime) (w_3 : P.LiesOver p)
(hP : Function... | null | false |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.UnusedVariables.visitAssignments.visitExpr | Lean.Linter.UnusedVariables | IO.Ref (Std.HashSet USize) → IO.Ref (Std.HashSet Lean.FVarId) → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit IO Unit | Visit an `Expr`, collecting all fvars in it into `fvarUses` | true |
Lean.Elab.Term.withSynthesize | Lean.Elab.SyntheticMVars | {m : Type → Type u_1} →
{α : Type} →
[MonadFunctorT Lean.Elab.TermElabM m] →
m α → optParam Lean.Elab.Term.PostponeBehavior Lean.Elab.Term.PostponeBehavior.no → m α | Execute `k`, and synthesize pending synthetic metavariables created while executing `k` are solved.
If `mayPostpone == false`, then all of them must be synthesized.
Remark: even if `mayPostpone == true`, the method still uses `synthesizeUsingDefault` | true |
Lean.PersistentArrayNode.node.elim | Lean.Data.PersistentArray | {α : Type u} →
{motive_1 : Lean.PersistentArrayNode α → Sort u_1} →
(t : Lean.PersistentArrayNode α) →
t.ctorIdx = 0 →
((cs : Array (Lean.PersistentArrayNode α)) → motive_1 (Lean.PersistentArrayNode.node cs)) → motive_1 t | null | false |
TopCat.Presheaf.SheafConditionPairwiseIntersections.coneEquivInverse_map_hom | Mathlib.Topology.Sheaves.SheafCondition.EqualizerProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasProducts C] {X : TopCat}
(F : TopCat.Presheaf C X) {ι : Type v'} (U : ι → TopologicalSpace.Opens ↑X)
{c c' : CategoryTheory.Limits.Cone (TopCat.Presheaf.SheafConditionEqualizerProducts.diagram F U)} (f : c ⟶ c'),
((TopCat.... | null | true |
ContinuousWithinAt.eval_const | Mathlib.Topology.Hom.ContinuousEvalConst | ∀ {F : Type u_1} {α : Type u_2} {X : Type u_3} {Z : Type u_4} [inst : FunLike F α X] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [ContinuousEvalConst F α X] [inst_4 : TopologicalSpace Z] {f : Z → F} {s : Set Z}
{z : Z}, ContinuousWithinAt f s z → ∀ (x : α), ContinuousWithinAt (fun x_1 => (f x_1) x) ... | null | true |
ConcaveOn.right_le_of_le_left' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConcaveOn 𝕜 s f... | null | true |
CategoryTheory.PreZeroHypercover.inv_hom_h₀_assoc | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀) {Z : C} (h : F.X (e.hom.s₀ (e.inv.s₀ i)) ⟶ Z),
CategoryTheory.CategoryStruct.comp (e.inv.h₀ i) (CategoryTheory.CategoryStruct.comp (e.hom.h₀ (e.inv.s₀ i)) h) =
CategoryTheory.Catego... | null | true |
Setoid.eq_iff_rel_eq | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {r₁ r₂ : Setoid α}, r₁ = r₂ ↔ ⇑r₁ = ⇑r₂ | Two equivalence relations are equal iff their underlying binary operations are equal. | true |
RootPairing.pairingIn_eq_add_of_root_eq_add | Mathlib.LinearAlgebra.RootSystem.IsValuedIn | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {S : Type u_6}
[inst_5 : CommRing S] [inst_6 : Algebra S R] [FaithfulSMul S R] [inst_8 : P.IsValuedIn S] {i j k ... | null | true |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit._sunfold | Lean.Meta.ExprTraverse | {M : Type → Type u_1} →
[Monad M] →
[MonadLiftT Lean.MetaM M] →
[MonadControlT Lean.MetaM M] →
(Lean.SubExpr.Pos → Lean.Expr → M Lean.Expr) → Array Lean.Expr → Lean.SubExpr.Pos → Lean.Expr → M Lean.Expr | null | false |
FreeGroup.Red.Step.lift | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)} {β : Type v} [inst : Group β] {f : α → β},
FreeGroup.Red.Step L₁ L₂ → FreeGroup.Lift.aux f L₁ = FreeGroup.Lift.aux f L₂ | null | true |
Function.Injective.mem_range_iff_existsUnique | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ {b : β}, b ∈ Set.range f ↔ ∃! a, f a = b | null | true |
ContinuousLinearMapWOT.seminormFamily | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | {𝕜₁ : 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 : TopologicalSpace E] →
[inst_4 : Module 𝕜₁ E... | The family of seminorms that induce the weak operator topology, namely `‖y (A x)‖` for
all `x` and `y`. | true |
SubarrayIterator.step.eq_1 | Init.Data.Slice.Array.Iterator | ∀ {α : Type u} {m : Type u → Type u_1} (xs : Subarray α),
SubarrayIterator.step { internalState := { xs := xs } } =
if h : xs.start < xs.stop then
have this := ⋯;
have this := ⋯;
Std.IterStep.yield
{
internalState :=
{
xs :=
{
... | null | true |
pow_le_pow | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] [MulRightMono M] {a b : M},
a ≤ b → 1 ≤ b → ∀ {m n : ℕ}, m ≤ n → a ^ m ≤ b ^ n | null | true |
Std.TreeSet.isSome_max?_eq_not_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isSome = !t.isEmpty | null | true |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces.consumeSpaces._mutual._proof_2 | Init.Data.String.Extra | ∀ {s : String} (n : ℕ) (it : s.Pos) (r : String),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun n it => PSigma.casesOn it fun it r => (it, 1)) fun _x =>
PSigma.casesOn _x fun it r => (it, 0))
Prod.instWellFoundedRelation).1
(PSum.inr ⟨it, r⟩) (PSum.inl ⟨... | null | false |
CategoryTheory.LocalizerMorphism.LeftResolution.comp_f_assoc | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{L L' L'' : Φ.LeftResolution X₂} (φ : L ⟶ L')... | null | true |
Fin.orderIsoPair.match_1 | Mathlib.Order.Fin.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : α) (motive : ↥{a, b} → Prop) (x : ↥{a, b}),
(∀ (x : α) (hx : x ∈ {a, b}), motive ⟨x, hx⟩) → motive x | null | false |
Function.locallyFinsuppWithin.restrictMonoidHom._proof_2 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(h : V ⊆ U), Function.locallyFinsuppWithin.restrict 0 h = 0 | null | false |
CategoryTheory.Limits.equalizerPullbackMapIso_hom_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasEqualizers C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X Y S T : C} {f g : X ⟶ Y} {s : X ⟶ S} {t : Y ⟶ S}
(hf : CategoryTheory.CategoryStruct.comp f t = s) (hg : CategoryTheory.CategoryStruct.comp g t = s) (v : T ⟶ S... | null | true |
Matrix.conjTranspose_fromRows_eq_fromCols_conjTranspose | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} [inst : Star R] (A₁ : Matrix m₁ n R)
(A₂ : Matrix m₂ n R), (A₁.fromRows A₂).conjTranspose = A₁.conjTranspose.fromCols A₂.conjTranspose | A row partitioned matrix in a Star ring when conjugate transposed gives a column partitioned
matrix with the rows of the initial matrix conjugate transposed to become columns. | true |
mdifferentiableAt_prod_module_iff | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F₁ : Type u_17} [inst_6 : NormedAddCom... | null | true |
LinearEquiv.algEquivOfRing._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (e : R ≃ₗ[R] A)
(x : R), e.symm (e 1 * (algebraMap R A) x) = e.symm (x • e 1) | null | false |
MeasureTheory.Measure.count.instSigmaFinite | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [Countable α],
MeasureTheory.SigmaFinite MeasureTheory.Measure.count | null | true |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.Functor.rightUnitor._proof_5 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (x : C),
(CategoryTheory.CategoryStruct.comp { app := fun X => CategoryTheory.CategoryStruct.id (F.obj X), naturality := ⋯ }
{ app := fun X => Cate... | null | false |
CategoryTheory.MorphismProperty.HasQuotient.mk | Mathlib.CategoryTheory.MorphismProperty.Quotient | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C}
{homRel : HomRel C} [inst_1 : CategoryTheory.HomRel.IsStableUnderPrecomp homRel]
[inst_2 : CategoryTheory.HomRel.IsStableUnderPostcomp homRel],
(∀ ⦃X Y : C⦄ ⦃f g : X ⟶ Y⦄, homRel f g → (W f ↔ W g)) → W.HasQuotie... | null | true |
Associates.mk_surjective | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], Function.Surjective Associates.mk | null | true |
List.sbtw_iff_triplewise_and_ne_pair | Mathlib.Analysis.Convex.BetweenList | ∀ {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] [IsOrderedRing R] {l : List P},
List.Sbtw R l ↔ List.Triplewise (Sbtw R) l ∧ ∀ (a : P), l ≠ [a, a] | null | true |
ProbabilityTheory.strong_law_Lp | Mathlib.Probability.StrongLaw | ∀ {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [inst_3 : MeasurableSpace E] [BorelSpace E] {p : ENNReal},
1 ≤ p →
p ≠ ⊤ →
∀ (X : ℕ → Ω → E),
MeasureTheory.MemLp (X 0) p μ →
... | **Strong law of large numbers**, Lᵖ version: if `X n` is a sequence of independent
identically distributed random variables in Lᵖ, then `n⁻¹ • ∑ i ∈ range n, X i`
converges in `Lᵖ` to `𝔼[X 0]`. | true |
Std.TreeSet.min!_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.min! ∈ t | null | true |
MulDissociated.subset | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : CommGroup α] {s t : Set α}, s ⊆ t → MulDissociated t → MulDissociated s | null | true |
CategoryTheory.Limits.PullbackCone.combineIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Pullbacks | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] {F G H : CategoryTheory.Functor D C} (f : F ⟶ H) (g : G ⟶ H)
(c : (X : D) → CategoryTheory.Limits.PullbackCone (f.app X) (g.app X))
(hc : (X : D) → CategoryTheory.Limits.IsLimit (c X)) (k ... | null | false |
MeasureTheory.JordanDecomposition.exists_compl_positive_negative | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (j : MeasureTheory.JordanDecomposition α),
∃ S,
MeasurableSet S ∧
MeasureTheory.VectorMeasure.restrict j.toSignedMeasure S ≤ MeasureTheory.VectorMeasure.restrict 0 S ∧
MeasureTheory.VectorMeasure.restrict 0 Sᶜ ≤ MeasureTheory.VectorMeasure.restrict j.toSig... | A Jordan decomposition provides a Hahn decomposition. | true |
Lean.mkListNode | Lean.Syntax | Array Lean.Syntax → Lean.Syntax | null | true |
alexDiscEquivPreord_inverse_map | Mathlib.Topology.Order.Category.AlexDisc | ∀ {X Y : Preord} (f : X ⟶ Y),
alexDiscEquivPreord.inverse.map f =
CategoryTheory.ConcreteCategory.ofHom (Topology.WithUpperSet.map (Preord.Hom.hom f)) | null | true |
TopologicalSpace.isSeparable_iUnion._simp_1 | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {ι : Sort u_2} [Countable ι] {s : ι → Set α},
TopologicalSpace.IsSeparable (⋃ i, s i) = ∀ (i : ι), TopologicalSpace.IsSeparable (s i) | null | false |
CategoryTheory.Arrow.AugmentedCechNerve.extraDegeneracy._proof_3 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(S : CategoryTheory.SplitEpi f.hom),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp S.secti... | null | false |
SubgroupClass.coe_zpow._simp_2 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G] (x : ↥H)
(n : ℤ), ↑x ^ n = ↑(x ^ n) | null | false |
CategoryTheory.Over.postAdjunctionLeft_counit_app_left | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] {X : C} {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D C} (a : F ⊣ G)
(X_1 : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj (... | null | true |
List.Pairwise.destutter_eq_dedup | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} [inst : DecidableEq α] {r : α → α → Prop} [Std.Antisymm r] {l : List α},
List.Pairwise r l → List.destutter (fun x1 x2 => x1 ≠ x2) l = l.dedup | If the elements of a list `l` are related pairwise by an antisymmetric relation `r`, then
destuttering `l` by disequality produces the same result as deduplicating `l`.
This is most useful when `r` is a strict or weak ordering.
| true |
LinearIsometryEquiv.norm_iteratedFDeriv_comp_left | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (g : F ≃ₗᵢ[𝕜] G) (f : E → F) (x : E)... | Composition with a linear isometry equiv on the left preserves the norm of the iterated
derivative. | true |
Monotone.ae_hasDerivAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ} (hf : Monotone f),
∀ᵐ (x : ℝ), HasDerivAt f (hf.stieltjesFunction.measure.rnDeriv MeasureTheory.volume x).toReal x | A monotone function is almost everywhere differentiable, with derivative equal to the
Radon-Nikodym derivative of the associated Stieltjes measure with respect to Lebesgue. | true |
CategoryTheory.Limits.coneUnopOfCoconeEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ}
{X Y : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X) (j : J),
CategoryTheory.CategoryStruct.comp f.unop.hom.unop
((CategoryTheory.Limits.coneUn... | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree.0.groupCohomology.mem_cocycles₁_iff._simp_1_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Std.TreeMap.instSliceableRcoSlice._auto_1 | Std.Data.TreeMap.Slice | Lean.Syntax | null | false |
CategoryTheory.Abelian.Ext.comp_zero | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) (Z : C) (m p : ℕ)
(h : n + m = p), α.comp 0 h = 0 | null | true |
CommRingCat.Colimits.Relation.below.mul | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop} (j : J)
(x y : ↑(F.obj j)), CommRingCat.Colimits.Relation.below ⋯ | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.State.found | Lean.Util.ParamMinimizer | Lean.Util.ParamMinimizer.State✝ → Bool | null | true |
nnnorm_pow_le_mul_norm | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] {a : E} {n : ℕ}, ‖a ^ n‖₊ ≤ ↑n * ‖a‖₊ | null | true |
Matrix.updateCol_self | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M : Matrix m n α} {i : m} {j : n} {c : m → α} [inst : DecidableEq n],
M.updateCol j c i j = c i | null | true |
Lean.Nat.mkInstPow | Lean.Expr | Lean.Expr | null | true |
WithCStarModule.instUniformSpace | Mathlib.Analysis.CStarAlgebra.Module.Synonym | {A : Type u_3} → {E : Type u_4} → [u : UniformSpace E] → UniformSpace (WithCStarModule A E) | null | true |
Fin.univ_succAbove._proof_1 | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ) (p : Fin (n + 1)), p ∉ Finset.map p.succAboveEmb Finset.univ | null | false |
RingTheory.Sequence.IsRegular.recIterModByRegularWithRing | Mathlib.RingTheory.Regular.RegularSequence | {motive :
(R : Type u) →
[inst : CommRing R] →
(M : Type v) →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (rs : List R) → RingTheory.Sequence.IsRegular M rs → Sort u_7} →
((R : Type u) →
[inst : CommRing R] →
(M : Type v) → [inst_1 : AddCommGroup M] → [ins... | An alternate induction principle from `IsRegular.recIterModByRegular` where
we mod out by successive elements in both the module and the base ring. This is
useful for propagating certain properties of the initial `M`, e.g. faithfulness
or freeness, throughout the induction. | true |
ProbabilityTheory.measurePreserving_restrict₂_multivariateGaussian | Mathlib.Probability.Distributions.Gaussian.Multivariate | ∀ {ι : Type u_2} [inst : DecidableEq ι] {I J : Finset ι} {μ : EuclideanSpace ℝ ↥I} {S : Matrix ↥I ↥I ℝ},
S.PosSemidef →
∀ (hJI : J ⊆ I),
MeasureTheory.MeasurePreserving (⇑(EuclideanSpace.restrict₂ hJI)) (ProbabilityTheory.multivariateGaussian μ S)
(ProbabilityTheory.multivariateGaussian ((EuclideanS... | If one restricts a multivariate Gaussian measure indexed by a finite set `I` to
coordinates indexed by `J ⊆ I`, one obtains the multivariate Gaussian measure whose
covariance matrix is given by the corresponding submatrix. | true |
Std.Internal.Do.WPMonad.ctorIdx | Std.Internal.Do.WP.Basic | {m : Type u → Type v} →
{Pred : outParam (Type w)} →
{EPred : outParam (Type w')} →
{inst : Monad m} →
{inst_1 : Std.Internal.Do.Assertion Pred} →
{inst_2 : Std.Internal.Do.Assertion EPred} → Std.Internal.Do.WPMonad m Pred EPred → ℕ | null | false |
CategoryTheory.ObjectProperty.monotone_retractClosure | Mathlib.CategoryTheory.ObjectProperty.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.retractClosure ≤ Q.retractClosure | null | true |
PseudoMetricSpace.toPseudoEMetricSpace | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u} → [PseudoMetricSpace α] → PseudoEMetricSpace α | A pseudometric space induces a pseudoemetric space | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_add._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {i_lt : i < w}, ¬w - 1 - i < w → False | null | false |
CategoryTheory.ObjectProperty.colimitsClosure.recOn | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.colimitsClosure J a → Prop} {a : C} (t : P.colimitsClosure J a),
(∀ (X : C) (hX : P X), motive X ⋯) →
... | null | false |
Int.Linear.Poly.divCoeffs.eq_2 | Init.Data.Int.Linear | ∀ (k k_1 : ℤ) (v : Int.Linear.Var) (p_1 : Int.Linear.Poly),
Int.Linear.Poly.divCoeffs k (Int.Linear.Poly.add k_1 v p_1) = (k_1 % k == 0 && Int.Linear.Poly.divCoeffs k p_1) | null | true |
_private.Mathlib.Algebra.Order.Star.Basic.0.StarOrderedRing.pos_iff._simp_1_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) | null | false |
CategoryTheory.Center.ofBraidedObj_fst | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C), (CategoryTheory.Center.ofBraidedObj X).fst = X | null | true |
Order.IsPredPrelimit.eq_1 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : LT α] (a : α), Order.IsPredPrelimit a = ∀ (b : α), ¬a ⋖ b | null | true |
Std.ExtDHashMap.getKey!_inter_of_mem_right | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {k : α}, k ∈ m₂ → (m₁ ∩ m₂).getKey! k = m₁.getKey! k | null | true |
CategoryTheory.PreZeroHypercover.pullback₁_X | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback f (E.f i)] (i : E.I₀),
(CategoryTheory.PreZeroHypercover.pullback₁ f E).X i = CategoryTheory.Limits.pullback f (E.f i) | null | true |
Aesop.LIFOQueue.rec | Aesop.Search.Queue | {motive : Aesop.LIFOQueue → Sort u} →
((goals : Array Aesop.GoalRef) → motive { goals := goals }) → (t : Aesop.LIFOQueue) → motive t | null | false |
NormedSpace.invertibleExpOfMemBall | Mathlib.Analysis.Normed.Algebra.Exponential | {𝕂 : Type u_1} →
{𝔸 : Type u_2} →
[inst : NontriviallyNormedField 𝕂] →
[inst_1 : NormedRing 𝔸] →
[inst_2 : NormedAlgebra 𝕂 𝔸] →
[CompleteSpace 𝔸] →
[CharZero 𝕂] →
{x : 𝔸} → x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius → Invertible (NormedSpace.... | `NormedSpace.exp x` has explicit two-sided inverse `NormedSpace.exp (-x)`. | true |
RKHS.kernel.congr_simp | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] (H : Type u_4) [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [inst_6 : CompleteSpace H] [inst_7 : CompleteSpace V] (a a_1 : X),
a = a_1 ... | null | true |
List.findIdx_eq_findIdx?.match_1 | Batteries.Data.List.Lemmas | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → ((i : ℕ) → motive (some i)) → (Unit → motive none) → motive x | null | false |
Stoch._proof_1 | Mathlib.Probability.Kernel.Category.Stoch | StochHom.IsMultiplicative | null | false |
HurwitzZeta.evenKernel._proof_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (x : ℝ),
Function.Periodic
(fun ξ => Real.exp (-Real.pi * ξ ^ 2 * x) * (jacobiTheta₂ (↑ξ * Complex.I * ↑x) (Complex.I * ↑x)).re) 1 | null | false |
Metric.sphere_union_ball | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, Metric.sphere x ε ∪ Metric.ball x ε = Metric.closedBall x ε | null | true |
Rat.exists_eq_mul_div_num_and_eq_mul_div_den | Mathlib.Data.Rat.Lemmas | ∀ (n : ℤ) {d : ℤ}, d ≠ 0 → ∃ c, n = c * (↑n / ↑d).num ∧ d = c * ↑(↑n / ↑d).den | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_roc_eq_if._proof_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, ¬m + 1 < n + 1 → ¬n < m + 1 → False | null | false |
CategoryTheory.MorphismProperty.RightFraction.ofHom_f | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C) {X Y : C}
(f : X ⟶ Y) [inst_1 : W.ContainsIdentities], (CategoryTheory.MorphismProperty.RightFraction.ofHom W f).f = f | null | true |
AlgebraicGeometry.ext_of_isDominant | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {W X Y : AlgebraicGeometry.Scheme} [AlgebraicGeometry.IsReduced X] {f g : X ⟶ Y} [Y.IsSeparated] (ι : W ⟶ X)
[AlgebraicGeometry.IsDominant ι],
CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g → f = g | Suppose `f g : X ⟶ Y` where `X` is a reduced scheme and `Y` is a separated scheme.
Then `f = g` if `ι ≫ f = ι ≫ g` for some dominant `ι`.
Also see `ext_of_isDominant_of_isSeparated` for the general version over arbitrary bases.
| true |
_private.Init.Data.String.Lemmas.Pattern.Find.Pred.0.String.Pos.find?_bool_eq_none_iff._simp_1_3 | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {s : String} {p q : s.Pos}, (p.toSlice ≤ q.toSlice) = (p ≤ q) | null | false |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.exists_iso_single._proof_1_4 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n i : ℤ), n < i → n < i | null | false |
Std.DHashMap.Internal.mkIdx._proof_2 | Std.Data.DHashMap.Internal.Index | ∀ (sz : ℕ),
0 < sz → ∀ (hash : UInt64), ((Std.DHashMap.Internal.scrambleHash hash).toUSize &&& USize.ofNat sz - 1).toNat < sz | null | false |
IsLocalization.Away.mvPolynomialQuotientEquiv.congr_simp | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u_2} [inst : CommRing R] (S : Type u_3) [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
IsLocalization.Away.mvPolynomialQuotientEquiv S r = IsLocalization.Away.mvPolynomialQuotientEquiv S r | null | true |
Hindman.FP.below.casesOn | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] {motive : (a : Stream' M) → (a_1 : M) → Hindman.FP a a_1 → Prop}
{motive_1 : {a : Stream' M} → {a_1 : M} → (t : Hindman.FP a a_1) → Hindman.FP.below t → Prop} {a : Stream' M}
{a_1 : M} {t : Hindman.FP a a_1} (t_1 : Hindman.FP.below t),
(∀ (a : Stream' M), motive_1 ⋯ ⋯) →
... | null | false |
Std.HashMap.Raw.size_filter_le_size | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → β → Bool}, m.WF → (Std.HashMap.Raw.filter f m).size ≤ m.size | null | true |
AdicCompletion.AdicCauchySequence.instSMul._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(r : R) (x : AdicCompletion.AdicCauchySequence I M) {m n : ℕ}, m ≤ n → r • ↑x m ≡ r • ↑x n [SMOD I ^ m • ⊤] | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_right_inj._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Lsp.CallHierarchyItem._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CallHierarchyItem | null | false |
Associates.normalize_out | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : IsCancelMulZero α] [inst_2 : NormalizationMonoid α]
(a : Associates α), normalize a.out = a.out | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.