name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.Echelon.BareissData.mk | Mathlib.Tactic.Echelon.Core | {V : Type} → Array (Array V) → Array (Array V) → Array (ℕ × ℕ) → Array ℕ → Mathlib.Tactic.Echelon.BareissData V | null | true |
Metric.AreSeparated.subset_compl_right | Mathlib.Topology.MetricSpace.MetricSeparated | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {s t : Set X}, Metric.AreSeparated s t → s ⊆ tᶜ | null | true |
Metric.PiNatEmbed.distDenseSeq | Mathlib.Topology.MetricSpace.PiNat | (X : Type u_3) → [inst : MetricSpace X] → [TopologicalSpace.SeparableSpace X] → ℕ → X → ↑unitInterval | Given a separable metric space `X`, `denseSeq X : ℕ → X` gives a countable
dense sequence. This measures the distance between `denseSeq X n` and `x`, truncated to the unit
interval `I` so that the distances remain bounded.
The function `(fun x n ↦ distDenseSeq n x) : X → ℕ → I` is a mapping from `X` to the Hilbert cub... | true |
Aesop.IndexingMode.hyps.inj | Aesop.Index.Basic | ∀ {keys keys_1 : Array Lean.Meta.DiscrTree.Key},
Aesop.IndexingMode.hyps keys = Aesop.IndexingMode.hyps keys_1 → keys = keys_1 | null | true |
Std.TreeMap.Raw.unitOfList_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {hd : α} {tl : List α},
Std.TreeMap.Raw.unitOfList (hd :: tl) cmp = (∅.insertIfNew hd ()).insertManyIfNewUnit tl | null | true |
Set.image_eq_range | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range fun x => f ↑x | null | true |
_private.Mathlib.Algebra.Order.AbsoluteValue.Basic.0.AbsoluteValue.nonpos_iff._simp_1_1 | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int64.reduceOfIntLE._regBuiltin.Int64.reduceOfIntLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.922157756._hygCtx._hyg.369 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
_private.Init.Data.List.Impl.0.List.filter.match_1.eq_1 | Init.Data.List.Impl | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | null | true |
Float.Model.UnpackedFloat.Accuracy.ctorIdx | Init.Data.Float.Model.Unpacked.Round | Float.Model.UnpackedFloat.Accuracy → ℕ | null | false |
IsCyclotomicExtension.fromZetaAut.eq_1 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] {L : Type u_2} {μ : L} [inst_2 : CommRing L]
[inst_3 : IsDomain L] (hμ : IsPrimitiveRoot μ n) [inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L]
(h : Irreducible (Polynomial.cyclotomic n K)),
IsCyclotomicExtension.fromZetaAut hμ h = (IsCyc... | null | true |
ImportGraph.Lean.instBEqImportRef | ImportGraph.Imports.Pretty | BEq ImportGraph.Lean.ImportRef | null | true |
Batteries.Tactic.GeneralizeProofs.AState.casesOn | Batteries.Tactic.GeneralizeProofs | {motive : Batteries.Tactic.GeneralizeProofs.AState → Sort u} →
(t : Batteries.Tactic.GeneralizeProofs.AState) →
((generalizations : Array (Lean.Expr × Lean.Expr)) →
(propToProof : Lean.ExprMap Lean.Expr) →
motive { generalizations := generalizations, propToProof := propToProof }) →
motive ... | null | false |
Polynomial.smeval_X_pow_mul._f | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Semiring R] (p : Polynomial R) {S : Type u_2} [inst_1 : NonAssocSemiring S]
[inst_2 : Module R S] [inst_3 : Pow S ℕ] (x : S) [NatPowAssoc S] [SMulCommClass R S S] (x_1 : ℕ) (f : Nat.below x_1),
(Polynomial.X ^ x_1 * p).smeval x = x ^ x_1 * p.smeval x | null | false |
Affine.Simplex.euclideanHausdorffMeasure_closedInterior_eq_one | Mathlib.Geometry.Euclidean.Volume.MeasureSimplex | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [inst_4 : MeasurableSpace P] [inst_5 : BorelSpace P] (s : Affine.Simplex ℝ P 0),
(MeasureTheory.Measure.euclideanHausdorffMeasure 0) s.closedInterior = 1 | null | true |
CategoryTheory.Square | Mathlib.CategoryTheory.Square | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max u v) | The category of commutative squares in a category. | true |
MulEquiv.mulDissociated_preimage._simp_2 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} {β : Type u_2} [inst : CommGroup α] [inst_1 : CommGroup β] {s : Set α} (e : β ≃* α),
MulDissociated (⇑e ⁻¹' s) = MulDissociated s | null | false |
_private.Mathlib.Data.Set.Function.0.Set.prod_surjOn_fst_iff._simp_1_3 | Mathlib.Data.Set.Function | ∀ {β₁ : Type u_7} {β₂ : Type u_8} {t₁ : Set β₁} {t₂ : Set β₂}, t₂.Nonempty → Set.SurjOn Prod.fst (t₁ ×ˢ t₂) t₁ = True | null | false |
Equiv.prodPProd_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₂ : Sort u_3} {β₂ : Sort u_6} {α₁ : Type u_9} {β₁ : Type u_10} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (a : α₁ × β₁),
(ea.prodPProd eb) a = ⟨ea a.1, eb a.2⟩ | null | true |
Std.IterM.Total.mk.injEq | Init.Data.Iterators.Consumers.Monadic.Total | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (it it_1 : Std.IterM m β),
({ it := it } = { it := it_1 }) = (it = it_1) | null | true |
CategoryTheory.WithTerminal.down_id | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
CategoryTheory.WithTerminal.down (CategoryTheory.CategoryStruct.id (CategoryTheory.WithTerminal.of X)) =
CategoryTheory.CategoryStruct.id X | null | true |
Nat.maxPrimeFac_zero | Mathlib.Data.Nat.MaxPrimeFac | Nat.maxPrimeFac 0 = 0 | null | true |
MvPowerSeries.Restricted.val_add | Mathlib.RingTheory.MvPowerSeries.Restricted | ∀ {R : Type u_1} [inst : NormedRing R] {σ : Type u_2} [inst_1 : IsUltrametricDist R] (c : σ → ℝ)
(f g : MvPowerSeries.Restricted R c), ↑(f + g) = ↑f + ↑g | null | true |
Lean.Lsp.instToJsonDocumentHighlightKind.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.DocumentHighlightKind → Sort u_1) →
(x : Lean.Lsp.DocumentHighlightKind) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.text) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.read) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.write) → motive x | null | false |
LinearMap.IsContPerfPair.casesOn | Mathlib.Topology.Algebra.Module.PerfectPairing | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommRing R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : TopologicalSpace M] →
[inst_5 : AddCommGroup N] →
[inst_6 : Mod... | null | false |
HasDerivWithinAt.fun_finset_prod | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι]
{𝔸' : Type u_3} [inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'}
{f' : ι → 𝔸'},
(∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) →
HasDerivWithinAt (fu... | **Alias** of `HasDerivWithinAt.fun_finsetProd`. | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.addDocString._regBuiltin.Lean.Parser.Command.addDocString.declRange_5 | Lean.Parser.Command | IO Unit | null | false |
Substring.Raw.next | Init.Data.String.Substring | Substring.Raw → String.Pos.Raw → String.Pos.Raw | Returns the next position in a substring after the given position. If the position is at the end of
the substring, it is returned unmodified.
Both the input position and the returned position are interpreted relative to the substring's start
position, not the underlying string.
| true |
_private.Mathlib.Topology.Compactness.CountablyCompact.0.isCountablyCompact_iff_countable_open_cover._simp_1_1 | Mathlib.Topology.Compactness.CountablyCompact | ∀ {X : Type u} [inst : TopologicalSpace X] {ι : Type u_3} [inst_1 : Preorder ι] [IsDirectedOrder ι] [Nonempty ι]
{x : ι → X} {a : X}, MapClusterPt a Filter.atTop x = ∀ (i : ι), a ∈ closure (x '' Set.Ici i) | null | false |
FirstOrder.Language.Theory.Imp | Mathlib.ModelTheory.Equivalence | {L : FirstOrder.Language} → {α : Type w} → {n : ℕ} → L.Theory → L.BoundedFormula α n → L.BoundedFormula α n → Prop | `φ ⟹[T] ψ` indicates that `φ` implies `ψ` in models of `T`. | true |
IsCoveringMap.fundamentalGroupMulAction._proof_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_2} {X : Type u_1} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X}
(cov : IsCoveringMap p) (x : X) (x_1 x_2 : FundamentalGroup X x) (x_3 : ↑(p ⁻¹' {x})),
cov.monodromy (Path.Homotopic.Quotient.trans x_2.asHom x_1.asHom) x_3 =
cov.monodromy x_1.asHom (cov.monodromy x_2.asHom x_... | null | false |
List.sublist_append_of_sublist_right._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l l₂ l₁ : List α}, l.Sublist l₂ → l.Sublist (l₁ ++ l₂) = True | null | false |
CommRingCat.commRingObj._proof_23 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommRingCat) (j : J),
autoParam (∀ (n : ℕ) (x : (F.comp (CategoryTheory.forget CommRingCat)).obj j), x ^ (n + 1) = x ^ n * x)
Monoid.npow_succ._autoParam | null | false |
spectrum.pow_norm_pow_one_div_tendsto_nhds_spectralRadius | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_2} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] [CompleteSpace A] (a : A),
Filter.Tendsto (fun n => ENNReal.ofReal (‖a ^ n‖ ^ (1 / ↑n))) Filter.atTop (nhds (spectralRadius ℂ a)) | **Gelfand's formula**: Given an element `a : A` of a complex Banach algebra, the
`spectralRadius` of `a` is the limit of the sequence `‖a ^ n‖₊ ^ (1 / n)`. | true |
Set.centralizer_empty | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M], ∅.centralizer = ⊤ | null | true |
HomologicalComplex.xPrevIso.eq_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.xPrevIso r = CategoryTheory.eqToIso ⋯ | null | true |
MvPolynomial | Mathlib.Algebra.MvPolynomial.Basic | Type u_1 → (R : Type u_2) → [CommSemiring R] → Type (max u_2 u_1) | Multivariate polynomial, where `σ` is the index set of the variables and
`R` is the coefficient ring | true |
Quot.lift | Init.Prelude | {α : Sort u} → {r : α → α → Prop} → {β : Sort v} → (f : α → β) → (∀ (a b : α), r a b → f a = f b) → Quot r → β | Lifts a function from an underlying type to a function on a quotient, requiring that it respects the
quotient's relation.
Given a relation `r : α → α → Prop` and a quotient `Quot r`, applying a function `f : α → β`
requires a proof `a` that `f` respects `r`. In this case, `Quot.lift f a : Quot r → β` computes the
same... | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.liftCochain_v_descCochain_v._proof_1_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {n m n' m' : ℤ},
n + 1 = m → m' + 1 = n' → ∀ (p₁ p₂ p₃ : ℤ), p₁ + n = p₂ → p₂ + n' = p₃ → ∀ (q : ℤ), p₁ + m = q → q + m' = p₃ | null | false |
CategoryTheory.Span.SpanBicat.associator_inv_hom_πₗ_πᵣ | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | true |
ISize.ofInt_neg | Init.Data.SInt.Lemmas | ∀ (a : ℤ), ISize.ofInt (-a) = -ISize.ofInt a | null | true |
Lean.Compiler.LCNF.LetValue.pap.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fn : Lean.Name} →
{args : Array (Lean.Compiler.LCNF.Arg pu)} →
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15} →
{fn' : Lean.Name} →
{args' : Array (Lean.Compiler.LCNF.Arg pu)} →
... | null | false |
ProbabilityTheory.integral_binomial | Mathlib.Probability.Distributions.Binomial | ∀ {n : ℕ} {p : ↑unitInterval} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E]
(f : ℕ → E),
∫ (x : ℕ), f x ∂ProbabilityTheory.binomial n p = ∑ k ≤ n, (↑(n.choose k) * ↑p ^ k * (1 - ↑p) ^ (n - k)) • f k | null | true |
Lean.Parser.Term.doLoopInvariant.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | null | true |
List.maxOn?_id | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} [inst : Max α] [inst_1 : LE α] [inst_2 : DecidableLE α] [Std.LawfulOrderLeftLeaningMax α]
{xs : List α}, List.maxOn? id xs = xs.max? | null | true |
TopCat.instFaithfulUliftFunctor | Mathlib.Topology.Category.TopCat.ULift | TopCat.uliftFunctor.Faithful | null | true |
ZMod.AddAutEquivUnits._proof_2 | Mathlib.Data.ZMod.Aut | ∀ (n : ℕ), IsDedekindFiniteMonoid (ZMod n) | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.withRestoreOrSaveFull.match_1 | Lean.Elab.Term.TermElabM | (motive :
Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot)) →
Sort u_1) →
(x : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))) →
((old : Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask ... | null | false |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.Recv.responseBody | Std.Http.Server.Connection | {β : Type} → Option Std.Http.Chunk → Std.Http.Server.Connection.Recv✝ β | null | true |
MeasureTheory.SignedMeasure.im_toComplexMeasure | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (s t : MeasureTheory.SignedMeasure α),
MeasureTheory.ComplexMeasure.im (s.toComplexMeasure t) = t | null | true |
LatticeHom.dual._proof_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β],
Function.LeftInverse (fun f => { toSupHom := SupHom.dual.symm f.toInfHom, map_inf' := ⋯ }) fun f =>
{ toSupHom := InfHom.dual f.toInfHom, map_inf' := ⋯ } | null | false |
Filter.EventuallyEmptyOrUniv.mulIndicator_const_iff._simp_2 | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : One β] {s : Set α} {c : β},
Filter.EventuallyConst (s.mulIndicator fun x => c) l = (c = 1 ∨ Filter.EventuallyEmptyOrUniv s l) | null | false |
instBEqAlignment | Mathlib.Util.FormatTable | BEq Alignment | null | true |
Polynomial.support_C | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {a : R}, a ≠ 0 → (Polynomial.C a).support = {0} | null | true |
CategoryTheory.unmop_comp | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp f g).unmop = CategoryTheory.CategoryStruct.comp f.unmop g.unmop | null | true |
CategoryTheory.Localization.instLifting₃Lift₃ | Mathlib.CategoryTheory.Localization.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{D₁ : Type u_6} →
{D₂ : Type u_7} →
{D₃ : Type u_8} →
{E : Type u_13} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[ins... | null | true |
Std.ExtDTreeMap.Const.insertManyIfNewUnit_cons | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k : α},
Std.ExtDTreeMap.Const.insertManyIfNewUnit t (k :: l) =
Std.ExtDTreeMap.Const.insertManyIfNewUnit (t.insertIfNew k ()) l | null | true |
Sym2.Mem.decidable._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x a b : α), Subsingleton (Decidable (x ∈ s(a, b))) | null | false |
Lean.Order.FlatOrder.rel.rec | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {motive : (x y : Lean.Order.FlatOrder b) → x.rel y → Prop},
(∀ {x : Lean.Order.FlatOrder b}, motive b x ⋯) →
(∀ {x : Lean.Order.FlatOrder b}, motive x x ⋯) → ∀ {x y : Lean.Order.FlatOrder b} (t : x.rel y), motive x y t | null | false |
PiTensorProduct.instAddCommGroup | Mathlib.LinearAlgebra.PiTensorProduct.Basic | {ι : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
{s : ι → Type u_3} →
[inst_1 : (i : ι) → AddCommGroup (s i)] →
[inst_2 : (i : ι) → Module R (s i)] → AddCommGroup (PiTensorProduct R fun i => s i) | Unlike for the binary tensor product, we require `R` to be a `CommRing` here, otherwise
this is false in the case where `ι` is empty. | true |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.lineCommentPosition? | Lean.Server.FileWorker.SignatureHelp | (s : String) → Option s.Pos | null | true |
CategoryTheory.MorphismProperty.Comma.mapRight | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(L : CategoryTheory.Functor A T) →
{P : CategoryTheory.MorphismPr... | A natural transformation `R₁ ⟶ R₂` induces a functor `P.Comma L R₁ Q W ⥤ P.Comma L R₂ Q W`. | true |
TopologicalSpace.PositiveCompacts.coe_toCompacts | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.PositiveCompacts α), ↑s.toCompacts = ↑s | null | true |
SSet.Subcomplex.Pairing.RankFunction.sigmaHorn | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} → {ι : Type v} → [inst : LinearOrder ι] → P.RankFunction ι → [P.IsProper] → ι → SSet | Given a rank function for a proper pairing of a subcomplex of a
simplicial set, this is the coproduct of the horns corresponding to
all cells of rank `j`. | true |
PerfectClosure.instCommRing._proof_13 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(e f g : PerfectClosure K p), e * (f + g) = e * f + e * g | null | false |
Sum.elimZeroLeft | Mathlib.Algebra.Module.LinearMap.Basic | {ι : Type u_6} → {κ : Type u_7} → {R : Type u_8} → [inst : Semiring R] → (ι → R) →ₗ[R] κ ⊕ ι → R | The map `Sum.elim` specialised with zero in the first argument, as a linear map. | true |
Filter.seq_eq_filter_seq | Mathlib.Order.Filter.Map | ∀ {α β : Type u} (f : Filter (α → β)) (g : Filter α), f <*> g = f.seq g | null | true |
Fin2.last._unsafe_rec | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 (n + 1) | null | false |
MeasureTheory.eLpNorm_count_lt_top | Mathlib.MeasureTheory.Function.LpSeminorm.Count | ∀ {α : Type u_1} {ε : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : α → ε} {p : ENNReal} [Finite α],
p ≠ 0 → (MeasureTheory.eLpNorm f p MeasureTheory.Measure.count < ⊤ ↔ ∀ (i : α), ‖f i‖ₑ < ⊤) | null | true |
CategoryTheory.SmallObject.SuccStruct.iterationFunctor | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.SmallObject.SuccStruct C →
(J : Type w) →
[inst_1 : LinearOrder J] →
[OrderBot J] →
[SuccOrder J] →
[WellFoundedLT J] → [CategoryTheory.Limits.HasIterationOfShape J C] → CategoryTheory.Funct... | Given `Φ : SuccStruct C` and a well-ordered type `J`, this
is the functor `J ⥤ C` which gives the iterations of `Φ` indexed by `J`. | true |
WellFoundedLT.conditionallyCompleteLinearOrderBot._proof_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [i₁ : LinearOrder α] [WellFoundedLT α] (s : Set α), s.Nonempty → WellFoundedLT α | null | false |
Lean.Compiler.LCNF.PullLetDecls.withNewScope | Lean.Compiler.LCNF.PullLetDecls | {α : Type} → Lean.Compiler.LCNF.PullLetDecls.PullM α → Lean.Compiler.LCNF.PullLetDecls.PullM α | null | true |
WithCStarModule.zero_fst | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_3} {F : Type u_4} [inst : AddCommGroup E] [inst_1 : AddCommGroup F], 0.1 = 0 | null | true |
Partition.instSemilatticeInf._proof_10 | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} [inst : Order.Frame α] (s : α) (P Q : Partition s), sSup {a | ∃ p ∈ P, ∃ q ∈ Q, a = p ⊓ q} = s | null | false |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_38 | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 : Turing.ToPartrec.Code), ¬a.case a_1 = Turing.ToPartrec.Code.succ | null | false |
NonUnitalSubsemiring.center.instNonUnitalCommSemiring._proof_4 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocSemiring R] (a : ↥(NonUnitalSubsemiring.center R)), a * 0 = 0 | null | false |
Equiv.symm_comp_eq | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : γ → α) (g : γ → β), ⇑e.symm ∘ g = f ↔ g = ⇑e ∘ f | null | true |
AlgEquiv.map_mul' | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (self : A ≃ₐ[R] B) (x y : A),
self.toFun (x * y) = self.toFun x * self.toFun y | The proposition that the function preserves multiplication | true |
HasProd.sum | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_4} {β : Type u_5} {M : Type u_6} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] [ContinuousMul M]
{f : α ⊕ β → M} {a b : M}, HasProd (f ∘ Sum.inl) a → HasProd (f ∘ Sum.inr) b → HasProd f (a * b) | null | true |
Equiv.Perm.SameCycle.of_zpow_right | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}, f.SameCycle x ((f ^ n) y) → f.SameCycle x y | **Alias** of the forward direction of `Equiv.Perm.sameCycle_zpow_right`. | true |
WithLp.instProdT0Space | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [T0Space α]
[T0Space β], T0Space (WithLp p (α × β)) | null | true |
ContinuousLinearMap.opNorm_le_iff_lipschitzWith | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] {f : ... | null | true |
Polynomial.natSepDegree_X_sub_C_pow | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} [inst : Field F] {x : F} {n : ℕ},
((Polynomial.X - Polynomial.C x) ^ n).natSepDegree = if n = 0 then 0 else 1 | null | true |
List.head?_dropWhile_not.match_1 | Init.Data.List.TakeDrop | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive x | null | false |
CategoryTheory.Pseudofunctor.DescentData.Hom.noConfusionType | Mathlib.CategoryTheory.Sites.Descent.DescentData | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{D₁ D₂ : F.DescentDa... | null | false |
AddMonoidAlgebra.singleAddHom_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] (m : M) (r : R),
(AddMonoidAlgebra.singleAddHom m) r = AddMonoidAlgebra.single m r | null | true |
Relation.SymmGen.trans_antisymmRel | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b c : α} [inst : Preorder α],
Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a b →
AntisymmRel (fun x1 x2 => x1 ≤ x2) b c → Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a c | **Alias** of `Relation.SymmGen.of_symmGen_of_antisymmRel`. | true |
ContinuousLinearMap.hasMFDerivAt | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(f : E →L[𝕜] E') {x : E}, HasMFDerivAt% (⇑f) x f | null | true |
SSet.Truncated.FundamentalGroupoid.mk_surjective | Mathlib.AlgebraicTopology.SimplicialSet.FundamentalGroupoid.Basic | ∀ {X : SSet.Truncated 2}, Function.Surjective SSet.Truncated.FundamentalGroupoid.mk | null | true |
Std.Tactic.BVDecide.BVExpr.eval_const | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {w : ℕ} {val : BitVec w},
Std.Tactic.BVDecide.BVExpr.eval assign (Std.Tactic.BVDecide.BVExpr.const val) = val | null | true |
CategoryTheory.ObjectProperty.limitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {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)] (X : C), P X → P.limitsClosure J X | null | true |
zero_lt_one | Mathlib.Algebra.Order.ZeroLEOne | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1], 0 < 1 | See `zero_lt_one'` for a version with the type explicit. | true |
AddCircle.openPartialHomeomorphCoe._proof_10 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] [IsOrderedAddMonoid 𝕜] (a : 𝕜)
[inst_3 : TopologicalSpace 𝕜] [OrderTopology 𝕜] [DiscreteTopology ↥(AddSubgroup.zmultiples p)], IsOpen {↑a}ᶜ | null | false |
TensorProduct.AlgebraTensorModule.homTensorHomMap | Mathlib.LinearAlgebra.TensorProduct.Tower | (R : Type uR) →
(A : Type uA) →
(B : Type uB) →
(M : Type uM) →
(N : Type uN) →
(P : Type uP) →
(Q : Type uQ) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →... | Heterobasic version of `TensorProduct.homTensorHomMap` | true |
AlgebraicGeometry.IsLocalIso.eq_iInf | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | @AlgebraicGeometry.IsLocalIso = ⨅ P, ⨅ (_ : P.ContainsIdentities), ⨅ (_ : AlgebraicGeometry.IsZariskiLocalAtSource P), P | `IsLocalIso` is the weakest source-Zariski-local property containing identities. | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_eq_prod_roots_sub._simp_1_3 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R}, q.Monic → (p %ₘ q = 0) = (q ∣ p) | null | false |
SSet.PtSimplex.MulStruct.δ_castSucc_castSucc_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) self.map = g.map | null | true |
Std.instNonemptySync_1 | Std.Sync.Channel | ∀ {α : Type}, Nonempty (Std.Channel.Sync α) | null | true |
Polynomial.fiberEquivQuotient | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(f : Polynomial R →ₐ[R] S) →
Function.Surjective ⇑f →
(p : Ideal R) →
[inst_3 : p.IsPrime] →
p.Fiber S ≃ₐ[p.ResidueField]
... | `κ(p) ⊗[R] (R[X] ⧸ I) = κ(p)[X] / I` | true |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_2 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.