name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddCommSemigroup.add_comm | Mathlib.Algebra.Group.Semigroup | ∀ {G : Type u_2} [self : AddCommSemigroup G] (a b : G), a + b = b + a | Addition is commutative in a commutative additive magma. | true |
BitVec.shiftRight_sub_one_eq_shiftConcat | Init.Data.BitVec.Lemmas | ∀ {w wn : ℕ} (n : BitVec w), 0 < wn → n >>> (wn - 1) = (n >>> wn).shiftConcat (n.getLsbD (wn - 1)) | null | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.runM | Lean.Server.Completion.CompletionCollectors | Lean.Lsp.DocumentUri →
Lean.Lsp.Position →
ℕ →
Lean.Elab.ContextInfo →
Lean.LocalContext →
Lean.Server.Completion.M✝ Unit → Lean.Server.CancellableM (Array Lean.Lsp.ResolvableCompletionItem) | null | true |
CategoryTheory.fieldEndOfFiniteDimensional._proof_10 | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] (X : C) [inst_3 : CategoryTheory.Simple X] (q : ℚ≥0),
↑q = ↑q.num / ↑q.den | null | false |
Std.Internal.List.Const.isSome_minKey?_modifyKey_eq_isSome | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α] {k : α} {f : β → β}
{l : List ((_ : α) × β)},
(Std.Internal.List.minKey? (Std.Internal.List.Const.modifyKey k f l)).isSome = (Std.Internal.List.minKey? l).isSome | null | true |
_private.Mathlib.Combinatorics.KatonaCircle.0.Numbering.prefixedEquiv._simp_25 | Mathlib.Combinatorics.KatonaCircle | ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, (f = g) = ∀ (x : α), f x = g x | null | false |
Std.Sat.AIG.RefVec.IfInput.mk | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} → {w : ℕ} → aig.Ref → aig.RefVec w → aig.RefVec w → Std.Sat.AIG.RefVec.IfInput aig w | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodingStepWithEta._proof_1 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Nonempty
(ReaderT Lean.Meta.RefinedDiscrTree.Context✝ Lean.MetaM
(List (Lean.Meta.RefinedDiscrTree.Key × Lean.Meta.RefinedDiscrTree.LazyEntry))) | null | false |
Lean.getPPAnalyzeTrustSubtypeMk | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Options → Bool | null | true |
Set.IsSelfNeg.iInter | Mathlib.Algebra.Group.Pointwise.Set.SelfInv | ∀ {α : Type u_1} [inst : Neg α] {ι : Sort u_3} {s : ι → Set α}, (∀ (i : ι), IsSelfNeg (s i)) → IsSelfNeg (⋂ i, s i) | null | true |
Lean.Elab.DefsParsedSnapshot.isFatal._inherited_default | Lean.Elab.DefView | Bool | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.top_isIndContained_iff_top_isContained.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {V : Type u_2} {W : Type u_1} {H : SimpleGraph W} (motive : ⊤.IsContained H → Prop) (x : ⊤.IsContained H),
(∀ (f : ⊤.Copy H), motive ⋯) → motive x | null | false |
PEquiv.instFunLikeOption | Mathlib.Basic.PEquiv | {α : Type u} → {β : Type v} → FunLike (α ≃. β) α (Option β) | null | true |
Stream'.Seq.set_nil | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (n : ℕ) (x : α), Stream'.Seq.nil.set n x = Stream'.Seq.nil | null | true |
Nat.pow_mul' | Init.Data.Nat.Lemmas | ∀ (a m n : ℕ), a ^ (m * n) = (a ^ n) ^ m | null | true |
Nat.prime_def_le_sqrt | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Nat.Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), 2 ≤ m → m ≤ p.sqrt → ¬m ∣ p | null | true |
isLUB_ciSup | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α] [Nonempty ι] {f : ι → α},
BddAbove (Set.range f) → IsLUB (Set.range f) (⨆ i, f i) | null | true |
AlgebraNorm.isScalarTower_restriction._proof_3 | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | ∀ {R : Type u_2} [inst : SeminormedCommRing R] {S : Type u_1} [inst_1 : Ring S] [inst_2 : Algebra R S] {A : Type u_3}
[inst_3 : CommRing A] [inst_4 : Algebra A S] (f : AlgebraNorm R S) (x y : A),
f ((algebraMap A S) (x + y)) ≤ f ((algebraMap A S) x) + f ((algebraMap A S) y) | null | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.inr._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | 1 + -1 = 0 | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_filterMap_iff._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (p : α → Bool) (x : Option α), (Option.any p x = true) = ∃ y, x = some y ∧ p y = true | null | false |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.isSeparated_maximalSeparatedSet._proof_1_2 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal},
¬Metric.packingNumber ε A = ⊤ → ∃ C ⊆ A, C.Finite ∧ Metric.IsSeparated (↑ε) C ∧ C.encard = Metric.packingNumber ε A | null | false |
Lean.Elab.elabTerminationByHints | Lean.Elab.PreDefinition.Main | Array Lean.Elab.PreDefinition → Lean.Elab.TermElabM (Array (Option Lean.Elab.TerminationMeasure)) | Elaborates the `TerminationHint` in the clique to `TerminationMeasures`
| true |
FirstOrder.Language.DirectLimit.cg' | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type u_1} [Countable ι] [inst : Preorder ι] [inst_1 : IsDirectedOrder ι]
[inst_2 : Nonempty ι] {G : ι → Type w} [inst_3 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [h : ∀ (i : ι), FirstOrder.Language.Structure.CG L (G i)]
[inst_4 : DirectedSyst... | null | true |
_private.Batteries.Data.List.Basic.0.List.dropSliceTR.go.match_1.splitter | Batteries.Data.List.Basic | {α : Type u_1} →
(motive : List α → ℕ → Array α → Sort u_2) →
(x : List α) →
(x_1 : ℕ) →
(x_2 : Array α) →
((x : ℕ) → (x_3 : Array α) → motive [] x x_3) →
((head : α) → (xs : List α) → (acc : Array α) → motive (head :: xs) 0 acc) →
((x : α) → (xs : List α) → (n : ... | null | true |
isAddUnit_iff_exists | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {x : M}, IsAddUnit x ↔ ∃ b, x + b = 0 ∧ b + x = 0 | See `isAddUnit_iff_exists_and_exists` for a similar lemma with two existentials. | true |
CategoryTheory.GrothendieckTopology.HOneHypercover | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.GrothendieckTopology C → C → Type (max (max u v) (u_1 + 1)) | The category of `1`-hypercovers with refinement morphisms up to homotopy. | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.elabRename.addRule | Mathlib.Tactic.Translate.Core | Lean.Name →
Array Lean.Name →
Lean.TSyntax `ident → Lean.TSyntax `ident → Lean.NameMap Lean.Name → Lean.MetaM (Lean.NameMap Lean.Name) | null | true |
Bialgebra.TensorProduct.rid_toAlgEquiv | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R S A],
(Bialgebra.TensorProduct.rid R S A).toAlgEquiv = Algebra.TensorProduct.rid R S A | null | true |
Matrix.invOf_fromBlocks_zero₁₂_eq | Mathlib.LinearAlgebra.Matrix.SchurComplement | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_4} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : DecidableEq m]
[inst_3 : DecidableEq n] [inst_4 : CommRing α] (A : Matrix m m α) (C : Matrix n m α) (D : Matrix n n α)
[inst_5 : Invertible A] [inst_6 : Invertible D] [inst_7 : Invertible (Matrix.fromBlocks A 0 C D)],
... | null | true |
Nat.succ | Init.Prelude | ℕ → ℕ | The successor of a natural number `n`.
Using `Nat.succ n` should usually be avoided in favor of `n + 1`, which is the [simp normal
form](https://lean-lang.org/doc/reference/4.35.0/find/?domain=Verso.Genre.Manual.section&name=simp-normal-forms).
| true |
StrictConcaveOn.congr | 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 : PartialOrder β] [inst_5 : SMul 𝕜 E] [inst_6 : SMul 𝕜 β] {s : Set E}
{f g : E → β}, StrictConcaveOn 𝕜 s f → Set.EqOn f g s → StrictConcaveOn 𝕜 s g | null | true |
HahnSeries.SummableFamily.smul_hsum | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {α : Type u_5} {β : Type u_6} [inst : PartialOrder Γ] [inst_1 : PartialOrder Γ']
[inst_2 : VAdd Γ Γ'] [inst_3 : IsOrderedCancelVAdd Γ Γ'] {R : Type u_7} {V : Type u_8} [inst_4 : Semiring R]
[inst_5 : AddCommMonoid V] [inst_6 : Module R V] (s : HahnSeries.SummableFamily Γ R α)
(t :... | null | true |
Lean.Compiler.LCNF.Simp.InlineCandidateInfo.ifReduce | Lean.Compiler.LCNF.Simp.InlineCandidate | Lean.Compiler.LCNF.Simp.InlineCandidateInfo → Bool | `ifReduce = true` if the declaration being inlined was tagged with `inline_if_reduce`. | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow.mk | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{J : CategoryTheory.GrothendieckTopology C} → {S : J.Cover X} → (Y : C) → (f : Y ⟶ X) → (↑S).arrows f → S.Arrow | null | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.isoImage_ι_assoc | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
BesselPotentialSpace.instAddCommGroup._proof_9 | 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)],
auto... | null | false |
addMonoidEndRingEquivInt_apply | Mathlib.Algebra.Module.Equiv.Basic | ∀ (A : Type u_9) [inst : AddCommGroup A] (a : A →+ A),
(addMonoidEndRingEquivInt A) a = (↑(addMonoidHomLequivInt ℤ)).toFun a | null | true |
Std.Iter.findM?_toList | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type} {m : Type → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α Id β] [inst_2 : Std.IteratorLoop α Id m]
[LawfulMonad m] [Std.Iterators.Finite α Id] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → m Bool},
List.findM? f it.toList = it.findM? fun x => ULift.up <$> f x | null | true |
_private.Mathlib.RingTheory.RingHom.Locally.0.RingHom.locally_iff_isLocalization.match_1_1 | Mathlib.RingTheory.RingHom.Locally | ∀ {P : {R S : Type u_1} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} {R S : Type u_1}
[inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S)
(motive : (∃ s, ∃ (_ : Ideal.span ↑s = ⊤), ∀ t ∈ s, P ((algebraMap S (Localization.Away t)).comp f)) → Prop)
(x : ∃ s, ∃ (_ : Ideal.span ↑s = ⊤), ∀ t ∈... | null | false |
IsLocalization.map_eq | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {g : R →+* P}
{T : Submonoid P} {Q : Type u_4} [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T... | null | true |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.Seq.reverse.go._f | Lean.Meta.Tactic.Grind.AC.Seq | (a : Lean.Grind.AC.Seq) →
Lean.Grind.AC.Seq.below (motive := fun a => Lean.Grind.AC.Seq → Lean.Grind.AC.Seq) a →
Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | false |
MvPolynomial.coe_monomial | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (n : σ →₀ ℕ) (a : R),
↑((MvPolynomial.monomial n) a) = (MvPowerSeries.monomial n) a | null | true |
closure_eq_self_union_frontier | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] (s : Set X), closure s = s ∪ frontier s | null | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.degree_mul_of_isRegular_left._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u_1} [inst : MulZeroClass R] {a b : R}, IsLeftRegular b → (b * a = 0) = (a = 0) | null | false |
PeriodPair.order_weierstrassP | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), ∀ l₀ ∈ L.lattice, meromorphicOrderAt L.weierstrassP l₀ = -2 | null | true |
isCompl_ofDual_iff._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {a b : αᵒᵈ},
IsCompl (OrderDual.ofDual a) (OrderDual.ofDual b) = IsCompl a b | null | false |
_private.Init.Data.Array.Find.0.Array.find?_flatten_eq_some_iff._simp_1_3 | Init.Data.Array.Find | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
String.Slice.front? | Init.Data.String.Slice | String.Slice → Option Char | Returns the first character in `s`. If `s` is empty, returns `none`.
Examples:
* `"abc".toSlice.front? = some 'a'`
* `"".toSlice.front? = none`
| true |
Lean.Parser.ParserCacheEntry.rec | Lean.Parser.Types | {motive : Lean.Parser.ParserCacheEntry → Sort u} →
((stx : Lean.Syntax) →
(lhsPrec : ℕ) →
(newPos : String.Pos.Raw) →
(errorMsg : Option Lean.Parser.Error) →
motive { stx := stx, lhsPrec := lhsPrec, newPos := newPos, errorMsg := errorMsg }) →
(t : Lean.Parser.ParserCacheEntry) ... | null | false |
cardinalMk_algHom | Mathlib.FieldTheory.Fixed | ∀ (K : Type u) (V : Type v) (W : Type w) [inst : Field K] [inst_1 : Ring V] [inst_2 : Algebra K V]
[FiniteDimensional K V] [inst_4 : Field W] [inst_5 : Algebra K W],
Cardinal.mk (V →ₐ[K] W) ≤ ↑(Module.finrank W (V →ₗ[K] W)) | null | true |
IsOpen.ae_eq_zero_of_integral_contMDiff_smul_eq_zero' | Mathlib.Analysis.Distribution.AEEqOfIntegralContDiff | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {F : Type u_2}
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [CompleteSpace F] {H : Type u_3}
[inst_6 : TopologicalSpace H] (I : ModelWithCorners ℝ E H) {M : Type u_4} [inst_7 : TopologicalSpace M]
[inst... | If a function `f` locally integrable on an open subset `U` of a finite-dimensional real
manifold has zero integral when multiplied by any smooth function compactly supported
in `U`, then `f` vanishes almost everywhere in `U`. | true |
MonadSatisfying.instStateRefT'._aux_1 | Batteries.Recycling.MonadSatisfying.Basic | {m : Type → Type} →
{ω σ : Type} →
[inst : Monad m] →
[inst_1 : LawfulMonad m] →
[MonadSatisfying m] →
{α : Type} → {p : α → Prop} → {x : StateRefT' ω σ m α} → SatisfiesM p x → StateRefT' ω σ m { a // p a } | null | false |
cauchySeq_const | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : SemilatticeSup β] [Nonempty β] (x : α),
CauchySeq fun x_1 => x | null | true |
Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline.elim | Lean.Compiler.LCNF.Simp.FunDeclInfo | {motive : Lean.Compiler.LCNF.Simp.FunDeclInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.FunDeclInfo) →
t.ctorIdx = 2 → motive Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline → motive t | null | false |
Tilt.instField._aux_1 | Mathlib.RingTheory.Perfection | (K : Type u_1) →
[inst : Field K] →
(v : Valuation K NNReal) →
(O : Type u_2) →
[inst_1 : CommRing O] →
[inst_2 : Algebra O K] →
(hv : v.Integers O) →
(p : ℕ) → [inst_3 : Fact (Nat.Prime p)] → [hvp : Fact (v ↑p ≠ 1)] → Fact ¬IsUnit ↑p → Tilt K v O hv p | null | false |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Stream.readAll.loop._unsafe_rec | Std.Http.Data.Body.Stream | {m : Type → Type} →
[Monad m] →
[MonadExceptOf IO.Error m] →
[Std.Http.Body.Stream.NextChunk m] → Std.Http.Body.Stream → Option UInt64 → ByteArray → m ByteArray | null | false |
MeasureTheory.VectorMeasure.add | Mathlib.MeasureTheory.VectorMeasure.Basic | {α : Type u_1} →
{m : MeasurableSpace α} →
{M : Type u_3} →
[inst : AddCommMonoid M] →
[inst_1 : TopologicalSpace M] →
[ContinuousAdd M] →
MeasureTheory.VectorMeasure α M → MeasureTheory.VectorMeasure α M → MeasureTheory.VectorMeasure α M | The sum of two vector measure is a vector measure. | true |
Lean.Order.instCCPOPProd | Init.Internal.Order.Basic | {α : Sort u} → {β : Sort v} → [Lean.Order.CCPO α] → [Lean.Order.CCPO β] → Lean.Order.CCPO (α ×' β) | null | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Real.exists_isMinOn_norm_φ | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ {F : Type u_1} [inst : NormedRing F] [inst_1 : NormedAlgebra ℝ F] [NormOneClass F] (x : F),
∃ z, IsMinOn (fun x_1 => ‖NormedAlgebra.Real.φ✝ x x_1‖) Set.univ z | The norm of `‖φ x ·‖` attains a minimum on `ℝ × ℝ`. | true |
ClosedSubmodule.comap_id | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] (s : ClosedSubmodule R M), ClosedSubmodule.comap (ContinuousLinearMap.id R M) s = s | null | true |
_private.Mathlib.Topology.Constructions.0.inducing_sigma.match_1_4 | Mathlib.Topology.Constructions | ∀ {X : Type u_2} {ι : Type u_3} {σ : ι → Type u_1} [inst : (i : ι) → TopologicalSpace (σ i)]
[inst_1 : TopologicalSpace X] {f : Sigma σ → X}
(motive :
((∀ (i : ι), Topology.IsInducing (f ∘ Sigma.mk i)) ∧
∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i) →
Prop)
(x :
(∀ (i : ι)... | null | false |
CategoryTheory.instGroupoidFreeGroupoid | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Groupoid (CategoryTheory.FreeGroupoid C) | null | true |
ContinuousMap.instNonAssocSemiringOfIsTopologicalSemiring._proof_3 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonAssocSemiring β]
[inst_3 : IsTopologicalSemiring β], autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
Set.ncard_le_ncard_iff_ncard_diff_le_ncard_diff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α},
autoParam s.Finite Set.ncard_le_ncard_iff_ncard_sdiff_le_ncard_sdiff._auto_1 →
autoParam t.Finite Set.ncard_le_ncard_iff_ncard_sdiff_le_ncard_sdiff._auto_3 →
(s.ncard ≤ t.ncard ↔ (s \ t).ncard ≤ (t \ s).ncard) | **Alias** of `Set.ncard_le_ncard_iff_ncard_sdiff_le_ncard_sdiff`. | true |
GroupSeminorm.comp._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} {F : Type u_2} [inst : Group E] [inst_1 : Group F] (p : GroupSeminorm E) (f : F →* E), p (f 1) = 0 | null | false |
_private.Lean.Compiler.LCNF.ResetReuse.0.Lean.Compiler.LCNF.Context.ctorIdx | Lean.Compiler.LCNF.ResetReuse | Lean.Compiler.LCNF.Context✝ → ℕ | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.dbgTrace._regBuiltin.Lean.Parser.Term.dbgTrace_1 | Lean.Parser.Term | IO Unit | null | false |
Subgroup.normalizer_le_normalizer_closure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] (s : Set G), Subgroup.normalizer s ≤ Subgroup.normalizer ↑(Subgroup.closure s) | null | true |
MeasureTheory.IsFundamentalDomain.mk_of_measure_univ_le | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] [Countable G],
MeasureTheory.NullMeasurableSet s μ →
(∀ (g : G), g ≠ 1 → MeasureTheory.AEDisjoint μ (g • s) s) →
(∀ (g : G), Me... | If a measurable space has a finite measure `μ` and a countable group `G` acts
quasi-measure-preservingly, then to show that a set `s` is a fundamental domain, it is sufficient
to check that its translates `g • s` are (almost) disjoint and that the sum `∑' g, μ (g • s)` is
sufficiently large. | true |
Multiset.coe_consEquiv_of_ne._proof_1 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {m : Multiset α} {v : α} (x : (v ::ₘ m).ToType),
x.fst ≠ v → Multiset.count x.fst (v ::ₘ m) = Multiset.count x.fst m | null | false |
Subtype.map_involutive | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {f : α → α} (h : ∀ (a : α), p a → p (f a)),
Function.Involutive f → Function.Involutive (Subtype.map f h) | null | true |
Lean.Compiler.LCNF.Simp.Config.recOn | Lean.Compiler.LCNF.Simp.Config | {motive : Lean.Compiler.LCNF.Simp.Config → Sort u} →
(t : Lean.Compiler.LCNF.Simp.Config) →
((etaPoly inlinePartial implementedBy inlineDefs : Bool) →
motive
{ etaPoly := etaPoly, inlinePartial := inlinePartial, implementedBy := implementedBy,
inlineDefs := inlineDefs }) →
moti... | null | false |
PosNum.ldiff.match_1 | Mathlib.Data.Num.Bitwise | (motive : PosNum → PosNum → Sort u_1) →
(x x_1 : PosNum) →
((a : PosNum) → motive PosNum.one a.bit0) →
((x : PosNum) → motive PosNum.one x) →
((p : PosNum) → motive p.bit0 PosNum.one) →
((p : PosNum) → motive p.bit1 PosNum.one) →
((p q : PosNum) → motive p.bit0 q.bit0) →
... | null | false |
MeasureTheory.NullMeasurableSet.of_compl | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet sᶜ μ → MeasureTheory.NullMeasurableSet s μ | null | true |
_private.Mathlib.GroupTheory.Finiteness.0.Submonoid.FG.pi._simp_1_1 | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : MulOneClass M] {P : Submonoid M}, IsMulFG ↥P = ∃ S, Submonoid.closure ↑S = P | null | false |
Finset.zero_div_subset | Mathlib.Algebra.GroupWithZero.Pointwise.Finset | ∀ {α : Type u_1} [inst : GroupWithZero α] [inst_1 : DecidableEq α] (s : Finset α), 0 / s ⊆ 0 | null | true |
MeasureTheory.Measure.prod.instNullSingletonClass_snd | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.NullSingletonClass ν], MeasureTheory.NullSingletonClass (μ.prod ν) | null | true |
Lean.Lsp.LeanIdentifier.mk.injEq | Lean.Data.Lsp.Internal | ∀ (module decl : Lean.Name) (isExactMatch : Bool) (module_1 decl_1 : Lean.Name) (isExactMatch_1 : Bool),
({ module := module, decl := decl, isExactMatch := isExactMatch } =
{ module := module_1, decl := decl_1, isExactMatch := isExactMatch_1 }) =
(module = module_1 ∧ decl = decl_1 ∧ isExactMatch = isExactMa... | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_dvd_fdiv.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ (motive : (x x_1 x_2 : ℤ) → x ∣ x_1 → x_1 ∣ x_2 → Prop) (x x_1 x_2 : ℤ) (x_3 : x ∣ x_1) (x_4 : x_1 ∣ x_2),
(∀ (a b c : ℤ), motive a (a * b) (a * b * c) ⋯ ⋯) → motive x x_1 x_2 x_3 x_4 | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits.termL₂'_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.ParserDescr | null | true |
MeasureTheory.SimpleFunc.integrable_approxOn | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {β : Type u_2} {E : Type u_4} [inst : MeasurableSpace β] [inst_1 : MeasurableSpace E] [inst_2 : NormedAddCommGroup E]
[inst_3 : BorelSpace E] {f : β → E} {μ : MeasureTheory.Measure β} (fmeas : Measurable f),
MeasureTheory.Integrable f μ →
∀ {s : Set E} {y₀ : E} (h₀ : y₀ ∈ s) [inst_4 : TopologicalSpace.Separab... | null | true |
ContextFreeGrammar.reverse_surjective | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1}, Function.Surjective ContextFreeGrammar.reverse | null | true |
SemiRingCat.semiringObj._proof_26 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J SemiRingCat) (j : J)
(a b c : (F.comp (CategoryTheory.forget SemiRingCat)).obj j), a * (b + c) = a * b + a * c | null | false |
Seminorm.IsBounded | Mathlib.Analysis.LocallyConvex.WithSeminorms | {𝕜 : Type u_2} →
{𝕜₂ : Type u_3} →
{E : Type u_6} →
{F : Type u_7} →
{ι : Type u_9} →
{ι' : Type u_10} →
[inst : SeminormedRing 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : SeminormedRing 𝕜₂] →
... | The proposition that a linear map is bounded between spaces with families of seminorms. | true |
Algebra.kerTensorProductMapIdToAlgHomEquiv._proof_7 | Mathlib.RingTheory.Flat.Equalizer | ∀ (R : Type u_3) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
[inst_3 : CommRing A] [inst_4 : Algebra R A] (x : S),
(Algebra.TensorProduct.comm R A S).toFun ((algebraMap S (TensorProduct R A S)) x) =
(Algebra.TensorProduct.comm R A S).toFun ((algebraMap S (Tenso... | null | false |
Std.Time.Timestamp.toDurationSinceUnixEpoch | Std.Time.DateTime.Timestamp | Std.Time.Timestamp → Std.Time.Duration | Returns the `Duration` represented by the `Timestamp` since the Unix epoch.
| true |
LinearMap.comp_id_moduleCat | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_1} [inst : Ring R] {G : ModuleCat R} {H : Type u} [inst_1 : AddCommGroup H] [inst_2 : Module R H]
(f : ↑G →ₗ[R] H), f ∘ₗ ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.id G) = f | null | true |
Std.ExtDHashMap.isSome_get?_eq_contains | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {a : α},
(m.get? a).isSome = m.contains a | null | true |
_private.Lean.Meta.Tactic.Intro.0.Lean.Meta.introNImp | Lean.Meta.Tactic.Intro | {σ : Type} →
Lean.MVarId →
ℕ →
(Lean.LocalContext → Lean.Name → Bool → σ → Lean.MetaM (Lean.Name × σ)) →
σ → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) | null | true |
CategoryTheory.Precoverage.ZeroHypercover._sizeOf_inst | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
(J : CategoryTheory.Precoverage C) → (S : C) → [SizeOf C] → SizeOf (J.ZeroHypercover S) | null | false |
Lean.PersistentHashMap.findEntryAux._unsafe_rec | Lean.Data.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → [BEq α] → Lean.PersistentHashMap.Node α β → USize → α → Option (α × β) | null | false |
Lean.Grind.Linarith.Expr.ctorElimType | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} → ℕ → Sort (max 1 u) | null | false |
_private.Mathlib.MeasureTheory.Integral.Regular.0.IsOpen.measure_eq_biSup_integral_continuous._simp_1_1 | Mathlib.MeasureTheory.Integral.Regular | ∀ {α : Type u_1} {ι : Sort u_3} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (a < iSup f) = ∃ i, a < f i | null | false |
CategoryTheory.CatEnriched.instBicategory._proof_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_1} [inst : CategoryTheory.EnrichedCategory CategoryTheory.Cat C] {a b c : CategoryTheory.CatEnriched C}
(f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CatEnriched.hComp (CategoryTheory.CategoryStruct.id f) (CategoryTheory.CategoryStruct.id g) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStr... | null | false |
MeasureTheory.memLp_piLp_iff | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≤ q)]
{ι : Type u_2} [inst_1 : Fintype ι] {E : ι → Type u_3} [inst_2 : (i : ι) → NormedAddCommGroup (E i)]
{f : X → PiLp q E}, MeasureTheory.MemLp f p μ ↔ ∀ (i : ι), MeasureTheory.MemLp (fun x => (f x).ofLp i) p ... | null | true |
IndepMatroid | Mathlib.Combinatorics.Matroid.IndepAxioms | Type u_2 → Type u_2 | A matroid as defined by a ground set and an independence predicate.
This definition is an implementation detail whose purpose is to organize the multiple
different versions of the independence axioms;
usually, terms of type `IndepMatroid` should either be directly piped into `IndepMatroid.matroid`,
or should be constru... | true |
ConnectedComponents.equivOfIsClopenOfIsConnected_mk | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α] {ι : Type u_3} {U : ι → Set α} (hclopen : ∀ (i : ι), IsClopen (U i))
(hdisj : Pairwise (Function.onFun Disjoint U)) (hunion : ⋃ i, U i = Set.univ) (hconn : ∀ (i : ι), IsConnected (U i))
{i : ι},
∀ x ∈ U i,
(ConnectedComponents.equivOfIsClopenOfIsConnected hclopen hdi... | null | true |
ModuleCat.MonModuleEquivalenceAlgebra.inverse_map_hom | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u} [inst : CommRing R] {X Y : AlgCat R} (f : X ⟶ Y),
(ModuleCat.MonModuleEquivalenceAlgebra.inverse.map f).hom = ModuleCat.ofHom (AlgCat.Hom.hom f).toLinearMap | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.EncodedQueryString.mk.inj | Std.Http.Data.URI.Encoding | ∀ {r : UInt8 → Bool} {toByteArray : ByteArray} {valid : Std.Http.URI.IsAllowedEncodedQueryChars r toByteArray}
{toByteArray_1 : ByteArray} {valid_1 : Std.Http.URI.IsAllowedEncodedQueryChars r toByteArray_1},
{ toByteArray := toByteArray, valid := valid } = { toByteArray := toByteArray_1, valid := valid_1 } →
to... | null | true |
Algebra.SubmersivePresentation.aeval_invJacobianOfHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (R₀ : Type u_5)
[inst_4 : CommRing R₀] [inst_5 : Algebra R₀ R] [inst_6 : Algebra R₀ S] [inst_7 : IsScalarTower R₀ R S]
[in... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.