name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddLECancellable.tsub_mul | Mathlib.Algebra.Order.Ring.Canonical | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] [inst_1 : PartialOrder R] [CanonicallyOrderedAdd R] [inst_3 : Sub R]
[OrderedSub R] [Std.Total fun x1 x2 => x1 ≤ x2] [MulRightMono R] {a b c : R},
AddLECancellable (b * c) → (a - b) * c = a * c - b * c | null | true |
CategoryTheory.ObjectProperty.productTo | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) →
(X : C) → [inst_1 : CategoryTheory.Limits.HasProduct (P.productToFamily X)] → X ⟶ ∏ᶜ P.productToFamily X | Given `P : ObjectProperty C` and `X : C`, this is the product of
all the morphisms `X ⟶ Y` such that `P Y` holds. | true |
Std.Tactic.BVDecide.Normalize.BitVec.ult_max' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), a.ult (-1#w) = !a == -1#w | null | true |
Finset.zero_mem_neg_add_iff._simp_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddGroup α] {s t : Finset α}, (0 ∈ -t + s) = ¬Disjoint s t | null | false |
Nat.ppred | Mathlib.Data.Nat.PSub | ℕ → Option ℕ | Partial predecessor operation. Returns `ppred n = some m`
if `n = m + 1`, otherwise `none`. | true |
Polynomial.exists_mul_sq_add_linear_part_eq_eval_add | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : CommSemiring R] (p : Polynomial R) (x y : R),
∃ c, c * y ^ 2 + Polynomial.eval x (Polynomial.derivative p) * y + Polynomial.eval x p = Polynomial.eval (x + y) p | null | true |
BddDistLat.recOn | Mathlib.Order.Category.BddDistLat | {motive : BddDistLat → Sort u} →
(t : BddDistLat) →
((toDistLat : DistLat) →
[isBoundedOrder : BoundedOrder ↑toDistLat] →
motive { toDistLat := toDistLat, isBoundedOrder := isBoundedOrder }) →
motive t | null | false |
ContinuousLinearEquiv.arrowCongrEquiv._proof_4 | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_7} {R₂ : Type u_1} {R₃ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃]
{σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁} [inst_3 : RingHomInvPair σ₁₂ σ₂₁] [inst_4 : RingHomInvPair σ₂₁ σ₁₂]
{σ₂₃ : R₂ →+* R₃} {σ₁₃ : R₁ →+* R₃} [inst_5 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃] {M₁ : Type u_8}
... | null | false |
String.startsWith_slice_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String.Slice} {s : String}, s.startsWith pat = true ↔ pat.copy.toList <+: s.toList | null | true |
Submodule.coe_finsetInf | Mathlib.Algebra.Module.Submodule.Lattice | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
(s : Finset ι) (p : ι → Submodule R M), ↑(s.inf p) = ⋂ i ∈ s, ↑(p i) | null | true |
Matroid.Indep.mem_closure_iff' | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {I : Set α} {x : α},
M.Indep I → (x ∈ M.closure I ↔ x ∈ M.E ∧ (M.Indep (insert x I) → x ∈ I)) | null | true |
Matrix.instNonUnitalRing._proof_1 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : NonUnitalRing α] (a b : Matrix n n α), a - b = a + -b | null | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_7 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Finset.instLattice._proof_3 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (x x_1 x_2 : Finset α), x ≤ x_2 → x_1 ≤ x_2 → ∀ x_3 ∈ x ∪ x_1, x_3 ∈ x_2 | null | false |
intervalIntegrable_log_norm_meromorphicOn | Mathlib.Analysis.SpecialFunctions.Integrability.LogMeromorphic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E} {a b : ℝ},
MeromorphicOn f (Set.uIcc a b) → IntervalIntegrable (fun x => Real.log ‖f x‖) MeasureTheory.volume a b | **Alias** of `MeromorphicOn.intervalIntegrable_log_norm`.
---
If `f` is real-meromorphic on a compact interval, then `log ‖f ·‖` is interval integrable on this
interval.
| true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8.else_eq | Lean.Elab.DeclNameGen | ∀ {motive : Lean.Name → Sort u} (t : Lean.Name) (str : (pre : Lean.Name) → (str : String) → motive (pre.str str))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Command.NameGen.getParentProjArg._sparseCasesOn_8✝ t str «else» = «else» h | null | false |
VectorBundleCore.coordChange | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField R] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace R F] →
[inst_3 : TopologicalSpace B] → {ι : Type u_5} → VectorBundleCore R B F ι → ι → ι → B → F →L[R] F | null | true |
Lean.Elab.Structural.RecArgCandidates._sizeOf_1 | Lean.Elab.PreDefinition.Structural.FindRecArg | Lean.Elab.Structural.RecArgCandidates → ℕ | null | false |
LinearEquiv._sizeOf_inst | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_14} →
{S : Type u_15} →
{inst : Semiring R} →
{inst_1 : Semiring S} →
(σ : R →+* S) →
{σ' : S →+* R} →
{inst_2 : RingHomInvPair σ σ'} →
{inst_3 : RingHomInvPair σ' σ} →
(M : Type u_16) →
(M₂ : Type u_17) →
... | null | false |
Cycle.length_nil | Mathlib.Data.List.Cycle | ∀ {α : Type u_1}, Cycle.nil.length = 0 | null | true |
Lean.IR.CtorInfo.mk.inj | Lean.Compiler.IR.Basic | ∀ {name : Lean.Name} {cidx size usize ssize : ℕ} {name_1 : Lean.Name} {cidx_1 size_1 usize_1 ssize_1 : ℕ},
{ name := name, cidx := cidx, size := size, usize := usize, ssize := ssize } =
{ name := name_1, cidx := cidx_1, size := size_1, usize := usize_1, ssize := ssize_1 } →
name = name_1 ∧ cidx = cidx_1 ∧ s... | null | true |
CoxeterSystem.length_eq_one_iff | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W},
cs.length w = 1 ↔ ∃ i, w = cs.simple i | null | true |
Std.Internal.Do.WPMonad | Std.Internal.Do.WP.Basic | (m : Type u → Type v) →
(Pred : outParam (Type w)) →
(EPred : outParam (Type w')) →
[Monad m] →
[Std.Internal.Do.Assertion Pred] → [Std.Internal.Do.Assertion EPred] → Type (max (max (max (u + 1) v) w) w') | Weakest precondition monad: a monad `m` with a sound interpretation as predicate
transformers over assertion language `Pred` with exception postconditions `EPred`. | true |
Matrix.uniqueRingEquiv._proof_2 | Mathlib.LinearAlgebra.Matrix.Unique | ∀ {m : Type u_1} {A : Type u_2} [inst : Unique m] [inst_1 : NonUnitalNonAssocSemiring A] (x y : Matrix m m A),
Matrix.uniqueAddEquiv.toFun (x + y) = Matrix.uniqueAddEquiv.toFun x + Matrix.uniqueAddEquiv.toFun y | null | false |
Multiplicative.mulAction_isPretransitive | Mathlib.Algebra.Group.Action.Pretransitive | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid α] [inst_1 : AddAction α β] [AddAction.IsPretransitive α β],
MulAction.IsPretransitive (Multiplicative α) β | null | true |
LawfulMonadAttach.eq_of_canReturn_pure | Init.Control.Lawful.MonadAttach.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[LawfulMonadAttach m] {a b : α}, MonadAttach.CanReturn (pure a) b → a = b | null | true |
CochainComplex.homologyδOfTriangle._auto_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | Lean.Syntax | null | false |
MeasureTheory.integral_prod_swap | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[inst_4 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] (f : α × β → E),
∫ (z : β × α), f z.swap... | null | true |
Mathlib.Tactic.Linarith.Comp.scale | Mathlib.Tactic.Linarith.Datatypes | Mathlib.Tactic.Linarith.Comp → ℕ → Mathlib.Tactic.Linarith.Comp | `c.scale n` scales the coefficients of `c` by `n`. | true |
_private.Mathlib.Geometry.Manifold.ChartedSpace.0.ChartedSpace.t1Space._simp_1_1 | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Lean.ScopedEnvExtension.ScopedEntries.mk.injEq | Lean.ScopedEnvExtension | ∀ {β : Type} (map map_1 : Lean.SMap Lean.Name (Lean.PArray β)), ({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
mul_le_of_mul_le_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulLeftMono α] {a b c d : α}, a * b ≤ c → d ≤ b → a * d ≤ c | null | true |
SSet.anodyneExtensions.whiskerRight | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PushoutProduct | ∀ {X Y : SSet} {f : X ⟶ Y},
SSet.anodyneExtensions f →
∀ (Z : SSet), SSet.anodyneExtensions (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z) | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.reduce_fold_fn_preserves_induction_motive._simp_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
CategoryTheory.Functor.sheafPullbackConstruction.preservesFiniteLimits | Mathlib.CategoryTheory.Sites.Pullback | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
(G : CategoryTheory.Functor C D) (A : Type u₁) [inst_2 : CategoryTheory.Category.{v₁, u₁} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : G.IsC... | null | true |
div_div_eq_mul_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b / c) = a * c / b | null | true |
OrderIso.arrowCongr | Mathlib.Order.Hom.Basic | {α : Type u_6} →
{β : Type u_7} →
{γ : Type u_8} →
{δ : Type u_9} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : Preorder γ] → [inst_3 : Preorder δ] → α ≃o γ → β ≃o δ → (α →o β) ≃o (γ →o δ) | An order isomorphism between the domains and codomains of two prosets of
order homomorphisms gives an order isomorphism between the two function prosets. | true |
_private.Lean.Meta.Sorry.0.Lean.Meta.SorryLabelView.encode.match_1 | Lean.Meta.Sorry | (motive : Option Lean.DeclarationLocation → Sort u_1) →
(x : Option Lean.DeclarationLocation) →
((module : Lean.Name) →
(pos : Lean.Position) →
(charUtf16 : ℕ) →
(endPos : Lean.Position) →
(endCharUtf16 : ℕ) →
motive
(some
... | null | false |
HomogeneousSubsemiring.ext | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : AddMonoid ι] [inst_1 : Semiring A] [inst_2 : SetLike σ A]
[inst_3 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_4 : DecidableEq ι] [inst_5 : GradedRing 𝒜]
{R S : HomogeneousSubsemiring 𝒜}, R.toSubsemiring = S.toSubsemiring → R = S | null | true |
CategoryTheory.Limits.IsLimit.pushoutOfHasExactLimitsOfShape._proof_2 | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.Limits.HasPushouts C] {F : CategoryTheory.Functor J C}
{c : CategoryTheory.Limits.Cone F} {X : C} (f : c.pt ⟶ X),
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.sp... | null | false |
perfectClosure.eq_bot_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
perfectClosure F E = ⊥ | If `E / F` is separable, then the perfect closure of `F` in `E` is equal to `F`. Note that
the converse is not necessarily true (see https://math.stackexchange.com/a/3009197)
even when `E / F` is algebraic. | true |
Lean.Lsp.instHashableInsertReplaceEdit.hash | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.InsertReplaceEdit → UInt64 | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.IsBipartite.exists_isBipartiteWith._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Bipartite | NeZero (1 + 1) | null | false |
ContinuousLinearMap.flipMultilinearEquiv._proof_4 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) {ι : Type u_2} (E : ι → Type u_3) (G : Type u_5) (G' : Type u_4) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | null | false |
Std.Internal.List.getEntry?._sunfold | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → α → List ((a : α) × β a) → Option ((a : α) × β a) | null | false |
_private.Mathlib.GroupTheory.Submonoid.Inverses.0.Submonoid.leftInvEquiv._simp_2 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, (↑u⁻¹ = a) = (↑u * a = 1) | null | false |
Aesop.instInhabitedRuleTacDescr.default | Aesop.RuleTac.Descr | Aesop.RuleTacDescr | null | true |
Int.fib_neg_one | Mathlib.Data.Int.Fib.Basic | Int.fib (-1) = 1 | null | true |
Std.Internal.Do.EPost.cons._sizeOf_1 | Std.Internal.Do.ExceptPost | {eh : Type u} → {et : Type v} → [SizeOf eh] → [SizeOf et] → EPost.cons✝ eh et → ℕ | null | false |
MonadReader.casesOn | Init.Prelude | {ρ : Type u} →
{m : Type u → Type v} →
{motive : MonadReader ρ m → Sort u_1} → (t : MonadReader ρ m) → ((read : m ρ) → motive { read := read }) → motive t | null | false |
NumberField.instIsAlgebraicSubtypeMemSubfield | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K] [inst_1 : CharZero K] [Algebra.IsAlgebraic ℚ K] (k : Subfield K),
Algebra.IsAlgebraic (↥k) K | null | true |
MeasureTheory.setLIntegral_withDensity_eq_lintegral_mul₀ | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ {g : α → ENNReal},
AEMeasurable g μ →
∀ {s : Set α}, MeasurableSet s → ∫⁻ (a : α) in s, g a ∂μ.withDensity f = ∫⁻ (a : α) in s, (f * g) a ∂μ | null | true |
Set.graphOn_singleton | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x : α), Set.graphOn f {x} = {(x, f x)} | null | true |
cfcₙHomSuperset | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 :... | The composition of `cfcₙHom` with the natural embedding `C(s, R)₀ → C(quasispectrum R a, R)₀`
whenever `quasispectrum R a ⊆ s`.
This is sometimes necessary in order to consider the same continuous functions applied to multiple
distinct elements, with the added constraint that `cfcₙ` does not suffice. This can occur, f... | true |
String.Slice.copy_slice_eq_iff_splits | Init.Data.String.Lemmas.Splits | ∀ {t : String} {s : String.Slice} {pos₁ pos₂ : s.Pos},
(∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = t) ↔ ∃ t₁ t₂, pos₁.Splits t₁ (t ++ t₂) ∧ pos₂.Splits (t₁ ++ t) t₂ | null | true |
instInhabitedAsBoolRing | Mathlib.Algebra.Ring.BooleanRing | {α : Type u_1} → [Inhabited α] → Inhabited (AsBoolRing α) | null | true |
Fin.partialProd.eq_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : Monoid M] {n : ℕ} (f : Fin n → M) (i : Fin (n + 1)),
Fin.partialProd f i = (List.take (↑i) (List.ofFn f)).prod | null | true |
GenContFract.contsAux_eq_contsAux_squashGCF_of_le | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {g : GenContFract K} [inst : DivisionRing K] {m : ℕ},
m ≤ n → g.contsAux m = (g.squashGCF n).contsAux m | The auxiliary continuants before the squashed position stay the same. | true |
LinearIsometryEquiv.rTensor | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
(G : Type u_4) →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : InnerProductSpace 𝕜 F] →
... | This is the natural linear isometric equivalence induced by `f : E ≃ₗᵢ F`. | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.norm_intCast_eq_one_iff._simp_1_3 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {m n : ℤ}, IsCoprime m n = (m.gcd n = 1) | null | false |
Lean.Elab.Term.TacticMVarKind.autoParam.elim | Lean.Elab.Term.TermElabM | {motive : Lean.Elab.Term.TacticMVarKind → Sort u} →
(t : Lean.Elab.Term.TacticMVarKind) →
t.ctorIdx = 1 → ((argName : Lean.Name) → motive (Lean.Elab.Term.TacticMVarKind.autoParam argName)) → motive t | null | false |
Fin.rev_anti | Mathlib.Order.Fin.Basic | ∀ {n : ℕ}, Antitone Fin.rev | null | true |
mul_le_mul_left_of_neg._simp_1 | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulStrictMono R] [AddRightMono R]
[AddRightReflectLE R] {a b c : R}, c < 0 → (c * a ≤ c * b) = (b ≤ a) | null | false |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_3 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | null | false |
linearIndependent_fin_succ | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {n : ℕ}
{v : Fin (n + 1) → V},
LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ v 0 ∉ Submodule.span K (Set.range (Fin.tail v)) | **Alias** of `linearIndependent_finSucc`. | true |
Lean.Compiler.LCNF.Code.oset.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId : Lean.FVarId} →
{i : ℕ} →
{y : Lean.Compiler.LCNF.Arg pu} →
{k : Lean.Compiler.LCNF.Code pu} →
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_7} →
{fvarId' : Lean.FVarI... | null | false |
Lean.Meta.Grind.Arith.traceModel | Lean.Meta.Tactic.Grind.Arith.ModelUtil | Lean.Name → Array (Lean.Expr × ℚ) → Lean.MetaM Unit | If the given trace class is enabled, trace the model using the class. | true |
SSet.instIsStableUnderTransfiniteCompositionAnodyneExtensions._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | SSet.anodyneExtensions.IsStableUnderTransfiniteComposition | null | false |
Finset.max_abv_sum_one_le | Mathlib.NumberTheory.Height.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : CommSemiring S] [inst_2 : LinearOrder S] [IsOrderedRing S]
[CharZero S] (v : AbsoluteValue R S) {ι : Type u_3} {s : Finset ι},
s.Nonempty → ∀ (x : ι → R), max (v (∑ i ∈ s, x i)) 1 ≤ ↑s.card * ∏ i ∈ s, max (v (x i)) 1 | The "local" version of the height bound for arbitrary sums for general (possibly archimedean)
absolute values. | true |
_private.Mathlib.CategoryTheory.Monoidal.Multifunctor.0.CategoryTheory.MonoidalCategory.curriedTensorPreFunctor._simp_1 | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y₁ Y₂ : C} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f | null | false |
subset_affineSpan | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : Set P), s ⊆ ↑(affineSpan k s) | A set is contained in its affine span. | true |
MonotoneOn.convex_le | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : PartialOrder β] [inst_6 : Module 𝕜 E] [PosSMulMono 𝕜 E]
{s : Set E} {f : E → β}, MonotoneOn f s → Convex 𝕜 s → ∀ (r : β), Convex 𝕜 ... | null | true |
Submodule.equivOpposite._proof_5 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(x : (Submodule R A)ᵐᵒᵖ),
MulOpposite.op
(Submodule.comap (↑(MulOpposite.opLinearEquiv R))
(Submodule.comap (↑(MulOpposite.opLinearEquiv R).symm) (MulOpposite.unop x))) =
x | null | false |
Lean.ScopedEnvExtension.State.mk.injEq | Lean.ScopedEnvExtension | ∀ {σ : Type} (state : σ) (activeScopes : Lean.NameSet) (delimitsLocal : Bool) (state_1 : σ)
(activeScopes_1 : Lean.NameSet) (delimitsLocal_1 : Bool),
({ state := state, activeScopes := activeScopes, delimitsLocal := delimitsLocal } =
{ state := state_1, activeScopes := activeScopes_1, delimitsLocal := delimit... | null | true |
CategoryTheory.CommSq.rightAdjointLiftStructEquiv | Mathlib.CategoryTheory.LiftingProperties.Adjunction | {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] →
{G : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{A B : C} →
{X Y : D} →
{i : A ⟶ B} →
... | The liftings of a commutative are in bijection with the liftings of its (right)
adjoint square. | true |
_private.Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts.0.CategoryTheory.hasCoproduct_fin | Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C]
[CategoryTheory.Limits.HasInitial C] (n : ℕ) (f : Fin n → C), CategoryTheory.Limits.HasCoproduct f | If `C` has an initial object and binary coproducts, then it has a coproduct for objects indexed by
`Fin n`.
This is a helper lemma for `hasFiniteCoproducts_of_has_binary_and_initial`, which is more general
than this.
| true |
CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_π_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J) (k : K),
Catego... | null | true |
Lean.Parser.Command.structExplicitBinder | Lean.Parser.Command | Lean.Parser.Parser | null | true |
MeasureTheory.setLIntegral_measure_zero | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α) (f : α → ENNReal),
μ s = 0 → ∫⁻ (x : α) in s, f x ∂μ = 0 | null | true |
Std.ExtTreeMap.getKeyGE? | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → Option α | Tries to retrieve the smallest key that is greater than or equal to the
given key, returning `none` if no such key exists.
| true |
Lean.Meta.Contradiction.Config.emptyType | Lean.Meta.Tactic.Contradiction | Lean.Meta.Contradiction.Config → Bool | Check whether any of the hypotheses is an empty type. | true |
CoxeterSystem.length_wordProd_le | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B),
cs.length (cs.wordProd ω) ≤ ω.length | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Point___macroRules__private_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Point_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | Lean.Macro | null | false |
Pi.Colex.instCompleteLinearOrderColexForall._proof_10 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedGT ι] (a b : Colex ((i : ι) → α i)), Lattice.inf a b ≤ b | null | false |
ContinuousMap.HomotopyEquiv.prodCongr | Mathlib.Topology.Homotopy.Equiv | {X : Type u} →
{Y : Type v} →
{Z : Type w} →
{Z' : Type x} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
[inst_3 : TopologicalSpace Z'] →
ContinuousMap.HomotopyEquiv X Y →
Continuo... | If `X` is homotopy equivalent to `Y` and `Z` is homotopy equivalent to `Z'`, then `X × Z` is
homotopy equivalent to `Z × Z'`. | true |
MoritaEquivalence.mk.injEq | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} [inst : CommSemiring R] {A : Type u₁} [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u₂}
[inst_3 : Ring B] [inst_4 : Algebra R B] (eqv : ModuleCat A ≌ ModuleCat B)
(linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam)
(eqv_1 : ModuleCat A ≌ Modu... | null | true |
HomotopicalAlgebra.FibrantObject.homMk_id | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : C) [inst_3 : HomotopicalAlgebra.IsFibrant X],
HomotopicalAlgebra.FibrantObject.homMk (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryS... | null | true |
TopologicalSpace.UpgradedIsCompletelyMetrizableSpace.edist._inherited_default | Mathlib.Topology.Metrizable.CompletelyMetrizable | {X : Type u_3} →
(dist : X → X → ℝ) →
(∀ (x : X), dist x x = 0) →
(∀ (x y : X), dist x y = dist y x) → (∀ (x y z : X), dist x z ≤ dist x y + dist y z) → X → X → ENNReal | null | false |
_private.Mathlib.GroupTheory.Perm.Fin.0.Fin.cycleIcc_of_le_of_le._proof_1_17 | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} {i k : Fin n}, i ≤ k → ↑k - ↑i + 1 + (n - (n - ↑i)) = ↑k + 1 | null | false |
Equiv.Perm.sign_inv | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] (f : Equiv.Perm α), Equiv.Perm.sign f⁻¹ = Equiv.Perm.sign f | null | true |
HahnEmbedding.Seed.hahnCoeff_apply | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[ins... | null | true |
RootableBy.mk._flat_ctor | Mathlib.GroupTheory.Divisible | {A : Type u_1} →
{α : Type u_2} →
[inst : Monoid A] →
[inst_1 : Pow A α] →
[inst_2 : Zero α] →
(root : A → α → A) →
(∀ (a : A), root a 0 = 1) → (∀ {n : α} (a : A), n ≠ 0 → root a n ^ n = a) → RootableBy A α | null | false |
Std.TreeMap.getKeyLT | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.lt) → α | Given a proof that such a mapping exists, retrieves the largest key that is
less than the given key.
| true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.798741302._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat | IO Unit | null | false |
TensorProduct.induction_on | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {motive : TensorProduct R M N → Prop}
(z : TensorProduct R M N),
motive 0 →
(∀ (x : M) (y : N), motive (x ⊗ₜ[R] y)) →
(∀ (x y : TensorP... | null | true |
Finset.isPWO_support_addAntidiagonal | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO}, {a | (Finset.addAntidiagonal hs ht a).Nonempty}.IsPWO | null | true |
Set.sups_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] (s t u : Set α), s ⊻ t ⊻ u = s ⊻ (t ⊻ u) | null | true |
SSet.relativeCellComplexOfMono.Cell.ctorIdx | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | {X Y : SSet} → {i : X ⟶ Y} → {d : ℕ} → SSet.relativeCellComplexOfMono.Cell i d → ℕ | null | false |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.ne_bot_iff._simp_1_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | null | false |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.