name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.Kernel.eq_rnDeriv_measure | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η ξ : ProbabilityTheory.Kernel α γ}
{f : α → γ → ENNReal} [inst : ProbabilityTheory.IsFiniteKernel η],
κ = η.withDensity f + ξ →
Measurable (Function.uncurry f) → ∀ (a : α), (ξ a).MutuallySingular (η a) → f a =ᵐ[η a] (κ a).rnDe... | null | true |
PointedCone.isFaceOf_comap_iff | Mathlib.Geometry.Convex.Cone.Face.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {C F : PointedCone R M} [inst_5 : AddCommGroup N]
[inst_6 : Module R N] {f : N →ₗ[R] M},
Function.Surjective ⇑f → ((PointedCone.comap f F).IsFaceO... | The comap of a cone `F` under a surjective linear map is a face of the
comap of another cone `F` if and only if `F` is a face of `C`. | true |
Multiset.cons_lt_cons_iff._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s t : Multiset α} {a : α}, (a ::ₘ s < a ::ₘ t) = (s < t) | null | false |
SemilatInfCat.hasForgetToPartOrd._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y Z : SemilatInfCat} (f : X ⟶ Y) (g : Y ⟶ Z),
PartOrd.ofHom { toFun := ⇑(CategoryTheory.CategoryStruct.comp f g).toInfHom, monotone' := ⋯ } =
CategoryTheory.CategoryStruct.comp (PartOrd.ofHom { toFun := ⇑f.toInfHom, monotone' := ⋯ })
(PartOrd.ofHom { toFun := ⇑g.toInfHom, monotone' := ⋯ }) | null | false |
DirectLimit.instCommRingOfRingHomClass | Mathlib.Algebra.Colimit.DirectLimit | {ι : Type u_2} →
[inst : Preorder ι] →
{G : ι → Type u_3} →
{T : ⦃i j : ι⦄ → i ≤ j → Type u_6} →
{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 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] →
... | null | true |
CommMonCat.coyonedaType._proof_4 | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type u_1ᵒᵖ),
{
app := fun N =>
CommMonCat.ofHom
(MonoidHom.pi fun i =>
Pi.evalMonoidHom (fun a => ↑N)
((CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X).unop) i)),
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id
{ ob... | null | false |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._proof_1_4 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, ¬(a.toInt ≤ b.toInt ↔ a.toInt < b.toInt ∨ a.toInt = b.toInt) → False | null | false |
Subgroup._sizeOf_inst | Mathlib.Algebra.Group.Subgroup.Defs | (G : Type u_3) → {inst : Group G} → [SizeOf G] → SizeOf (Subgroup G) | null | false |
NormedGroup.toGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → [self : NormedGroup E] → Group E | null | true |
Derivation.compAEval_eq | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (a : A)
(d : Derivation R A M) (f : Polynomial R), (d.compAEval a) f = Polynomial.derivative f... | A form of the chain rule: if `f` is a polynomial over `R`
and `d : A → M` is an `R`-derivation then for all `a : A` we have
$$ d(f(a)) = f' (a) d a. $$
The equation is in the `R[X]`-module `Module.AEval R M a`.
For the same equation in `M`, see `Derivation.compAEval_eq`.
| true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_A_with_param._simp_1_3 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
IsPicardLindelof.mk | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E → E} {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E}
{a r L K : NNReal},
(∀ t ∈ Set.Icc tmin tmax, LipschitzOnWith K (f t) (Metric.closedBall x₀ ↑a)) →
(∀ x ∈ Metric.closedBall x₀ ↑a, ContinuousOn (fun x_1 => f x_1 x) (Set.Icc tmin tmax)) →
(∀... | null | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.succ_signVariations_le_X_sub_C_mul._proof_1_8 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] {η : R} {P : Polynomial R} (d : ℕ),
(∀ m < d + 1,
∀ {P : Polynomial R},
P ≠ 0 → P.natDegree = m → P.signVariations + 1 ≤ ((Polynomial.X - Polynomial.C η) * P).signVariations) →
P.eraseLead.natDegree < d + 1 →
¬P.eraseLead = 0 →
... | null | false |
_private.Mathlib.Tactic.Relation.Symm.0.Lean.Expr.relSidesIfSymm?.match_6 | Mathlib.Tactic.Relation.Symm | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 rhs : Lean.Expr) → motive (some (fst, lhs, fst_1, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | null | false |
Ordinal.cof_le_card | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ (o : Ordinal.{u_1}), o.cof ≤ o.card | null | true |
RingQuot.instMonoidWithZero._proof_7 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), 0 * a = 0 | null | false |
instIsMonHomOppositeCommAlgCatOpOfHomToAlgHom | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u} [inst : CommRing R] {A B : Type u} [inst_1 : CommRing A] [inst_2 : Bialgebra R A] [inst_3 : CommRing B]
[inst_4 : Bialgebra R B] (f : A →ₐc[R] B), CategoryTheory.IsMonHom (CommAlgCat.ofHom ↑f).op | null | true |
BitVec.clzAuxRec_eq_clzAuxRec_of_le | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} {x : BitVec w}, w - 1 ≤ n → x.clzAuxRec n = x.clzAuxRec (w - 1) | null | true |
_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_triple._simp_1_6 | Mathlib.Analysis.Convex.BetweenList | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit | null | true |
ModuleCat.rec | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] →
{motive : ModuleCat R → Sort u_1} →
((carrier : Type v) →
[isAddCommGroup : AddCommGroup carrier] →
[isModule : Module R carrier] →
motive { carrier := carrier, isAddCommGroup := isAddCommGroup, isModule := isModule }) →
(t : Modul... | null | false |
Filter.tendsto_atTop_pure | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : PartialOrder α] [inst_1 : OrderTop α] (f : α → β),
Filter.Tendsto f Filter.atTop (pure (f ⊤)) | null | true |
Ring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {R : Type u} → R → (R → R → R) → R → ℕ → R | null | false |
Lean.Meta.Match.Example.var | Lean.Meta.Match.Basic | Lean.FVarId → Lean.Meta.Match.Example | null | true |
GradedTensorProduct.lift._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} [inst : CommRing R] {C : Type u_2} [inst_1 : Ring C] [inst_2 : Algebra R C], SMulCommClass R C C | null | false |
Matrix.mulAction._proof_2 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} {α : Type u_3} [inst : Monoid R] [inst_1 : MulAction R α]
(b : Matrix m n α), 1 • b = b | null | false |
Hamming.instAddMonoid._proof_4 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddMonoid (β i)],
autoParam (∀ (x : Hamming β), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.mem_shadow_iterate_iff_exists_card._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} {s : Finset α} {n : ℕ} [inst : DecidableEq α],
(s.card = n + 1) = ∃ a t, a ∉ t ∧ insert a t = s ∧ t.card = n | null | false |
SeparationQuotient.instAddGroup._proof_5 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
(a : SeparationQuotient G), -a + a = 0 | null | false |
CategoryTheory.ComposableArrows.instIsIsoOfNatNatTwoδ₁Toδ₀ | Mathlib.CategoryTheory.ComposableArrows.Two | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i j k : C} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) [CategoryTheory.IsIso f],
CategoryTheory.IsIso (CategoryTheory.ComposableArrows.twoδ₁Toδ₀ f g fg h) | null | true |
Lean.Grind.CommRing.Poly.mulC_nc.go._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | null | false |
CategoryTheory.Limits.MulticospanIndex.sections.property | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J (Type u)}
(self : I.sections) (r : J.R),
(CategoryTheory.ConcreteCategory.hom (I.fst r)) (self.val (J.fst r)) =
(CategoryTheory.ConcreteCategory.hom (I.snd r)) (self.val (J.snd r)) | null | true |
PrimeMultiset.coe_coePNatMonoidHom | Mathlib.Data.PNat.Factors | ⇑PrimeMultiset.coePNatMonoidHom = PrimeMultiset.toPNatMultiset | null | true |
Lean.Meta.DSimp.Config.decide | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | When `true` (default: `false`), rewrites a proposition `p` to `True` or `False` by inferring
a `Decidable p` instance and reducing it.
| true |
hasProd_unique._simp_2 | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Unique β] (f : β → α)
(L : optParam (SummationFilter β) (SummationFilter.unconditional β)) [L.LeAtTop], HasProd f (f default) L = True | null | false |
Submodule.LinearDisjoint.rank_le_one_of_commute_of_flat_of_self | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {M : Submodule R S},
M.LinearDisjoint M → ∀ [Module.Flat R ↥M], (∀ (m n : ↥M), Commute ↑m ↑n) → Module.rank R ↥M ≤ 1 | If `M` and itself are linearly disjoint, if `M` is flat,
if any two elements of `M` are commutative, then the rank of `M` is at most one. | true |
Bundle.Trivialization.prod.eq_1 | Mathlib.Topology.VectorBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] {F₁ : Type u_2} [inst_1 : TopologicalSpace F₁] {E₁ : B → Type u_3}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_3 : TopologicalSpace F₂]
{E₂ : B → Type u_5} [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
(e₁ : Bundle.Trivialization... | null | true |
WithLp.fstₗ_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : WithLp p (α × β)),
(WithLp.fstₗ p 𝕜 α β) x = x.fst | null | true |
CategoryTheory.Comma.mapLeftComp_hom_app_right | 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] (R : CategoryTheory.Functor B T)
{L₁ L₂ L₃ : CategoryTheory.Functor A T} (l : L₁ ⟶ L₂) (l' : L₂ ⟶ L₃) (X : CategoryTheory.Comma L₃ R),
... | null | true |
HNNExtension.NormalWord.instMulAction | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} → {d : HNNExtension.NormalWord.TransversalPair G A B} → MulAction G (HNNExtension.NormalWord d) | null | true |
LindelofSpace | Mathlib.Topology.Compactness.Lindelof | (X : Type u_2) → [TopologicalSpace X] → Prop | X is a Lindelöf space iff every open cover has a countable subcover. | true |
CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
(x : CategoryTheory.Limits.WalkingReflexivePair),
(CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair F).hom.app x =
match x with
| CategoryTheory.Limits.WalkingRefle... | null | true |
chudnovskySum._proof_1 | Mathlib.Analysis.Real.Pi.Chudnovsky | (11 + 1).AtLeastTwo | null | false |
Topology.IsEmbedding.prodMap | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : X → Y} {g : Z → W},
Topology.IsEmbedding f → Topology.IsEmbedding g → Topology.IsEmbedding (Prod.map f g) | null | true |
Finset.prod_ite_index | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s t : Finset ι) (f : ι → M),
∏ x ∈ if p then s else t, f x = if p then ∏ x ∈ s, f x else ∏ x ∈ t, f x | null | true |
Nat.strongRec._unsafe_rec | Batteries.Data.Nat.Basic | {motive : ℕ → Sort u_1} → ((n : ℕ) → ((m : ℕ) → m < n → motive m) → motive n) → (t : ℕ) → motive t | null | false |
CategoryTheory.Cokleisli.Adjunction.adj._proof_6 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (U : CategoryTheory.Comonad C)
{X : CategoryTheory.Cokleisli U} {Y x : C} (f : (CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).obj X ⟶ Y)
(g : Y ⟶ x),
{ toFun := fun f => { of := f }, invFun := fun f => f.of, left_inv := ⋯, right_inv := ⋯ }
... | null | false |
BesselPotentialSpace.ext | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : CompleteSpace F] [inst_7 : NormedSpace ℂ F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)]
{f g ... | null | true |
Std.DTreeMap.Internal.Impl.maxEntry?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Intern... | null | false |
HasFDerivWithinAt.const_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}
{f' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → ∀ (c : F), HasFDerivWithinAt (... | null | true |
Std.DHashMap.Raw.Equiv.size_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.size = m₂.size | null | true |
CoxeterSystem.mk.noConfusion | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{M : CoxeterMatrix B} →
{W : Type u_2} →
{inst : Group W} →
{P : Sort u} →
{mulEquiv mulEquiv' : W ≃* M.Group} →
{ mulEquiv := mulEquiv } = { mulEquiv := mulEquiv' } → (mulEquiv ≍ mulEquiv' → P) → P | null | false |
WithBot.instMonoidWithZero.match_1 | Mathlib.Algebra.Order.Ring.WithTop | {α : Type u_1} →
(motive : WithBot α → ℕ → Sort u_2) →
(a : WithBot α) →
(n : ℕ) →
((a : α) → (n : ℕ) → motive (some a) n) → (Unit → motive none 0) → ((_n : ℕ) → motive none _n.succ) → motive a n | null | false |
OrderedFinpartition.partSize_pos | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (self : OrderedFinpartition n) (m : Fin self.length), 0 < self.partSize m | null | true |
Submonoid.isScalarTower | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MulOneClass M'] [inst_1 : SMul α β] [inst_2 : SMul M' α]
[inst_3 : SMul M' β] [IsScalarTower M' α β] (S : Submonoid M'), IsScalarTower (↥S) α β | Note that this provides `IsScalarTower S M' M'` which is needed by `SMulMulAssoc`. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ (a : ℕ) (a_1 : BitVec a) (b : ℕ) (b_1 : BitVec b),
¬a = b → { n := a, value := a_1 } = { n := b, value := b_1 } → False | null | false |
Lean.Lsp.DeleteFile.Options.ignoreIfNotExists | Lean.Data.Lsp.Basic | Lean.Lsp.DeleteFile.Options → Bool | null | true |
LieAlgebra.IsEngelian._proof_2 | Mathlib.Algebra.Lie.Engel | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | null | false |
univLE_iff_exists_embedding | Mathlib.SetTheory.Cardinal.UnivLE | UnivLE.{u, v} ↔ Nonempty (Ordinal.{u} ↪ Ordinal.{v}) | null | true |
Rat.mk'_pow._proof_2 | Mathlib.Data.Rat.Defs | ∀ (den : ℕ), den ≠ 0 → ∀ (n : ℕ), den ^ n ≠ 0 | null | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.LinearMap.linearIndependent_iff._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a ⊥ = True | null | false |
_private.Mathlib.Algebra.Lie.OfAssociative.0.termφ | Mathlib.Algebra.Lie.OfAssociative | Lean.ParserDescr | null | true |
Mathlib.Tactic.Conv.Path.rec | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
((arg : ℕ) →
(all : Bool) →
(next : Mathlib.Tactic.Conv.Path) → motive next → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((depth : ℕ) → motive (Mathlib.Tactic.Conv.Path.fun depth)) →
((next : Mathlib.Tactic.Conv.Path) → motive next → mo... | null | false |
_private.Mathlib.Analysis.Normed.Group.InfiniteSum.0.tsum_enorm_ne_top_iff_summable_norm._simp_1_2 | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] (a : E), ‖a‖ = ↑‖a‖₊ | null | false |
HomotopicalAlgebra.PrepathObject.map_P | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.PrepathObject X) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D), (P.map F).P = F.obj P.P | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition._simp_1_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ | null | false |
SSet.Truncated.Path₁.ext_iff | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet.Truncated 1} {n : ℕ} {x y : X.Path₁ n}, x = y ↔ x.vertex = y.vertex ∧ x.arrow = y.arrow | null | true |
List.pmap.eq_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (x_2 : ∀ a ∈ [], P a), List.pmap f [] x_2 = [] | null | true |
LinearMap.norm_map_iff_inner_map_map | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{E' : Type u_4} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] {F : Type u_5}
[inst_5 : FunLike F E E'] [LinearMapClass F 𝕜 E E'] (f : F),
(∀ (x : E), ‖f x‖ = ‖x‖) ↔ ... | A linear map is an isometry if and it preserves the inner product. | true |
Int64.instLawfulOrderOrd | Init.Data.Ord.SInt | Std.LawfulOrderOrd Int64 | null | true |
EuclideanGeometry.Sphere.orthRadius_eq_orthRadius_iff._simp_1 | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p q : P}, (s.orthRadius p = s.orthRadius q) = (p = q) | null | false |
Graph.Compatible.edgeSet_inf | Mathlib.Combinatorics.Graph.Lattice | ∀ {α : Type u_1} {β : Type u_2} {G H : Graph α β}, G.Compatible H → (G ⊓ H).edgeSet = G.edgeSet ∩ H.edgeSet | null | true |
Lean.Meta.SizeOfSpecNested.Context.recOn | Lean.Meta.SizeOf | {motive : Lean.Meta.SizeOfSpecNested.Context → Sort u} →
(t : Lean.Meta.SizeOfSpecNested.Context) →
((indInfo : Lean.InductiveVal) →
(sizeOfFns : Array Lean.Name) →
(ctorName : Lean.Name) →
(params localInsts : Array Lean.Expr) →
(recMap : Lean.NameMap Lean.Name) →
... | null | false |
_private.Init.Data.String.Lemmas.Basic.0.String.Slice.Pos.nextn.match_1.eq_1 | Init.Data.String.Lemmas.Basic | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
Pi.algebraMap._proof_2 | Mathlib.Algebra.Algebra.Pi | ∀ (ι : Type u_1) (R : Type u_3) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(t : R) (v : ι → R), ⇑(algebraMap R A) ∘ (t • v) = (RingHom.id R) t • ⇑(algebraMap R A) ∘ v | null | false |
Lean.Grind.CommRing.Poly.denote_insert | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (ctx : Lean.Grind.CommRing.Context α) (k : ℤ) (m : Lean.Grind.CommRing.Mon)
(p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.insert k m p) =
↑k * Lean.Grind.CommRing.Mon.denote ctx m + Lean.Grind.CommRing.Poly.denote ctx p | null | true |
CategoryTheory.Equivalence.sheafCongrPrecoherent_inverse_obj_obj_obj | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Precoherent C] (A : Type u_3)
[inst_3 : CategoryTheory.Category.{v_3, u_3} A] (e : C ≌ D)
(X : CategoryTheory.Sheaf (CategoryTheory.coherentTopology D) A) (X_1 : C... | null | true |
Finset.card_inter_smul | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
(A ∩ x • B).card = A.convolution B⁻¹ x | null | true |
Submodule.torsionBySet_isTorsionBySet | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R (↥(Submodule.torsionBySet R M s)) s | null | true |
CategoryTheory.AddMon.monMonoidal._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X₁ X₂ : CategoryTheory.AddMon C),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂)... | null | false |
DyckStep.D | Mathlib.Combinatorics.Enumerative.DyckWord | DyckStep | null | true |
ProbabilityTheory.gaussianPDF_def | Mathlib.Probability.Distributions.Gaussian.Real | ∀ (μ : ℝ) (v : NNReal),
ProbabilityTheory.gaussianPDF μ v = fun x => ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal μ v x) | null | true |
ContinuousOn.strictAntiOn_of_injOn_Icc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b → f b ≤ f a → ContinuousOn f (Set.Icc a b) → Set.InjOn f (Set.Icc... | Suppose `f : [a, b] → δ` is
continuous and injective. Then `f` is strictly antitone (decreasing) if `f(b) ≤ f(a)`. | true |
Filter.Eventually.and_frequently | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∃ᶠ (x : α) in f, q x) → ∃ᶠ (x : α) in f, p x ∧ q x | null | true |
Ideal.idealProdEquiv.match_1 | Mathlib.RingTheory.Ideal.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (motive : Ideal R × Ideal S → Prop)
(x : Ideal R × Ideal S), (∀ (I : Ideal R) (J : Ideal S), motive (I, J)) → motive x | null | false |
LatticeHom.fst | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) α | Natural projection homomorphism from `α × β` to `α`. | true |
Function.dcomp_def | Mathlib.Logic.Function.Defs | ∀ {ι : Sort u_3} {β : ι → Sort u_1} {φ : {i : ι} → β i → Sort u_2} (f : {i : ι} → (y : β i) → φ y) (g : (i : ι) → β i),
f ∘' g = fun i => f (g i) | null | true |
PseudoMetric._sizeOf_inst | Mathlib.Topology.MetricSpace.BundledFun | (X : Type u_1) →
(R : Type u_2) →
{inst : Zero R} → {inst_1 : Add R} → {inst_2 : LE R} → [SizeOf X] → [SizeOf R] → SizeOf (PseudoMetric X R) | null | false |
Lean.Meta.Grind.instBEqEMatchTheoremKind.beq | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheoremKind → Lean.Meta.Grind.EMatchTheoremKind → Bool | null | true |
Mathlib.Tactic.Abel.abelNFConv | Mathlib.Tactic.Abel | Lean.ParserDescr | `abel` solves equations in the language of *additive*, commutative monoids and groups.
`abel` and its variants work as both tactics and conv tactics.
* `abel1` fails if the target is not an equality that is provable by the axioms of
commutative monoids/groups.
* `abel_nf` rewrites all group expressions into a norma... | true |
CategoryTheory.CatCenter.smul_iso_hom_eq | Mathlib.CategoryTheory.Center.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (z : (CategoryTheory.CatCenter C)ˣ) {X Y : C} (f : X ≅ Y),
(z • f).hom = CategoryTheory.CategoryStruct.comp f.hom ((↑z).app Y) | null | true |
_private.Lean.CoreM.0.Lean.Core.wrapAsync.match_3 | Lean.CoreM | (motive : Lean.NameGenerator × Lean.NameGenerator → Sort u_1) →
(x : Lean.NameGenerator × Lean.NameGenerator) →
((childNGen parentNGen : Lean.NameGenerator) → motive (childNGen, parentNGen)) → motive x | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
-2 ^ (w + 1) ≤ 2 * x.toInt →
2 * x.toInt < 2 ^ (w + 1) →
-2 ^ (w + 1) ≤ 2 * y.toInt →
2 * y.toInt < 2 ^ (w + 1) →
(-2 ^ (w + 1) ≤ x.toInt - y.toInt →
x.toInt - y.toInt < 2 ^ (w + 1) →
((x.toInt - y.toInt).bmod (2 ^ (w + 1)) < ... | null | false |
_private.Mathlib.RingTheory.Regular.ProjectiveDimension.0.ModuleCat.projectiveDimension_quotSMulTop_eq_succ_of_isSMulRegular._simp_1_9 | Mathlib.RingTheory.Regular.ProjectiveDimension | ∀ {R : Type u_1} {M : Type u_3} [inst : MonoidWithZero R] [inst_1 : Zero M] [inst_2 : MulActionWithZero R M],
IsSMulRegular M 0 = Subsingleton M | null | false |
PUnit.commGroup.eq_1 | Mathlib.Algebra.Group.PUnit | PUnit.commGroup =
{ one := PUnit.unit, mul := fun x x_1 => PUnit.unit, mul_assoc := PUnit.commGroup._proof_7,
one_mul := PUnit.commGroup._proof_8, mul_one := PUnit.commGroup._proof_9, npow_zero := PUnit.commGroup._proof_1,
npow_succ := PUnit.commGroup._proof_2, inv := fun x => PUnit.unit, div_eq_mul_inv := PU... | null | true |
CategoryTheory.Abelian.comp_epiDesc | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[inst_2 : CategoryTheory.Epi f] {T : C} (g : X ⟶ T)
(hg : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) g = 0),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Abelian.ep... | null | true |
Vector.mapFinIdxM._proof_7 | Init.Data.Vector.Basic | ∀ {n : ℕ}, 0 = n - n | null | false |
Algebra.intTraceAux | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | (A : Type u_1) →
(K : Type u_2) →
(L : Type u_3) →
(B : Type u_6) →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
[inst_3 : Field K] →
[inst_4 : Field L] →
[inst_5 : Algebra A K] →
[IsF... | The restriction of the trace on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intTrace` instead. | true |
LinearEquiv.isUnit_det' | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f : M ≃ₗ[A] M),
IsUnit (LinearMap.det ↑f) | Specialization of `LinearEquiv.isUnit_det` | true |
Nat.div2_bit1 | Mathlib.Data.Nat.Bits | ∀ (n : ℕ), (2 * n + 1).div2 = n | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.