name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Combinatorics.Matroid.IndepAxioms.0.Matroid.existsMaximalSubsetProperty_of_bdd._simp_1_1 | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {n : ℕ∞} {k : ℕ}, (n ≤ ↑k) = ∃ n₀, n = ↑n₀ ∧ n₀ ≤ k | null | false |
CauSeq.lim_le | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : CauSeq.IsComplete α abs] {f : CauSeq α abs} {x : α}, f ≤ CauSeq.const abs x → f.lim ≤ x | null | true |
differentiable_star_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {E : Type u_2} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : StarAddMonoid F]
[inst_6 : NormedSpace 𝕜 F] [StarModule 𝕜 F] [ContinuousStar F] {f : E → F} [TrivialStar ... | null | false |
ContinuousMap.instLatticeOfTopologicalLattice._proof_2 | Mathlib.Topology.ContinuousMap.Ordered | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Lattice β]
[inst_3 : TopologicalLattice β] (a b : C(α, β)), SemilatticeInf.inf a b ≤ b | null | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.ctorElimType | Lean.Meta.Tactic.Grind.AC.Types | {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u} → ℕ → Sort (max 1 u) | null | false |
Lean.Elab.PartialFixpoint.fixpointType._default | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType | null | false |
Submodule.mapHom._proof_2 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_2} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Semiring A] [inst_2 : Algebra R A] {A' : Type u_1}
[inst_3 : Semiring A'] [inst_4 : Algebra R A'] (f : A →ₐ[R] A'), Submodule.map f.toLinearMap ⊥ = ⊥ | null | false |
Lean.Elab.Tactic.BVDecide.External.TimedOut.casesOn | Lean.Elab.Tactic.BVDecide.External | {α : Type u} →
{motive : Lean.Elab.Tactic.BVDecide.External.TimedOut α → Sort u_1} →
(t : Lean.Elab.Tactic.BVDecide.External.TimedOut α) →
((x : α) → motive (Lean.Elab.Tactic.BVDecide.External.TimedOut.success x)) →
motive Lean.Elab.Tactic.BVDecide.External.TimedOut.timeout → motive t | null | false |
_private.Mathlib.RingTheory.Noetherian.Defs.0.isNoetherian_iff'.match_1_1 | Mathlib.RingTheory.Noetherian.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(motive : IsNoetherian R M → Prop) (x : IsNoetherian R M), (∀ (h : ∀ (s : Submodule R M), s.FG), motive ⋯) → motive x | null | false |
MeasureTheory.AEStronglyMeasurable.smul | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{𝕜 : Type u_5} [inst_1 : TopologicalSpace 𝕜] [inst_2 : SMul 𝕜 β] [ContinuousSMul 𝕜 β] {f : α → 𝕜} {g : α → β},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ... | null | true |
List.mapIdx_ne_nil_iff | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {l : List α}, List.mapIdx f l ≠ [] ↔ l ≠ [] | null | true |
ZMod.expand_card | Mathlib.FieldTheory.Finite.Basic | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : Polynomial (ZMod p)), (Polynomial.expand (ZMod p) p) f = f ^ p | null | true |
Lean.Try.Config.mk | Init.Try | Bool → Bool → Bool → ℕ → Bool → Bool → Bool → Bool → Bool → Lean.Try.Config | null | true |
String.Slice.Pos.splits | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} (p : s.Pos), p.Splits (s.sliceTo p).copy (s.sliceFrom p).copy | null | true |
SemilatSupCat.instLargeCategory._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y : SemilatSupCat} (f : SupBotHom X.X Y.X), (SupBotHom.id Y.X).comp f = f | null | false |
CategoryTheory.mop_rightUnitor | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).mop =
CategoryTheory.MonoidalCategoryStruct.leftUnitor { unmop := X } | null | true |
BoundedContinuousFunction.coe_npowRec._f | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u} [inst : TopologicalSpace α] {R : Type u_1} [inst_1 : SeminormedRing R]
(f : BoundedContinuousFunction α R) (x : ℕ) (f_1 : Nat.below x), ⇑(npowRec x f) = ⇑f ^ x | null | false |
LinearIndependent.finite_of_le_span_finite | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{ι : Type u_2} (v : ι → M),
LinearIndependent R v → ∀ (w : Set M) [Finite ↑w], Set.range v ≤ ↑(Submodule.span R w) → Finite ι | If `R` satisfies the strong rank condition,
then any linearly independent family `v : ι → M`
contained in the span of some finite `w : Set M`,
is itself finite.
| true |
Mathlib.Meta.NormNum.isNat_ordinalSub | Mathlib.Tactic.NormNum.Ordinal | ∀ {a b : Ordinal.{u}} {an bn rn : ℕ},
Mathlib.Meta.NormNum.IsNat a an →
Mathlib.Meta.NormNum.IsNat b bn → an - bn = rn → Mathlib.Meta.NormNum.IsNat (a - b) rn | null | true |
Representation.ind | Mathlib.RepresentationTheory.Induced | {k : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : CommRing k] →
[inst_1 : Group G] →
[inst_2 : Group H] →
(φ : G →* H) →
{A : Type u_4} →
[inst_3 : AddCommGroup A] →
[inst_4 : Module k A] → (ρ : Representation k G A) → Re... | Given a group homomorphism `φ : G →* H` and a `G`-representation `A`, this is
`(k[H] ⊗[k] A)_G` equipped with the `H`-representation defined by sending `h : H` and `⟦h₁ ⊗ₜ a⟧`
to `⟦h₁h⁻¹ ⊗ₜ a⟧`. | true |
_private.Mathlib.Algebra.Field.Periodic.0.Function.Periodic.exists_mem_Ico₀.match_1_1 | Mathlib.Algebra.Field.Periodic | ∀ {α : Type u_1} {c : α} [inst : AddCommGroup α] [inst_1 : LinearOrder α] (x : α)
(motive : (∃! k, 0 ≤ x - k • c ∧ x - k • c < c) → Prop) (x_1 : ∃! k, 0 ≤ x - k • c ∧ x - k • c < c),
(∀ (n : ℤ) (H : 0 ≤ x - n • c ∧ x - n • c < c)
(right : ∀ (y : ℤ), (fun k => 0 ≤ x - k • c ∧ x - k • c < c) y → y = n), motive ... | null | false |
_private.Mathlib.Order.Basic.0.Function.Injective.linearOrder._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), (a ≤ b ∨ b ≤ a) = True | null | false |
hasMFDerivWithinAt_insert | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
ULift.up.noConfusion | Init.Prelude | {α : Type s} → {P : Sort u} → {down down' : α} → { down := down } = { down := down' } → (down ≍ down' → P) → P | null | false |
ContinuousMap.compStarAlgHom._proof_5 | Mathlib.Topology.ContinuousMap.Star | ∀ (X : Type u_1) {𝕜 : Type u_4} {A : Type u_3} {B : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommSemiring 𝕜]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : IsTopologicalSemiring A] [inst_5 : Star A]
[inst_6 : Algebra 𝕜 A] [inst_7 : TopologicalSpace B] [inst_8 : Semiring B] [inst_9 : IsTopol... | null | false |
List.Pairwise.imp_of_mem | Init.Data.List.Pairwise | ∀ {α : Type u_1} {l : List α} {R S : α → α → Prop},
(∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → List.Pairwise R l → List.Pairwise S l | null | true |
Lean.Lsp.RpcRef.mk.injEq | Lean.Server.Rpc.Basic | ∀ (p p_1 : USize), ({ p := p } = { p := p_1 }) = (p = p_1) | null | true |
Matrix.TransvectionStruct | Mathlib.LinearAlgebra.Matrix.Transvection | Type u_1 → Type u₂ → Type (max u_1 u₂) | A structure containing all the information from which one can build a nontrivial transvection.
This structure is easier to manipulate than transvections as one has a direct access to all the
relevant fields. | true |
GrpCat.SurjectiveOfEpiAuxs.τ_apply_infinity | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
(GrpCat.SurjectiveOfEpiAuxs.tau f) GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.infinity =
GrpCat.SurjectiveOfEpiAuxs.XWithInfinity.fromCoset ⟨↑(GrpCat.Hom.hom f).range, ⋯⟩ | null | true |
Lean.Kernel.Exception.other.noConfusion | Lean.Environment | {P : Sort u} →
{msg msg' : String} → Lean.Kernel.Exception.other msg = Lean.Kernel.Exception.other msg' → (msg = msg' → P) → P | null | false |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKanLift._proof_2 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : x ⟶ a)
(s :
CategoryTheory.Bicategory.LeftLift u (CategoryTheory.CategoryStruct.comp h (CategoryTheory.CategoryStruct.id a))),
CategoryTheory.bicategoricalComp
... | null | false |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.processNullaryOrCat.match_1 | Lean.Elab.Syntax | (motive : Array Lean.Syntax → Sort u_1) →
(x : Array Lean.Syntax) → ((arg : Lean.Syntax) → motive #[arg]) → ((x : Array Lean.Syntax) → motive x) → motive x | null | false |
CategoryTheory.HasShift.induced._proof_5 | Mathlib.CategoryTheory.Shift.Induced | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_4, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] (s : A → CategoryTheory.Functor D D)
(i : (a : A) → F.comp (s a) ≅ (CategoryTh... | null | false |
CategoryTheory.effectiveEpiStructOfRegularEpi._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B X : C} {f : X ⟶ B} (hf : CategoryTheory.RegularEpi f)
{W : C} (x : X ⟶ W),
(∀ {Z : C} (g₁ g₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ x = Categor... | null | false |
Std.HashMap.Equiv.of_toList_perm | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β},
m₁.toList.Perm m₂.toList → m₁.Equiv m₂ | null | true |
IsContMDiffRiemannianBundle.rec | Mathlib.Geometry.Manifold.VectorBundle.Riemannian | {EB : Type u_1} →
[inst : NormedAddCommGroup EB] →
[inst_1 : NormedSpace ℝ EB] →
{HB : Type u_2} →
[inst_2 : TopologicalSpace HB] →
{IB : ModelWithCorners ℝ EB HB} →
{n : WithTop ℕ∞} →
{B : Type u_3} →
[inst_3 : TopologicalSpace B] →
... | null | false |
CommAlgCat.instConcreteCategoryAlgHomCarrier._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y Z : CommAlgCat R} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
exists_prop_of_true | Init.PropLemmas | ∀ {p : Prop} {q : p → Prop} (h : p), (∃ (h' : p), q h') ↔ q h | null | true |
Lean.Grind.CommRing.Poly.denote_mulC_nc_go | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ acc : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.mulC_nc.go p₂ c p₁ acc) =
Lean.Grind.CommRing.Poly.denote ctx acc +
Lean.Grind.CommRing.P... | null | true |
MultipliableLocallyUniformlyOn.hasProdLocallyUniformlyOn | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
MultipliableLocallyUniformlyOn f s → HasProdLocallyUniformlyOn f (fun x => ∏' (i : ι), f i x) s | null | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_iff._simp_1_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) = ∀ {q : α → Prop}, (∀ᶠ (x : α) in f, q x) → ∃ x, p x ∧ q x | null | false |
Lean.Grind.Linarith.Expr.toPoly'.go.eq_7 | Init.Grind.Ordered.Linarith | ∀ (coeff : ℤ) (a : Lean.Grind.Linarith.Expr),
Lean.Grind.Linarith.Expr.toPoly'.go coeff a.neg = Lean.Grind.Linarith.Expr.toPoly'.go (-coeff) a | null | true |
_private.Mathlib.Tactic.ClickSuggestions.0.Mathlib.Tactic.ClickSuggestions.viewKAbstractSubExpr'.match_1 | Mathlib.Tactic.ClickSuggestions | (motive : Option (Lean.Expr × Option ℕ) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Option ℕ)) →
((subExpr : Lean.Expr) → (occ : Option ℕ) → motive (some (subExpr, occ))) →
((x : Option (Lean.Expr × Option ℕ)) → motive x) → motive __do_lift | null | false |
seminormFromBounded_of_mul_apply | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ} {c : ℝ},
0 ≤ f →
(∀ (x y : R), f (x * y) ≤ c * f x * f y) →
∀ {x : R}, (∀ (y : R), f (x * y) = f x * f y) → seminormFromBounded' f x = f x | If `f : R → ℝ` is a nonnegative, multiplicatively bounded function and `x : R` is
multiplicative for `f`, then `seminormFromBounded' f x = f x`. | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.preprocess.normLevels._f | Lean.Meta.SynthInstance | Lean.Level →
Array ℕ → (us : List Lean.Level) → List.below (motive := fun us => ℕ → List Lean.Level) us → ℕ → List Lean.Level | null | false |
MonoidWithZeroHom.ValueGroup₀.restrict₀._proof_2 | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_2} {B : Type u_1} [inst : MonoidWithZero A] [inst_1 : GroupWithZero B] (f : A →*₀ B) (a : A)
(h : ¬f a = 0), Units.mk0 (f a) h ∈ f.valueGroup | null | false |
SchwartzMap.smulLeftCLM_ofReal | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (𝕜' : Type u_10) [inst_4 : RCLike 𝕜'] [inst_5 : NormedSpace 𝕜' F] {g : E → ℝ},
Function.HasTemperateGrowth g →
∀ (f : SchwartzMap E F), (SchwartzMap.smulLeftCLM ... | null | true |
RBTree.RBNode.WF | BatteriesRecycling.RBTree.Basic | {α : Type u_1} → (α → α → Ordering) → RBTree.RBNode α → Prop | The well-formedness invariant for a red-black tree. The first constructor is the real invariant,
and the others allow us to "cheat" in this file and define `insert` and `erase`,
which have more complex proofs that are delayed to `RBTree.Lemmas`.
| true |
CategoryTheory.Limits.createsColimitsOfShapeOfLeftOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) →
[inst_2 : CategoryTheory.Category.{w', w} J] →
(F : CategoryTheory.Functor C Dᵒᵖ) →
[CategoryTheory.CreatesLimitsOfShape Jᵒ... | If `F.leftOp : Cᵒᵖ ⥤ D` creates limits of shape `Jᵒᵖ`, then `F : C ⥤ Dᵒᵖ` creates colimits
of shape `J`. | true |
CategoryTheory.evaluation._proof_4 | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {x x_1 : C} (f : x ⟶ x_1) ⦃X Y : CategoryTheory.Functor C D⦄
(f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
({ obj := fun F => F.obj x, map := fun {X Y} α => α.app x, map_id := ⋯,... | null | false |
QPF.Wequiv.abs | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] (a : (QPF.P F).A) (f : (QPF.P F).B a → (QPF.P F).W) (a' : (QPF.P F).A)
(f' : (QPF.P F).B a' → (QPF.P F).W), QPF.abs ⟨a, f⟩ = QPF.abs ⟨a', f'⟩ → QPF.Wequiv (WType.mk a f) (WType.mk a' f') | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.Set.InvOn.one_sub_one_add_inv._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
Lean.Parser.Error.mk.sizeOf_spec | Lean.Parser.Types | ∀ (unexpectedTk : Lean.Syntax) (unexpected : String) (expected : List String),
sizeOf { unexpectedTk := unexpectedTk, unexpected := unexpected, expected := expected } =
1 + sizeOf unexpectedTk + sizeOf unexpected + sizeOf expected | null | true |
WittVector.inverseCoeff.match_1 | Mathlib.RingTheory.WittVector.DiscreteValuationRing | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
nhdsSet_interior | Mathlib.Topology.NhdsSet | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, nhdsSet (interior s) = Filter.principal (interior s) | null | true |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme.0.AlgebraicGeometry.Scheme.instFullOppositeIdealSheafDataOverSubschemeFunctor._simp_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (h : X = Y),
CategoryTheory.IsIso (CategoryTheory.eqToHom h) = True | null | false |
Std.TreeSet.Equiv.getLTD_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
t₁.Equiv t₂ → t₁.getLTD k fallback = t₂.getLTD k fallback | null | true |
HasCompactSupport.convolution_integrand_bound_right | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | null | true |
Std.Http.URI.Path.normalize | Std.Http.Data.URI.Basic | Std.Http.URI.Path → Std.Http.URI.Path | Removes dot segments from the path according to RFC 3986 Section 5.2.4. This handles "."
(current directory) and ".." (parent directory) segments.
| true |
Lean.Elab.CompletionInfo.fieldId.injEq | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (id : Option Lean.Name) (lctx : Lean.LocalContext) (structName : Lean.Name) (stx_1 : Lean.Syntax)
(id_1 : Option Lean.Name) (lctx_1 : Lean.LocalContext) (structName_1 : Lean.Name),
(Lean.Elab.CompletionInfo.fieldId stx id lctx structName =
Lean.Elab.CompletionInfo.fieldId stx_1 id_1 lctx... | null | true |
Lean.PrettyPrinter.Delaborator.OmissionReason.string.sizeOf_spec | Lean.PrettyPrinter.Delaborator.Basic | ∀ (s : String), sizeOf (Lean.PrettyPrinter.Delaborator.OmissionReason.string s) = 1 + sizeOf s | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.throw_ExceptT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
Lean.Meta.Sym.Context.config._default | Lean.Meta.Sym.SymM | Lean.Meta.Sym.Config | null | false |
_private.Mathlib.RingTheory.Ideal.Maximal.0.Ideal.exists_le_prime_disjoint.match_1_1 | Mathlib.RingTheory.Ideal.Maximal | ∀ {α : Type u_1} [inst : CommSemiring α] (I : Ideal α) (S : Submonoid α)
(motive : (∃ m, I ≤ m ∧ Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) m) → Prop)
(x : ∃ m, I ≤ m ∧ Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) m),
(∀ (p : Ideal α) (hIp : I ≤ p) (hp : Maximal (fun x => x ∈ {p | Disjoint ↑p ↑S}) p), motive ⋯) →... | null | false |
Set.Icc.coe_nonneg | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] (x : ↑(Set.Icc 0 1)), 0 ≤ ↑x | null | true |
_private.Init.While.0.whileM.erased | Init.While | {α : Type u} → {m : Type u → Type v} → [Monad m] → {β : Type u} → [Nonempty β] → (α → m (α ⊕ β)) → α → m β | An erased version of `whileM.impl` that eta-expands better in the compiler.
Can be removed once `whileM.impl` optimizes to the same code.
| true |
MeasureTheory.ae_eq_trim_iff_of_aestronglyMeasurable | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] [TopologicalSpace.MetrizableSpace β]
{m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → β} (hm : m ≤ m0)
(hfm : MeasureTheory.AEStronglyMeasurable f μ) (hgm : MeasureTheory.AEStronglyMeasurable g μ),
MeasureTheory.AEStronglyMeasurable.mk... | null | true |
Lean.Meta.mkHEq | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `a ≍ b`. | true |
Matrix.single_apply_of_col_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α]
(i i' : m) {j j' : n}, j ≠ j' → ∀ (a : α), Matrix.single i j a i' j' = 0 | null | true |
isPreirreducible_singleton | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, IsPreirreducible {x} | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.index | Mathlib.Tactic.GRewrite.Core | Mathlib.Tactic.GRewrite.GRewriteLemma✝ → Lean.HeadIndex × ℕ | The key used to determine where to attempt rewriting. | true |
String.Pos.instTransLe | Init.Data.String.OrderInstances | {s : String} → Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_53 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r r' : ℤ),
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47 →
autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_49 → r₀ ≤ r' | null | false |
continuousOn_stereoToFun | Mathlib.Geometry.Manifold.Instances.Sphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {v : E},
ContinuousOn (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1} | null | true |
Submodule.mulRightMap | Mathlib.LinearAlgebra.Finsupp.LSum | {R : Type u_1} →
[inst : Semiring R] →
{S : Type u_4} →
[inst_1 : Semiring S] →
[inst_2 : Module R S] →
[SMulCommClass R R S] →
[IsScalarTower R S S] →
(M : Submodule R S) → {N : Submodule R S} → {ι : Type u_5} → (ι → ↥N) → (ι →₀ ↥M) →ₗ[R] S | If `M` and `N` are submodules of an `R`-algebra `S`, `n : ι → N` is a family of elements, then
there is an `R`-linear map from `ι →₀ M` to `S` which maps `{ m_i }` to the sum of `m_i * n_i`.
This is used in the definition of linearly disjointness. | true |
CategoryTheory.MonoidalClosed.uncurry_ihomUncurry | Mathlib.CategoryTheory.Monoidal.Closed.InternalCurrying | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (x y z : C)
[inst_2 : CategoryTheory.Closed x] [inst_3 : CategoryTheory.Closed y]
[inst_4 : CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj x y)],
CategoryTheory.MonoidalClosed.uncurry (Cat... | null | true |
CategoryTheory.Oplax.OplaxTrans.Modification.noConfusion | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {P : Sort u} →
{B : Type u₁} →
{inst : CategoryTheory.Bicategory B} →
{C : Type u₂} →
{inst_1 : CategoryTheory.Bicategory C} →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{t : CategoryTheory.Oplax.OplaxTrans.Modification η θ} →
{B' : ... | null | false |
CategoryTheory.LiftRightAdjoint.constructRightAdjoint | Mathlib.CategoryTheory.Adjunction.Lifting.Right | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{U : CategoryTheory.Functor A B} →
{F : CategoryTheory.Functor B A} →
... | Construct the right adjoint to `L`, with object map `constructRightAdjointObj`. | true |
Lean.Data.Trie.empty | Lean.Data.Trie | {α : Type} → Lean.Data.Trie α | The empty `Trie` | true |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.rec | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | {motive : Lean.Meta.Grind.Arith.CommRing.RingM.Context → Sort u} →
((ringId : ℕ) → (checkCoeffDvd : Bool) → motive { ringId := ringId, checkCoeffDvd := checkCoeffDvd }) →
(t : Lean.Meta.Grind.Arith.CommRing.RingM.Context) → motive t | null | false |
Real.sqrt_inj._simp_1 | Mathlib.Analysis.Real.Sqrt | ∀ {x y : ℝ}, 0 ≤ x → 0 ≤ y → (√x = √y) = (x = y) | null | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.performRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} →
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n →
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n →
Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) →
Array ℕ → Array (ℕ × Array ℕ) → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n × Bool | Attempts to verify that `c` can be added to `f` via unit propagation. If it can, it returns
`((f.insert c), true)`. If it can't, it returns false as the second part of the tuple
(and no guarantees are made about what formula is returned).
| true |
TopCat.pathEquiv._proof_4 | Mathlib.Topology.Homotopy.TopCat.Path | ContinuousMapClass (↑TopCat.I ≃ₜ ↑unitInterval) ↑TopCat.I ↑unitInterval | null | false |
Aesop.RuleTacDescr.cases.noConfusion | Aesop.RuleTac.Descr | {P : Sort u} →
{target : Aesop.CasesTarget} →
{md : Lean.Meta.TransparencyMode} →
{isRecursiveType : Bool} →
{ctorNames : Array Aesop.CtorNames} →
{target' : Aesop.CasesTarget} →
{md' : Lean.Meta.TransparencyMode} →
{isRecursiveType' : Bool} →
{cto... | null | false |
Bimod.AssociatorBimod.hom_inv_id | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)]
[i... | null | true |
CategoryTheory.ObjectProperty.InheritedFromSource.instMin | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P P' : CategoryTheory.ObjectProperty C)
(Q : CategoryTheory.MorphismProperty C) [P.InheritedFromSource Q] [P'.InheritedFromSource Q],
(P ⊓ P').InheritedFromSource Q | null | true |
Ideal.snd_comp_quotientInfEquivQuotientProd | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_2} [inst : CommRing R] (I J : Ideal R) (coprime : IsCoprime I J),
(RingHom.snd (R ⧸ I) (R ⧸ J)).comp ↑(I.quotientInfEquivQuotientProd J coprime) = Ideal.Quotient.factor ⋯ | null | true |
CategoryTheory.Profunctor.ofHom._proof_4 | Mathlib.CategoryTheory.Profunctor.Basic | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_5, u_3} D] {P Q : CategoryTheory.ProfunctorCore.{u_4, u_1, u_5, u_2, u_3} C D}
(f : P.Hom Q) ⦃X Y : C⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Profunctor.ofCore P).map f_1)... | null | false |
Vector.set | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i < n) Vector.set._auto_1 → Vector α n | Set an element in a vector using a `Nat` index, with a tactic provided proof that the index is in
bounds.
This will perform the update destructively provided that the vector has a reference count of 1.
| true |
Subsemiring.mem_centralizer_iff | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R] {s : Set R} {z : R}, z ∈ Subsemiring.centralizer s ↔ ∀ g ∈ s, g * z = z * g | null | true |
_private.Mathlib.Probability.Distributions.Fernique.0.ProbabilityTheory.exists_integrable_exp_sq_of_map_rotation_eq_self_of_isProbabilityMeasure._simp_1_2 | Mathlib.Probability.Distributions.Fernique | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
CategoryTheory.Cat.freeRefl_map | Mathlib.CategoryTheory.Category.ReflQuiv | ∀ {X Y : CategoryTheory.ReflQuiv} (F : X ⟶ Y),
CategoryTheory.Cat.freeRefl.map F = (CategoryTheory.Cat.freeReflMap F).toCatHom | null | true |
BitVec.extractLsb'_append_extractLsb' | Init.Data.BitVec.Lemmas | ∀ {w len : ℕ} {x : BitVec (w + len)}, BitVec.extractLsb' len w x ++ BitVec.extractLsb' 0 len x = x | null | true |
Std.Internal.List.getValue?_insertEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [PartialEquivBEq α] {l : List ((_ : α) × β)} {k a : α} {v : β},
Std.Internal.List.getValue? a (Std.Internal.List.insertEntry k v l) =
if (k == a) = true then some v else Std.Internal.List.getValue? a l | null | true |
CategoryTheory.MorphismProperty.equivalenceLeftFractionRel | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W : CategoryTheory.MorphismProperty C)
[W.HasLeftCalculusOfFractions] (X Y : C), Equivalence CategoryTheory.MorphismProperty.LeftFractionRel | null | true |
sSupHom.instSSupHomClass | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : SupSet α] [inst_1 : SupSet β], sSupHomClass (sSupHom α β) α β | null | true |
DFinsupp.Colex.decidableLE | Mathlib.Data.DFinsupp.Lex | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : (i : ι) → Zero (α i)] →
[inst_1 : LinearOrder ι] → [inst_2 : (i : ι) → LinearOrder (α i)] → DecidableLE (Colex (Π₀ (i : ι), α i)) | The less-or-equal relation for the colexicographic ordering is decidable. | true |
VectorFourier.norm_fourierIntegral_le_integral_norm | Mathlib.Analysis.Fourier.FourierTransform | ∀ {𝕜 : Type u_1} [inst : CommRing 𝕜] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : MeasurableSpace V] {W : Type u_3} [inst_4 : AddCommGroup W] [inst_5 : Module 𝕜 W] {E : Type u_4}
[inst_6 : NormedAddCommGroup E] [inst_7 : NormedSpace ℂ E] (e : AddChar 𝕜 Circle) (μ : MeasureTheory.Mea... | The uniform norm of the Fourier integral of `f` is bounded by the `L¹` norm of `f`. | true |
ValuationSubring.instFieldSubtypeMemTop._proof_19 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K], 0⁻¹ = 0 | null | false |
instInvInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : CommGroup α] → [inst_1 : PartialOrder α] → [IsOrderedMonoid α] → Inv (Interval α) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.