name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
RingHom.coe_id | Mathlib.Algebra.Ring.Hom.Defs | ∀ {α : Type u_2} {x : NonAssocSemiring α}, ⇑(RingHom.id α) = id | null | true |
AddGroupExtension.quotientKerRightHomEquivRight.eq_1 | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : AddGroup N] [inst_1 : AddGroup G] {E : Type u_3} [inst_2 : AddGroup E]
(S : AddGroupExtension N E G),
S.quotientKerRightHomEquivRight = QuotientAddGroup.quotientKerEquivOfSurjective S.rightHom ⋯ | null | true |
indepFun_pi_of_prod_bcf | Mathlib.Probability.Independence.BoundedContinuousFunction | ∀ {Ω : Type u_1} {T : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {F : T → Type u_5} {G : Type u_6}
[inst : (t : T) → TopologicalSpace (F t)] [inst_1 : (t : T) → MeasurableSpace (F t)] [∀ (t : T), BorelSpace (F t)]
[∀ (t : T), HasOuterApproxClosed (F t)] [inst_4 : TopologicalSpace G] [inst_5 : ... | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rci.size_eq_size_roi._proof_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} [inst : Std.Rxi.HasSize α] (l : α), Std.Rxi.HasSize.size l = 0 → Std.Rxi.HasSize.size l > 0 → False | null | false |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ¬1 ≤ 2 → False | null | false |
Lean.Elab.Term.Do.ToCodeBlock.doReassignArrowToCode | Lean.Elab.Do.Legacy | Lean.Syntax → List Lean.Syntax → Lean.Elab.Term.Do.ToCodeBlock.M Lean.Elab.Term.Do.CodeBlock | Generate `CodeBlock` for `doReassignArrow; doElems`
`doReassignArrow` is of the form
```
(doIdDecl <|> doPatDecl)
```
| true |
SSet.RelativeMorphism.Homotopy.mk | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | {X Y : SSet} →
{A : X.Subcomplex} →
{B : Y.Subcomplex} →
{φ : A.toSSet ⟶ B.toSSet} →
{f g : SSet.RelativeMorphism A B φ} →
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (SSet.stdSimplex.obj { len := 1 }) ⟶ Y) →
autoParam (CategoryTheory.CategoryStruct.comp SSet.ι₀ h = ... | null | true |
String.apply_skipSuffixWhile_bool_eq_false._proof_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String} {h : s.skipSuffixWhile p ≠ s.startPos}, (s.skipSuffixWhile p).prev h ≠ s.endPos | null | false |
MeasureTheory.Measure.MutuallySingular.compProd_of_left | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ ν : MeasureTheory.Measure α},
μ.MutuallySingular ν → ∀ (κ η : ProbabilityTheory.Kernel α β), (μ.compProd κ).MutuallySingular (ν.compProd η) | null | true |
exists_continuous_sum_one_of_isOpen_isCompact | Mathlib.Topology.PartitionOfUnity | ∀ {X : Type v} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {n : ℕ} {t : Set X} {s : Fin n → Set X},
(∀ (i : Fin n), IsOpen (s i)) →
IsCompact t →
t ⊆ ⋃ i, s i →
∃ f,
(∀ (i : Fin n), tsupport ⇑(f i) ⊆ s i) ∧
Set.EqOn (∑ i, ⇑(f i)) 1 t ∧
(∀ (i : ... | A variation of **Urysohn's lemma**.
In a locally compact T2 space `X`, for a compact set `t` and a finite family of open sets `{s i}_i`
such that `t ⊆ ⋃ i, s i`, there is a family of compactly supported continuous functions `{f i}_i`
supported in `s i`, `∑ i, f i x = 1` on `t` and `0 ≤ f i x ≤ 1`. | true |
AlgebraicGeometry.IsSchemeTheoreticallyDominant.rec | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsSchemeTheoreticallyDominant f → Sort u} →
((ker_eq_bot : AlgebraicGeometry.Scheme.Hom.ker f = ⊥) → motive ⋯) →
(t : AlgebraicGeometry.IsSchemeTheoreticallyDominant f) → motive t | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.primitiveTriangle._proof_27 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ}, 0 < n + 2 → 0 < n + 4 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
OmegaCompletePartialOrder.ContinuousHom.mk | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} →
{β : Type u_3} →
[inst : OmegaCompletePartialOrder α] →
[inst_1 : OmegaCompletePartialOrder β] →
(toOrderHom : α →o β) →
(∀ (c : OmegaCompletePartialOrder.Chain α),
toOrderHom.toFun (OmegaCompletePartialOrder.ωSup c) = OmegaCompletePartialOrder.ωSup (c.map to... | null | true |
WittVector.one_coeff_zero | Mathlib.RingTheory.WittVector.Defs | ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R], WittVector.coeff 1 0 = 1 | null | true |
Set.add_mem_Ico_iff_right | Mathlib.Algebra.Order.Interval.Set.Group | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] {a b c d : α},
a + b ∈ Set.Ico c d ↔ b ∈ Set.Ico (c - a) (d - a) | null | true |
Matroid.eRk_union_ground | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.eRk (X ∪ M.E) = M.eRank | null | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_160 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (n : ℕ)
(lhs : Std.Tactic.BVDecide.BVExpr w) (rhs : Std.Tactic.BVDecide.BVExpr n),
¬llhs.arithShiftRight lrhs = lhs.shiftRight rhs | null | false |
CategoryTheory.ShortComplex.epi_homologyMap_of_epi_cyclesMap' | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
CategoryTheory.Epi (CategoryTheory.ShortComplex.cyclesMap φ) →
CategoryTheory.Epi (CategoryTheor... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_6 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
dense_of_nonempty_smul_invariant | Mathlib.Dynamics.Minimal | ∀ (M : Type u_1) {α : Type u_3} [inst : Monoid M] [inst_1 : TopologicalSpace α] [inst_2 : MulAction M α]
[MulAction.IsMinimal M α] {s : Set α}, s.Nonempty → (∀ (c : M), c • s ⊆ s) → Dense s | null | true |
List.drop_modifyHead_of_pos | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α} {i : ℕ}, 0 < i → List.drop i (List.modifyHead f l) = List.drop i l | null | true |
div_eq_inv_self | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b = b⁻¹ ↔ a = 1 | null | true |
Pi.Lex.instCompleteLinearOrderLexForall._proof_15 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedLT ι] (a : Lex ((i : ι) → α i)), ⊤ \ a = ￢a | null | false |
Matrix.of.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {m : Type u_2} {n : Type u_3} {α : Type v}, Matrix.of = Equiv.refl (m → n → α) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_maxKey!_eq_maxKey._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Finset.min_mem_image_coe | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α}, s.Nonempty → s.min ∈ Finset.image WithTop.some s | null | true |
CauSeq.Completion.Cauchy.divisionRing._proof_9 | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : ℚ≥0) (x_1 : CauSeq.Completion.Cauchy abv),
x • x_1 = ↑x * x_1 | null | false |
_private.Init.Data.Rat.Lemmas.0.Rat.divInt.match_3.eq_1 | Init.Data.Rat.Lemmas | ∀ (motive : ℤ → ℤ → Sort u_1) (n : ℤ) (d : ℕ) (h_1 : (n : ℤ) → (d : ℕ) → motive n (Int.ofNat d))
(h_2 : (n : ℤ) → (d : ℕ) → motive n (Int.negSucc d)),
(match n, Int.ofNat d with
| n, Int.ofNat d => h_1 n d
| n, Int.negSucc d => h_2 n d) =
h_1 n d | null | true |
Rep.coindFunctor_map | Mathlib.RepresentationTheory.Coinduced | ∀ (k : Type u) {G : Type v} {H : Type w} [inst : CommRing k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H)
{X Y : Rep.{t, u, v} k G} (f : X ⟶ Y), (Rep.coindFunctor k φ).map f = Rep.coindMap φ f | null | true |
hasProd_one_add_of_hasSum_prod | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} [inst : CommSemiring α] [inst_1 : TopologicalSpace α] {f : ι → α} {a : α},
HasSum (fun x => ∏ i ∈ x, f i) a → HasProd (fun x => 1 + f x) a | null | true |
GroupExtension.Section.mul_mul_mul_inv_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ : S.Section) (g₁ g₂ : G), σ g₁ * σ g₂ * (σ (g₁ * g₂))⁻¹ ∈ S.inl.range | null | true |
MeasureTheory.instSigmaFiniteQuotientOrbitRelOfHasFundamentalDomainOfQuotientMeasureEqMeasurePreimageVolume | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasureTheory.MeasureSpace α]
[Countable G] [MeasureTheory.SMulInvariantMeasure G α MeasureTheory.volume] [MeasurableConstSMul G α]
[MeasureTheory.SigmaFinite MeasureTheory.volume] [MeasureTheory.HasFundamentalDomain G α MeasureTheo... | If a measure `μ` on a quotient satisfies `QuotientVolumeEqVolumePreimage` with respect to a
sigma-finite measure, then it is itself `SigmaFinite`. | true |
Lean.Elab.Command.instMonadLiftTIOCommandElabM | Lean.Elab.Command | MonadLiftT IO Lean.Elab.Command.CommandElabM | null | true |
AffineMap.differentiableAt | Mathlib.Analysis.Calculus.Deriv.AffineMap | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (f : 𝕜 →ᵃ[𝕜] E) {x : 𝕜}, DifferentiableAt 𝕜 (⇑f) x | null | true |
GetElem? | Init.GetElem | (coll : Type u) → (idx : Type v) → outParam (Type w) → outParam (coll → idx → Prop) → Type (max (max u v) w) | The classes `GetElem` and `GetElem?` implement lookup notation,
specifically `xs[i]`, `xs[i]?`, `xs[i]!`, and `xs[i]'p`.
Both classes are indexed by types `coll`, `idx`, and `elem` which are
the collection, the index, and the element types.
A single collection may support lookups with multiple index
types. The relatio... | true |
pow_lt_pow_right₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 1 < a → m < n → a ^ m < a ^ n | null | true |
AddMonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddMonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | null | true |
NumberField.instCommRingRingOfIntegers._aux_20 | Mathlib.NumberTheory.NumberField.Basic | (K : Type u_1) → [inst : Field K] → ℕ → NumberField.RingOfIntegers K → NumberField.RingOfIntegers K | null | false |
_private.Mathlib.Algebra.Ring.Subring.Defs.0.intCast_mem._simp_1_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u_1} [inst : AddGroupWithOne R] (n : ℤ), ↑n = n • 1 | null | false |
Algebra.Extension | Mathlib.RingTheory.Extension.Basic | (R : Type u) → (S : Type v) → [inst : CommRing R] → [inst_1 : CommRing S] → [Algebra R S] → Type (max (max u v) (w + 1)) | An extension of an `R`-algebra `S` is an `R` algebra `P` together with a surjection `P →ₐ[R] S`.
Also see `Algebra.Extension.ofSurjective`.
| true |
isOfFinAddOrder_ofMul_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G] {x : G}, IsOfFinAddOrder (Additive.ofMul x) ↔ IsOfFinOrder x | null | true |
SeparationQuotient.preimage_image_mk_closed | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsClosed s → SeparationQuotient.mk ⁻¹' SeparationQuotient.mk '' s = s | null | true |
IsCompact.compl_mem_coclosedCompact_of_isClosed | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsClosed s → sᶜ ∈ Filter.coclosedCompact X | null | true |
Lean.Elab.InlayHint.textEdits._inherited_default | Lean.Elab.InfoTree.InlayHints | Array Lean.Elab.InlayHintTextEdit | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {newWidth : ℕ} {aig : Std.Sat.AIG α} {w : ℕ}
(input : aig.RefVec w) (start curr : ℕ) (hcurr : curr ≤ newWidth) (s : aig.RefVec curr),
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go input start curr hcurr s =
if h : curr < newWidth then
have fa... | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig.maxSteps._default | Std.Tactic.BVDecide.Syntax | ℕ | null | false |
ContinuousLinearEquiv.continuousAlternatingMapCongrLeft._proof_1 | Mathlib.Topology.Algebra.Module.Alternating.Topology | ∀ {𝕜 : Type u_1} {E : Type u_2} {E' : Type u_5} {F : Type u_3} {ι : Type u_4} [inst : NormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup E']
[inst_5 : Module 𝕜 E'] [inst_6 : TopologicalSpace E'] [inst_7 : AddCommGroup F] [inst_8 : Module 𝕜 F]
[... | null | false |
Sigma.curry_update | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} [inst : DecidableEq α]
[inst_1 : (a : α) → DecidableEq (β a)] (i : (a : α) × β a) (f : (i : (a : α) × β a) → γ i.fst i.snd)
(x : γ i.fst i.snd),
Sigma.curry (Function.update f i x) =
Function.update (Sigma.curry f) i.fst (Function.update (Sigm... | null | true |
Polynomial.recOnHorner._proof_10 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1}, M (0 * Polynomial.X) = M 0 | null | false |
_private.Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.Array.0.Lean.Meta.Tactic.Cbv.simpArrayGetElem.match_1 | Lean.Meta.Tactic.Cbv.BuiltinCbvSimprocs.Array | (motive : OptionT Id ℕ → Sort u_1) →
(x : OptionT Id ℕ) → ((idx : ℕ) → motive (some idx)) → ((x : OptionT Id ℕ) → motive x) → motive x | null | false |
sup_eq_of_max | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup β] [inst_1 : OrderBot β] {D : α → β} {s : Finset α}
[inst_2 : Nonempty α] {b : β}, b ∈ Set.range D → Function.invFun D b ∈ s → (∀ a ∈ s, D a ≤ b) → s.sup D = b | null | true |
Matrix.cRank_one | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {R : Type uR} [inst : Semiring R] [Nontrivial R] [inst_2 : DecidableEq m] [StrongRankCondition R],
Matrix.cRank 1 = Cardinal.lift.{uR, um} (Cardinal.mk m) | null | true |
LinearMap.IsRefl.liftQ₂._proof_4 | Mathlib.LinearAlgebra.Quotient.Bilinear | ∀ {R : Type u_2} {S : Type u_3} {M : Type u_1} {P : Type u_4} [inst : AddCommGroup M] [inst_1 : CommRing R]
[inst_2 : CommRing S] [inst_3 : Module R M] [inst_4 : AddCommGroup P] [inst_5 : Module S P] {I₁ I₂ : R →+* S}
(f : M →ₛₗ[I₁] M →ₛₗ[I₂] P) (N : Submodule R M), f.IsRefl → N ≤ f.ker → N ≤ f.flip.ker | null | false |
Cardinal.fact_isRegular_aleph0 | Mathlib.SetTheory.Cardinal.Regular | Fact Cardinal.aleph0.IsRegular | null | true |
Finset.finsuppAntidiagEquivSubtype._proof_2 | Mathlib.Algebra.Order.Antidiag.FinsuppEquiv | ∀ {ι : Type u_2} {μ : Type u_1} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] (s : Finset ι) (n : μ)
(f : { P // (P.sum fun x => id) = n }), ((↑f).extendDomain.sum fun x x_1 => x_1) = n | null | false |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf.induct_unfolding | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded (Std.Rxi.Iterator α) Id Pl) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), Std.PRange.UpwardE... | null | true |
NonUnitalRing.sub._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u_1} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), nsmul 0 x = 0) → (∀ (n : ℕ) (x : α), nsmul (n + 1) x = nsmul n x + x) → (α → α) → α → α... | null | false |
_private.Lean.DocString.Markdown.0.Lean.Doc.midLineSpecial.match_1 | Lean.DocString.Markdown | (motive : Char → Sort u_1) → (c : Char) → (Unit → motive '!') → ((x : Char) → motive x) → motive c | null | false |
invertibleOfLeftInverse | Mathlib.Algebra.Group.Invertible.Defs | {α : Type u} → [inst : Monoid α] → [IsDedekindFiniteMonoid α] → (a b : α) → b * a = 1 → Invertible a | An element in a Dedekind-finite monoid is invertible if it has a left inverse. | true |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleRing.exists_linearEquiv_ideal_of_isSimpleModule.match_1_3 | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_1) [inst : Ring R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)) → Prop) (x : ∃ I, I.IsMaximal ∧ Nonempty (M ≃ₗ[R] R ⧸ I)),
(∀ (J : Ideal R) (left : J.IsMaximal) (e : M ≃ₗ[R] R ⧸ J), motive ⋯) → motive x | null | false |
ContDiff.fun_comp_contDiffOn | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : 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] {n : WithTop ℕ∞} {s : Set E} {g : F →... | null | true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.parseTagged.match_5 | Lean.Data.Json.FromToJson.Basic | (motive : Option (Array Lean.Name) → Sort u_1) →
(fieldNames? : Option (Array Lean.Name)) →
((fieldNames : Array Lean.Name) → motive (some fieldNames)) → (Unit → motive none) → motive fieldNames? | null | false |
Set.preimage_preimage | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {g : β → γ} {f : α → β} {s : Set γ},
f ⁻¹' g ⁻¹' s = (fun x => g (f x)) ⁻¹' s | null | true |
HomotopicalAlgebra.LeftHomotopyClass.whitehead | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
[HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y] [HomotopicalAlgebra.IsFibrant X]
[HomotopicalAlgebra.IsFibrant Y] (f : X ⟶ Y) [HomotopicalAlgebra.WeakEquivalence f],
∃ g,
Homo... | null | true |
nontrivial_iff | Mathlib.Logic.Nontrivial.Defs | ∀ {α : Type u_1}, Nontrivial α ↔ ∃ x y, x ≠ y | null | true |
AlgebraicGeometry.Scheme.Cover.instCategoryI₀Pullback₁._aux_1 | Mathlib.AlgebraicGeometry.Cover.Directed | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{X : AlgebraicGeometry.Scheme} →
[inst : P.IsStableUnderBaseChange] →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) →
[CategoryTheory.Category.{u_1, u_2} 𝒰.I₀] →
{Y : AlgebraicGeometry.Sche... | null | false |
CategoryTheory.Functor.FullyFaithful.homEquiv.eq_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C},
hF.homEquiv = { toFun := F.map, invFun := hF.preimage, left_inv := ⋯, right_inv := ⋯ } | null | true |
IsLowerSet.isOpen | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [WellFoundedLT α] {s : Set α},
IsLowerSet s → IsOpen s | null | true |
CategoryTheory.overEquivOfIsInitial | Mathlib.CategoryTheory.Comma.Over.StrictInitial | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Limits.HasStrictInitialObjects C] →
(X : C) → CategoryTheory.Limits.IsInitial X → (CategoryTheory.Over X ≌ CategoryTheory.Discrete PUnit.{w + 1}) | If `C` has strict initial objects and `X` is an initial object, the category
`Over X` is equivalent to a point. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.subgraphOfAdj_eq_induce._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_6 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) (M : Type u_1) [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
AddSubmonoidClass (LieSubmodule R (↥H) M) M | null | false |
ProbabilityTheory.Kernel.ae_comp_of_ae_ae | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} {η : ProbabilityTheory.Kernel β γ} {a : α} {p : γ → Prop},
MeasurableSet {z | p z} → (∀ᵐ (y : β) ∂κ a, ∀ᵐ (z : γ) ∂η y, p z) → ∀ᵐ (z : γ) ∂(η.comp κ) a, p z | null | true |
ProbabilityTheory.Kernel.lintegral_id | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} [MeasurableSingletonClass α] {f : α → ENNReal} (a : α),
∫⁻ (a : α), f a ∂ProbabilityTheory.Kernel.id a = f a | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionAssocNatIso_hom_app_app_app | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (X X_1 : C) (X_2 : D),
(((CategoryTheory.MonoidalCategory.MonoidalLeftAction.... | null | true |
CategoryTheory.ObjectProperty.isoClosure_eq_self | Mathlib.CategoryTheory.ObjectProperty.ClosedUnderIsomorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderIsomorphisms], P.isoClosure = P | null | true |
Lean.Grind.CommRing.Expr.toPolyC.go.match_4.congr_eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (x : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | null | true |
Lean.Lsp.ApplyWorkspaceEditParams.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (label? : Option String) (edit : Lean.Lsp.WorkspaceEdit),
sizeOf { label? := label?, edit := edit } = 1 + sizeOf label? + sizeOf edit | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.Mathlib.Meta.Positivity.evalIntegral.match_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα pα e) → Sort u_1) →
(u : ... | null | false |
sInf_mem_lowerBounds | Mathlib.Order.CompleteLattice.Defs | ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α] {s : Set α}, sInf s ∈ lowerBounds s | null | true |
PartialFun.instCoeSortType | Mathlib.CategoryTheory.Category.PartialFun | CoeSort PartialFun (Type u_1) | null | true |
Filter.mem_zero | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, s ∈ 0 ↔ 0 ∈ s | null | true |
MvPolynomial.eval₂_comp_left | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁] {S₂ : Type u_2}
[inst_2 : CommSemiring S₂] (k : S₁ →+* S₂) (f : R →+* S₁) (g : σ → S₁) (p : MvPolynomial σ R),
k (MvPolynomial.eval₂ f g p) = MvPolynomial.eval₂ (k.comp f) (⇑k ∘ g) p | null | true |
Std.DTreeMap.Internal.Impl.Const.get?_union_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF) (h₂ : m₂.WF) {k : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.get? (m₁.union m₂ ⋯ ⋯) k = Std.DTreeMap.Internal.Impl.Const.get? m₂ k | null | true |
CategoryTheory.AddMon.Hom.mk | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} → (hom : M.X ⟶ N.X) → [isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] → M.Hom N | null | true |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation | Init.Data.String.Pattern.Basic | {ρ : Type} →
(pat : ρ) →
(s : String.Slice) →
[inst : String.Slice.Pattern.ForwardPattern pat] →
[String.Slice.Pattern.StrictForwardPattern pat] →
Std.Iterators.FinitenessRelation (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s) Id | null | true |
Subtype.orderBot._proof_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u_1} {p : α → Prop} [inst : LE α] [inst_1 : OrderBot α] (x : { x // p x }), ⊥ ≤ ↑x | null | false |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.dist_triangle_nonarch._simp_1_4 | Mathlib.Topology.MetricSpace.PiNat | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 0 < a → ∀ (n : ℕ), (0 < a ^ n) = True | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchAction.0.Lean.Meta.Grind.Action.EMatchTheoremIds | Lean.Meta.Tactic.Grind.EMatchAction | Type | null | true |
LieRinehartAlgebra.Hom.comp._proof_1 | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_3} {A₁ : Type u_7} {L₁ : Type u_2} {A₂ : Type u_5} {L₂ : Type u_4} {A₃ : Type u_6} {L₃ : Type u_1}
[inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : LieRing L₁] [inst_3 : Module A₁ L₁]
[inst_4 : LieRingModule L₁ A₁] [inst_5 : CommRing A₂] [inst_6 : LieRing L₂] [inst_7 : Module A₂ L₂]
[inst_8 : Li... | null | false |
CategoryTheory.GrothendieckTopology.sheafify.eq_1 | Mathlib.CategoryTheory.Sites.CompatibleSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
[inst_3 : ∀ (X : C), Categ... | null | true |
Std.DTreeMap.Internal.Impl.Equiv.getKey_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} (hk : k ∈ t₁), t₁.getKey k hk = t₂.getKey k ⋯ | null | true |
IsDiscreteValuationRing.toWithBotNat_eq_bot_iff | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] (x : R),
IsDiscreteValuationRing.toWithBotNat x = ⊥ ↔ x = 0 | null | true |
Tropical.trop_inj_iff | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} (x y : R), Tropical.trop x = Tropical.trop y ↔ x = y | null | true |
multipliable_of_exists_eq_zero | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoidWithZero α] [inst_1 : TopologicalSpace α] {f : β → α}
{L : SummationFilter β}, (∃ b, f b = 0) → ∀ [L.LeAtTop], Multipliable f L | null | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.posGE_le_iff._simp_1_3 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_5 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Sort u_1}, (∀ (a : α), True) = True | null | false |
CharTwo.add_cancel_right | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : Semiring R] [CharP R 2] (a b : R), a + b + b = a | null | true |
Mathlib.Tactic.Contrapose.contrapose.negate_iff | Mathlib.Tactic.Contrapose | Lean.Option Bool | An option to turn off the feature that `contrapose` negates both sides of `↔` goals.
This may be useful for teaching. | true |
_private.Mathlib.GroupTheory.Coxeter.Basic.0.CoxeterSystem.getElem_alternatingWord._proof_1_5 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (i j : B) (n k : ℕ), k ≤ n → ¬k = 0 → k - 1 < (CoxeterSystem.alternatingWord i j n).length | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.