name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DFinsupp.equivFunOnFintype_symm_coe | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : Fintype ι] (f : Π₀ (i : ι), β i),
DFinsupp.equivFunOnFintype.symm ⇑f = f | null | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.derivative_mul._proof_1_1 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} [inst : Semiring R] (a b : R) (m n : ℕ),
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1) - 1)) (a * (b * ↑(n + 1))) =
(Polynomial.monomial (m + 1 - 1 + (n + 1))) (a * (b * ↑(m + 1))) +
(Polynomial.monomial (m + 1 + (n + 1 - 1)))... | null | false |
_private.Mathlib.Algebra.Order.Ring.Ordering.Basic.0.RingPreordering.supportAddSubgroup_eq_bot._simp_1_1 | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} {x : R}, (x ∈ P.supportAddSubgroup) = (x ∈ P ∧ -x ∈ P) | null | false |
MeasureTheory.LocallyIntegrable | Mathlib.MeasureTheory.Function.LocallyIntegrable | {X : Type u_1} →
{ε : Type u_3} →
[inst : MeasurableSpace X] →
[TopologicalSpace X] →
[inst_2 : TopologicalSpace ε] →
[ContinuousENorm ε] →
(X → ε) → autoParam (MeasureTheory.Measure X) MeasureTheory.LocallyIntegrable._auto_1 → Prop | A function `f : X → ε` is *locally integrable* if it is integrable on a neighborhood of every
point. In particular, it is integrable on all compact sets,
see `LocallyIntegrable.integrableOn_isCompact`. | true |
IsAlgebraic.nontrivial | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsAlgebraic R a → Nontrivial R | null | true |
CategoryTheory.Limits.preservesFiniteLimits_of_op | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesFiniteColimits F.op],
CategoryTheory.Limits.PreservesFiniteLimits F | If `F.op : Cᵒᵖ ⥤ Dᵒᵖ` preserves finite colimits, then `F : C ⥤ D` preserves finite limits. | true |
IsLocalization.AtPrime.inertiaDeg_map_eq_inertiaDeg | Mathlib.RingTheory.Localization.AtPrime.Extension | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
[inst_3 : p.IsPrime] (Rₚ : Type u_3) [inst_4 : CommRing Rₚ] [inst_5 : Algebra R Rₚ] [IsLocalization.AtPrime Rₚ p]
[inst_7 : IsLocalRing Rₚ] (Sₚ : Type u_4) [inst_8 : CommRing Sₚ] [inst_9 : Algebra S Sₚ]
... | null | true |
sdiff_right_inj | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], x ≤ z → y ≤ z → (z \ x = z \ y ↔ x = y) | null | true |
Lean.Elab.SyntaxDeprecationEntry.ctorIdx | Lean.Elab.DeprecatedSyntax | Lean.Elab.SyntaxDeprecationEntry → ℕ | null | false |
Lean._aux_Lean_Message___macroRules_Lean_termM!__1 | Lean.Message | Lean.Macro | null | false |
CategoryTheory.Preadditive.isSeparator_iff | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsSeparator G ↔
∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (h : G ⟶ X), CategoryTheory.CategoryStruct.comp h f = 0) → f = 0 | null | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable.0.hasSum_nat_jacobiTheta._simp_1_3 | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
List.insert_replicate_self | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α},
0 < n → List.insert a (List.replicate n a) = List.replicate n a | null | true |
_private.Mathlib.NumberTheory.SumPrimeReciprocals.0.ite_prime_eq_mulIndicator | Mathlib.NumberTheory.SumPrimeReciprocals | ∀ {M : Type u_1} [inst : CommMonoid M] (f : ℕ → M),
(fun n => if Nat.Prime n then f n else 1) = {n | Nat.Prime n}.mulIndicator f | null | true |
Polynomial.hasStrictDerivAt | Mathlib.Analysis.Calculus.Deriv.Polynomial | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (p : Polynomial 𝕜) (x : 𝕜),
HasStrictDerivAt (fun x => Polynomial.eval x p) (Polynomial.eval x (Polynomial.derivative p)) x | The derivative (in the analysis sense) of a polynomial `p` is given by `p.derivative`. | true |
AlgHom.toOpposite._proof_2 | Mathlib.Algebra.Algebra.Opposite | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : ∀ (x y : A), Commute (f x) (f y)) (x y : A),
(↑↑(f.toOpposite hf)).toFun (x * y) = (↑↑(f.toOpposite hf)).toFun x * (↑↑(f.toOpposite h... | null | false |
CategoryTheory.SingleFunctors.map_lift_shiftIso_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctorsLift | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{u_7, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] [inst_2 : CategoryTheory.Category.{u_5, u_3} E] {A : Type u_4}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | true |
Subtype.instTotalLE | Init.Data.Subtype.Order | ∀ {α : Type u} [inst : LE α] [i : Std.Total fun x1 x2 => x1 ≤ x2] {P : α → Prop}, Std.Total fun x1 x2 => x1 ≤ x2 | null | true |
InverseSystem.piSplitLE._proof_14 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} {i : ι} [inst : PartialOrder ι], i ≤ i | null | false |
InnerProductSpace.toDual_apply_eq_toDualMap_apply | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (x : E), (InnerProductSpace.toDual 𝕜 E) x = (InnerProductSpace.toDualMap 𝕜 E) x | null | true |
SimpleGraph.Subgraph.coeCopy | Mathlib.Combinatorics.SimpleGraph.Copy | {V : Type u_1} → {G : SimpleGraph V} → (G' : G.Subgraph) → G'.coe.Copy G | A `Subgraph G` gives rise to a copy from the coercion to `G`. | true |
isLUB_setOfPred_le_and_isCompactElement | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : Preorder α] (a : α) [IsCompactlyGenerated α], IsLUB {x | x ≤ a ∧ IsCompactElement x} a | null | true |
SimpleGraph.map_neighborFinset_induce_of_neighborSet_subset | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {s : Set V} [inst : DecidablePred fun x => x ∈ s] [inst_1 : Fintype V] {G : SimpleGraph V}
[inst_2 : DecidableRel G.Adj] {v : ↑s},
G.neighborSet ↑v ⊆ s →
Finset.map (Function.Embedding.subtype fun x => x ∈ s) ((SimpleGraph.induce s G).neighborFinset v) =
G.neighborFinset ↑v | null | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.isProofOrDecidableQuick.match_4 | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (lvls : List Lean.Level) → motive (Lean.Expr.const declName lvls)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
Polynomial.eraseLead_monomial | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] (i : ℕ) (r : R), ((Polynomial.monomial i) r).eraseLead = 0 | null | true |
AddSemiconjBy.unop | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {a x y : αᵃᵒᵖ},
AddSemiconjBy a x y → AddSemiconjBy (AddOpposite.unop a) (AddOpposite.unop y) (AddOpposite.unop x) | null | true |
Equiv.sigmaSumDistrib_apply | Mathlib.Logic.Equiv.Sum | ∀ {ι : Type u_11} (α : ι → Type u_9) (β : ι → Type u_10) (p : (i : ι) × (α i ⊕ β i)),
(Equiv.sigmaSumDistrib α β) p = Sum.map (Sigma.mk p.fst) (Sigma.mk p.fst) p.snd | null | true |
Num.mod.eq_3 | Mathlib.Data.Num.ZNum | ∀ (a b : PosNum), (Num.pos a).mod (Num.pos b) = a.mod' b | null | true |
CategoryTheory.Limits.prod.map_mono | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z)
[CategoryTheory.Mono f] [CategoryTheory.Mono g] [inst_3 : CategoryTheory.Limits.HasBinaryProduct W X]
[inst_4 : CategoryTheory.Limits.HasBinaryProduct Y Z], CategoryTheory.Mono (CategoryTheory.Limits.prod.map f g) | null | true |
List.step_iter_cons | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {x : β} {xs : List β}, (x :: xs).iter.step = ⟨Std.IterStep.yield xs.iter x, ⋯⟩ | null | true |
CategoryTheory.Square.toArrowArrowFunctor._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.Square C} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.homMk φ.τ₁ φ.τ₃ ⋯)
(CategoryTheory.Arrow.mk (CategoryTheory.Arrow.homMk Y.f₁₂ Y.f₃₄ ⋯)).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | false |
tacticSimp_wf | Init.WFTactics | Lean.ParserDescr | Unfold definitions commonly used in well founded relation definitions.
Since Lean 4.12, Lean unfolds these definitions automatically before presenting the goal to the
user, and this tactic should no longer be necessary. Calls to `simp_wf` can be removed or replaced
by plain calls to `simp`.
| true |
preservesBinaryCoproducts_of_preservesInitial_and_pushouts | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasInitial C] [CategoryTheory.Limits.HasPushouts C]
[CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) F]
[... | A functor that preserves initial objects and pushouts preserves binary coproducts. | true |
Inclusion.ExprInclusion.mk.sizeOf_spec | Mathlib.Tactic.Inclusion.Core.Types | ∀ (inclusion proof : Lean.Expr), sizeOf { inclusion := inclusion, proof := proof } = 1 + sizeOf inclusion + sizeOf proof | null | true |
MeasureTheory.measureReal_union_null | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
μ.real s₁ = 0 → μ.real s₂ = 0 → μ.real (s₁ ∪ s₂) = 0 | null | true |
Polynomial.C_mul_X_pow_eq_monomial | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, Polynomial.C a * Polynomial.X ^ n = (Polynomial.monomial n) a | null | true |
LeanSearchClient.LoogleResult.noConfusionType | LeanSearchClient.LoogleSyntax | Sort u → LeanSearchClient.LoogleResult → LeanSearchClient.LoogleResult → Sort u | null | false |
MvPolynomial.isWeightedHomogeneous_X | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} [inst_1 : AddCommMonoid M] (w : σ → M) (i : σ),
MvPolynomial.IsWeightedHomogeneous w (MvPolynomial.X i) (w i) | An indeterminate `i : σ` is weighted homogeneous of degree `w i`. | true |
TopologicalLattice.rec | Mathlib.Topology.Order.Lattice | {L : Type u_1} →
[inst : TopologicalSpace L] →
[inst_1 : Lattice L] →
{motive : TopologicalLattice L → Sort u} →
([toContinuousInf : ContinuousInf L] → [toContinuousSup : ContinuousSup L] → motive ⋯) →
(t : TopologicalLattice L) → motive t | null | false |
MeasureTheory.FiniteMeasure.restrict_biUnion_finset | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] {ι : Type u_3} {μ : MeasureTheory.FiniteMeasure Ω} {T : Finset ι}
{s : ι → Set Ω},
(↑T).Pairwise (Function.onFun Disjoint s) →
(∀ (i : ι), MeasurableSet (s i)) → μ.restrict (⋃ i ∈ T, s i) = ∑ i ∈ T, μ.restrict (s i) | null | true |
FinEnum.instUInt64 | Mathlib.Data.FinEnum | FinEnum UInt64 | null | true |
Prod.mk_le_swap._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x : α × β} {a : α} {b : β},
((b, a) ≤ x.swap) = ((a, b) ≤ x) | null | false |
Similar.comp_left_iff | Mathlib.Topology.MetricSpace.Similarity | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {F : Type u_6}
[inst_3 : FunLike F P₁ P₃] [DilationClass F P₁ P₃] (f : F), Similar (⇑f ∘ v₁) v₂ ↔ Similar v₁ v₂ | null | true |
ImportGraph.Lean.Import.mkImportSuggestionMessage | ImportGraph.Imports.Pretty | Lean.Syntax →
Array Lean.Import →
Array (ImportGraph.Lean.ImportRef × ImportGraph.Lean.Import.Whitespace) →
optParam ImportGraph.Lean.Import.FormatBehavior ImportGraph.Lean.Import.FormatBehavior.grouped →
optParam (Option (String → String)) (some fun x => "Modify imports") →
optParam Bool ... | Create a message that suggests replacing `sourceImps` with `newImps`. Includes errors as a
comment. Returns `none` if the suggestion is would not modify the source at all (including
whitespace).
Note that the resulting widget will show a diff view if the resulting `errs : Import.FormatErrors`
satisfies `errs.isEmpty` ... | true |
List.set | Init.Prelude | {α : Type u_1} → List α → ℕ → α → List α | Replaces the value at (zero-based) index `n` in `l` with `a`. If the index is out of bounds, then
the list is returned unmodified.
Examples:
* `["water", "coffee", "soda", "juice"].set 1 "tea" = ["water", "tea", "soda", "juice"]`
* `["water", "coffee", "soda", "juice"].set 4 "tea" = ["water", "coffee", "soda", "juice"... | true |
DoResultPRBC.recOn | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) →
((a : α) → (a_1 : σ) → motive (DoResultPRBC.pure a a_1)) →
((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) →
((a : σ) → motive (DoResultPRBC.break a)) → ((a : σ) → motive (DoResultPRBC.conti... | null | false |
CondensedMod.ofSheafProfinite | Mathlib.Condensed.Explicit | (R : Type (u + 1)) →
[inst : Ring R] →
(F : CategoryTheory.Functor Profiniteᵒᵖ (ModuleCat R)) →
[CategoryTheory.Limits.PreservesFiniteProducts F] →
CategoryTheory.regularTopology.EqualizerCondition F → CondensedMod R | A `CondensedMod` version of `Condensed.ofSheafProfinite`. | true |
CategoryTheory.Limits.WalkingMultispan.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | Sort u →
{J : CategoryTheory.Limits.MultispanShape} →
{x x_1 : CategoryTheory.Limits.WalkingMultispan J} →
x.Hom x_1 →
{J' : CategoryTheory.Limits.MultispanShape} →
{x' x'_1 : CategoryTheory.Limits.WalkingMultispan J'} → x'.Hom x'_1 → Sort u | null | false |
CochainComplex.homologyMap_homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | null | false |
CommHopfAlgCat.Hom.mk.inj | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u} {inst : CommRing R} {A B : CommHopfAlgCat R} {hom' hom'_1 : ↑A →ₐc[R] ↑B},
{ hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | true |
lt_iff_le_and_ne' | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, b < a ↔ b ≤ a ∧ a ≠ b | null | true |
DFinsupp.wellFoundedLT | Mathlib.Data.DFinsupp.WellFounded | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → Zero (α i)] [inst_1 : (i : ι) → Preorder (α i)]
[∀ (i : ι), WellFoundedLT (α i)], (∀ ⦃i : ι⦄ ⦃a : α i⦄, ¬a < 0) → WellFoundedLT (Π₀ (i : ι), α i) | null | true |
CochainComplex.shiftFunctorZero'_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (n : ℤ) (h : n = 0)
(X : CochainComplex C ℤ) (i : ℤ),
((CochainComplex.shiftFunctorZero' C n h).inv.app X).f i = (HomologicalComplex.XIsoOfEq X ⋯).inv | null | true |
MulEquiv.submonoidCongr.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {S T : Submonoid M} (h : S = T),
MulEquiv.submonoidCongr h = { toEquiv := Set.equivOfEq ⋯, map_mul' := ⋯ } | null | true |
Rep.coinvariantsTensorIndHom.eq_1 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u} [inst : CommRing k] {G H : Type u} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u, u, u} k G) (B : Rep.{u, u, u} k H),
Rep.coinvariantsTensorIndHom φ A B =
ModuleCat.ofHom
(Representation.Coinvariants.lift
(((CategoryTheory.MonoidalCategory.curriedTensor (Rep.{u, u, ... | null | true |
CategoryTheory.MorphismProperty.Comma.Hom.noConfusionType | Mathlib.CategoryTheory.MorphismProperty.Comma | Sort u →
{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} →
{R : ... | null | false |
Std.DTreeMap.Internal.Impl.filterMap._proof_10 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | null | false |
_private.Mathlib.Topology.Category.Stonean.Basic.0.Stonean.epi_iff_surjective._simp_1_6 | Mathlib.Topology.Category.Stonean.Basic | ∀ {a : Prop}, (¬¬a) = a | null | false |
LinearIndependent.Maximal | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type w} →
{R : Type u} →
[inst : Semiring R] →
{M : Type v} → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {v : ι → M} → LinearIndependent R v → Prop | A linearly independent family is maximal if there is no strictly larger linearly independent family.
| true |
ValuativeRel.instOrderBotValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (t : ValuativeRel.ValueGroupWithZero R), ⊥ ≤ t | null | false |
Fin.snocOrderIso | Mathlib.Order.Fin.Tuple | {n : ℕ} →
(α : Fin (n + 1) → Type u_2) →
[inst : (i : Fin (n + 1)) → LE (α i)] → α (Fin.last n) × ((i : Fin n) → α i.castSucc) ≃o ((i : Fin (n + 1)) → α i) | Order isomorphism between tuples of length `n + 1` and pairs of an element and a tuple of length
`n` given by separating out the last element of the tuple.
This is `Fin.snoc` as an `OrderIso`. | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetQuotEquivAssociates._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K)),
x ≈ x_1 →
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x =
NumberField.mixedEmbedding.fundamentalCone.integerSetToAssociates K x_1 | null | false |
Mathlib.Tactic.Translate.elabArgStx | Mathlib.Tactic.Translate.Reorder | Lean.TSyntax [`ident, `num] → Array Lean.Name → Array Lean.Expr → Lean.MessageData → Lean.MetaM ℕ | Elaborate syntax that refers to an argument of a declaration or hypothesis.
This is either a 1-indexed number, or a name from `argNames`.
- `fvars` is only used to add hover information to `stx`
- `head` is only used for the error message. | true |
CategoryTheory.AddMonObj.ofIso | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M X : C} → [CategoryTheory.AddMonObj M] → (M ≅ X) → CategoryTheory.AddMonObj X | Transfer `AddMonObj` along an isomorphism. | true |
Filter.Realizer.rec | Mathlib.Data.Analysis.Filter | {α : Type u_1} →
{f : Filter α} →
{motive : f.Realizer → Sort u} →
((σ : Type u_5) → (F : CFilter (Set α) σ) → (eq : F.toFilter = f) → motive { σ := σ, F := F, eq := eq }) →
(t : f.Realizer) → motive t | null | false |
Lean.Meta.ParamInfo.isStrictImplicit | Lean.Meta.Basic | Lean.Meta.ParamInfo → Bool | null | true |
instSemilatticeSupPrimeMultiset._proof_5 | Mathlib.Data.PNat.Factors | ∀ (a : PrimeMultiset), a ≤ a | null | false |
MonoidWithZeroHom.instMul._proof_2 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} [inst : MulZeroOneClass α] {β : Type u_2} [inst_1 : CommMonoidWithZero β], MonoidHomClass (α →*₀ β) α β | null | false |
CategoryTheory.Limits.Cocone.extend_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) {X : C} (f : c.pt ⟶ X), (c.extend f).pt = X | null | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.isZero_of_isStrictlyLE._simp_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (p n : ℤ), (∀ (i : ℕ), (ComplexShape.embeddingUpIntLE p).f i ≠ n) = (p < n) | null | false |
inv_hausdorffEntourage | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} (U : SetRel α α), (hausdorffEntourage U).inv = hausdorffEntourage U.inv | null | true |
Vector.getElem?_set!_ne | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i j : ℕ} {xs : Vector α n} {x : α}, i ≠ j → (xs.set! i x)[j]? = xs[j]? | null | true |
Rat.inv_eq_of_mul_eq_one | Init.Data.Rat.Lemmas | ∀ {a b : ℚ}, a * b = 1 → a⁻¹ = b | null | true |
MvPolynomial.IsHomogeneous.neg | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {R : Type u_5} {σ : Type u_6} [inst : CommRing R] {φ : MvPolynomial σ R} {n : ℕ},
φ.IsHomogeneous n → (-φ).IsHomogeneous n | null | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Lean.Name.prefixToName | Mathlib.Tactic.Linter.DirectoryDependency | Lean.Name → Array Lean.Name → Option Lean.Name | Find a name in `ns` that starts with prefix `p`. | true |
CategoryTheory.effectiveEpiStructOfIsColimit.match_1 | Mathlib.CategoryTheory.Sites.EffectiveEpimorphic | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{X Y : C} →
(f : Y ⟶ X) →
(motive : (CategoryTheory.Sieve.generateSingleton f).arrows.category → Sort u_3) →
(x : (CategoryTheory.Sieve.generateSingleton f).arrows.category) →
((obj : CategoryTheory.Over X) →
... | null | false |
ISize.toBitVec64_minValue | Init.Data.SInt.IntToBitVec | ∀ (h : System.Platform.numBits = 64), ISize.minValue.toBitVec64 h = BitVec.intMin 64 | null | true |
IsField.toSemifield._proof_9 | Mathlib.Algebra.Field.IsField | ∀ {R : Type u_1} [inst : Semiring R] (h : IsField R), (if ha : 0 = 0 then 0 else Classical.choose ⋯) = 0 | null | false |
CategoryTheory.RetractArrow.unop_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : Cᵒᵖ} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g),
h.unop.i =
CategoryTheory.Arrow.homMk (CategoryTheory.Arrow.Hom.right h.r).unop (CategoryTheory.Arrow.Hom.left h.r).unop ⋯ | null | true |
Lean.Meta.Grind.addHypothesis | Lean.Meta.Tactic.Grind.Core | Lean.FVarId → optParam ℕ 0 → Lean.Meta.Grind.GoalM Unit | Adds a new hypothesis. | true |
Nat.mod_eq_of_modEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [MOD n] → b < n → a % n = b | null | true |
Nat.minFacAux | Mathlib.Data.Nat.Prime.Defs | ℕ → ℕ → ℕ | If `n < k * k`, then `minFacAux n k = n`, if `k | n`, then `minFacAux n k = k`.
Otherwise, `minFacAux n k = minFacAux n (k+2)` using well-founded recursion.
If `n` is odd and `1 < n`, then `minFacAux n 3` is the smallest prime factor of `n`.
This definition is by well-founded recursion, so `rfl` or `decide` cannot be ... | true |
CategoryTheory.Limits.WalkingParallelFamily.one.elim | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{motive : CategoryTheory.Limits.WalkingParallelFamily J → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelFamily J) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelFamily.one → motive t | null | false |
BoundedContinuousFunction.charAlgHom | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | {V : Type u_1} →
{W : Type u_2} →
[inst : AddCommGroup V] →
[inst_1 : Module ℝ V] →
[inst_2 : TopologicalSpace V] →
[inst_3 : AddCommGroup W] →
[inst_4 : Module ℝ W] →
[inst_5 : TopologicalSpace W] →
{e : AddChar ℝ Circle} →
{L : ... | Algebra homomorphism mapping `w` to `fun v ↦ e (L v w)`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
ClosureOperator.closure_sup_closure_left | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeSup α] (c : ClosureOperator α) (x y : α), c (c x ⊔ y) = c (x ⊔ y) | null | true |
Submodule.tensorToSpan._proof_2 | Mathlib.LinearAlgebra.Span.TensorProduct | ∀ (A : Type u_1) {M : Type u_2} [inst : CommSemiring A] [inst_1 : AddCommMonoid M] [inst_2 : Module A M],
IsScalarTower A A M | null | false |
CategoryTheory.Cokleisli.Adjunction.fromCokleisli_map | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Comonad C)
{X x : CategoryTheory.Cokleisli U} (f : X ⟶ x),
(CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).map f =
CategoryTheory.CategoryStruct.comp (U.δ.app X.of) (U.map f.of) | null | true |
Submonoid.unop_eq_bot | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {S : Submonoid Mᵐᵒᵖ}, S.unop = ⊥ ↔ S = ⊥ | null | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.arithmeticFolders._proof_32 | Lean.Compiler.LCNF.Simp.ConstantFold | ∀ (a : UInt64), a * 0 = 0 | null | false |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeChar._proof_2 | Batteries.Data.Fin.Coding | ∀ (val : UInt32) (valid : val.isValidChar),
¬{ val := val, valid := valid }.toNat < Char.minSurrogate →
{ val := val, valid := valid }.toNat - (57343 + 1 - 55296) < 1114111 - 57343 + 55296 | null | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_of_countable._proof_1_3 | Mathlib.Probability.ProductMeasure | ∀ {ι : Type u_1} {X : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (X i)},
s.pi t = s.pi fun i => if i ∈ s then t i else Set.univ | null | false |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.measureEntries._mutual | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(x :
(_ : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) ×' ℕ ⊕'
Lean.PersistentHashMap.Node α β) →
PSum.casesOn x (fun _x => ℕ) fun _x => ℕ | Counts the total entries in an entries array starting at index `i`. | false |
NNReal.coe_inv._simp_1 | Mathlib.Basic.NNReal.Defs | ∀ (r : NNReal), (↑r)⁻¹ = ↑r⁻¹ | null | false |
List.find?_eq_head?_dropWhile_not | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.find? p l = (List.dropWhile (fun x => !p x) l).head? | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabAnonymousCtor._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Turing.ToPartrec.Code.comp.injEq | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), (a.comp a_1 = a_2.comp a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
Lex.instNonAssocRing | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [NonAssocRing R] → NonAssocRing (Lex R) | null | true |
Topology.«_aux_Mathlib_Topology_Baire_BaireMeasurable___macroRules_Topology_term∀ᵇ_,__1» | Mathlib.Topology.Baire.BaireMeasurable | Lean.Macro | null | false |
HAnd.rec | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HAnd α β γ → Sort u_1} → ((hAnd : α → β → γ) → motive { hAnd := hAnd }) → (t : HAnd α β γ) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.