name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Balanced.isIso_of_mono_of_epi | Mathlib.CategoryTheory.Balanced | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Balanced C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Mono f] [CategoryTheory.Epi f], CategoryTheory.IsIso f | null | true |
SmoothPartitionOfUnity.casesOn | Mathlib.Geometry.Manifold.PartitionOfUnity | {ι : Type uι} →
{E : Type uE} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type uH} →
[inst_2 : TopologicalSpace H] →
{I : ModelWithCorners ℝ E H} →
{M : Type uM} →
[inst_3 : TopologicalSpace M] →
[inst_4 : ... | null | false |
Valuation.IsEquiv.valueGroup₀Fun._proof_3 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_2} {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] {v : Valuation R Γ₀}
(d : { xy // (MonoidWithZeroHom.ofClass v) xy.1 ≠ 0 ∧ (MonoidWithZeroHom.ofClass v) xy.2 ≠ 0 }),
(MonoidWithZeroHom.ofClass v) (↑d).2 ≠ 0 | null | false |
CategoryTheory.Comonad.coalgebraPreadditive._proof_7 | Mathlib.CategoryTheory.Preadditive.EilenbergMoore | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(U : CategoryTheory.Comonad C) [inst_2 : U.Additive] (F G : U.Coalgebra) (x x_1 x_2 : F ⟶ G),
x + x_1 + x_2 = x + (x_1 + x_2) | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.import._regBuiltin.Lean.Parser.Command.import.parenthesizer_11 | Lean.Parser.Command | IO Unit | null | false |
MeasurableDiv₂.rec | Mathlib.MeasureTheory.Group.Arithmetic | {G₀ : Type u_2} →
[inst : MeasurableSpace G₀] →
[inst_1 : Div G₀] →
{motive : MeasurableDiv₂ G₀ → Sort u} →
((measurable_div : Measurable fun p => p.1 / p.2) → motive ⋯) → (t : MeasurableDiv₂ G₀) → motive t | null | false |
Std.TreeMap.Raw.Equiv.entryAtIdxD_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp] {i : ℕ}
{fallback : α × β}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.entryAtIdxD i fallback = t₂.entryAtIdxD i fallback | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.example.parenthesizer_289 | Lean.Parser.Command | IO Unit | null | false |
SimpleGraph.nonempty_dart_top | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} [Nontrivial V], Nonempty ⊤.Dart | null | true |
Perfection.teichmuller | Mathlib.RingTheory.Teichmuller | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
{R : Type u_1} →
[inst_1 : CommRing R] →
(I : Ideal R) → [inst_2 : CharP (R ⧸ I) p] → [IsAdicComplete I R] → Perfection (R ⧸ I) p →* R | Given an `I`-adically complete ring `R`, and a prime number `p` with `p ∈ I`, this is the
multiplicative map from `Perfection (R ⧸ I) p` to `R` itself. Specifically, it is defined as the
limit of `p^n`-th powers of arbitrary lifts in `R` of the `n`-th component from the perfection of
`R ⧸ I`.
The simp NF is `teichmull... | true |
Filter.join._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f : Filter (Filter α)), Set.univ ∈ {s | {t | s ∈ t} ∈ f} | null | false |
IsCyclotomicExtension.subsingleton_iff._simp_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (S : Set ℕ) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Subsingleton B], IsCyclotomicExtension S A B = (S ⊆ {0, 1}) | null | false |
tendsto_comp_coe_Ioo_atTop._simp_1 | Mathlib.Topology.Order.AtTopBotIxx | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X] {a b : X} {α : Type u_2}
{l : Filter α} {f : X → α},
a < b →
autoParam (Order.IsSuccPrelimit b) tendsto_comp_coe_Ioo_atTop._auto_1 →
Filter.Tendsto (fun x => f ↑x) Filter.atTop l = Filter.Tendsto f (nhdsWithin b (Set.I... | null | false |
CategoryTheory.Limits.ι_colimitFiberwiseColimitIso_inv_assoc | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
(G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H)
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F... | null | true |
MeasureTheory.Lp.compMeasurePreserving._proof_2 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_2} {E : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {β : Type u_3} [inst_1 : MeasurableSpace β] {μb : MeasureTheory.Measure β} (f : α → β)
(hf : MeasureTheory.MeasurePreserving f μ μb) (g : ↥(MeasureTheory.Lp E p μb)),
(↑g).compMeasureP... | null | false |
Std.PRange.instToStreamRocIterIteratorOfUpwardEnumerable | Init.Data.Range.Polymorphic.Stream | {α : Type u_1} → [Std.PRange.UpwardEnumerable α] → Std.ToStream (Std.Roc α) (Std.Iter α) | null | true |
Bundle.Trivialization.contMDiffOn_iff | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {M : Type u_5} {E : B → Type u_6}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_8} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSp... | null | true |
SSet.StrictSegalCore.concat.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet} {n : ℕ} (self self_1 : X.StrictSegalCore n),
self = self_1 →
∀ (x x_1 : X.obj (Opposite.op { len := 1 })) (e_x : x = x_1) (s s_1 : X.obj (Opposite.op { len := n }))
(e_s : s = s_1)
(h :
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ X 0)) x =
(Ca... | null | true |
Lean.Elab.Tactic.Do.Internal.VCGen.State | Lean.Elab.Tactic.Do.Internal.VCGen.Context | Type | null | true |
Char.instLawfulUpwardEnumerableLE | Init.Data.Range.Polymorphic.Char | Std.PRange.LawfulUpwardEnumerableLE Char | null | true |
Lean.Elab.Tactic.Do.ProofMode.checkHasType | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Expr → Lean.Expr → optParam Bool false → Lean.MetaM Unit | null | true |
extProc._@.Mathlib.Tactic.Attr.Register.612238087._hygCtx._hyg.3 | Mathlib.Tactic.Attr.Register | Lean.Meta.Simp.SimprocExtension | Simplification procedure | false |
_private.Mathlib.MeasureTheory.Function.AbsolutelyContinuous.0.AbsolutelyContinuousOnInterval.hasBasis_totalLengthFilter._simp_1_3 | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) | null | false |
Std.HashMap.Raw.mem_of_mem_insertMany_list | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List (α × β)} {k : α}, k ∈ m.insertMany l → (List.map Prod.fst l).contains k = false → k ∈ m | null | true |
AddSubgroup.ascending_central_series_le_upper | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : AddGroup G] (H : ℕ → AddSubgroup G),
AddSubgroup.IsAscendingCentralSeries H → ∀ (n : ℕ), H n ≤ AddSubgroup.upperCentralSeries G n | Any ascending central series for an additive group is bounded above by the upper
central series. | true |
instZeroEuclideanQuadrant | Mathlib.Geometry.Manifold.Instances.Real | {n : ℕ} → Zero (EuclideanQuadrant n) | null | true |
CategoryTheory.Adjunction.right_triangle_components_assoc._to_dual_1 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (self : G ⊣ F) (Y : D) {Z : C} (h : Z ⟶ G.obj Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h (G.map ... | null | false |
HomotopyEquiv.mk._flat_ctor | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
(hom : C ⟶ D) →
(inv : D ⟶ C) →
Homotopy (CategoryTheory.CategoryStruct.co... | null | false |
MeasureTheory.«_aux_Mathlib_MeasureTheory_VectorMeasure_Basic___macroRules_MeasureTheory_term_⟂ᵥ__1» | Mathlib.MeasureTheory.VectorMeasure.Basic | Lean.Macro | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_eq_sum_segment._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : Finset ι) (f : ι → Set α) (a : α),
(a ∈ ∑ i ∈ t, f i) = ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ t → g i ∈ f i), ∑ i ∈ t, g i = a | null | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.Chain._simp_3 | Mathlib.Data.List.Cycle | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
HomologicalComplex.restrictionHomologyIso_hom_homologyι_assoc | Mathlib.Algebra.Homology.Embedding.RestrictionHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j k : ι) (hi : c.prev j = i)
(hk : c.next j = k)... | null | true |
Matrix.conjTransposeRingEquiv | Mathlib.LinearAlgebra.Matrix.ConjTranspose | (m : Type u_2) →
(α : Type v) →
[inst : NonUnitalNonAssocSemiring α] →
[inst_1 : StarRing α] → [inst_2 : Fintype m] → Matrix m m α ≃⋆+* (Matrix m m α)ᵐᵒᵖ | `Matrix.conjTranspose` as a `StarRingEquiv` to the opposite ring | true |
LocallyConstant.charFn | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
(Y : Type u_2) → [inst : TopologicalSpace X] → [MulZeroOneClass Y] → {U : Set X} → IsClopen U → LocallyConstant X Y | Characteristic functions are locally constant functions taking `x : X` to `1` if `x ∈ U`,
where `U` is a clopen set, and `0` otherwise. | true |
WithLp.ctorIdx | Mathlib.Analysis.Normed.Lp.WithLp | {p : ENNReal} → {V : Type u_1} → WithLp p V → ℕ | null | false |
String.toInt?_eq_none_iff._simp_1 | Std.Data.String.ToInt | ∀ {s : String}, (s.toInt? = none) = (s.isInt = false) | null | false |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_inf | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
Cardinal.lift.{w, v} (A.relran... | null | true |
QuotientGroup.completeSpace_left | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : Group G] [us : UniformSpace G] [inst_1 : IsLeftUniformGroup G] [FirstCountableTopology G]
(N : Subgroup G) [inst_3 : N.Normal] [hG : CompleteSpace G], CompleteSpace (G ⧸ N) | The quotient `G ⧸ N` of a complete first countable uniform group `G` by a normal subgroup
is itself complete. In contrast to `QuotientGroup.completeSpace_left'`, in this version `G` is
already equipped with a uniform structure.
[N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]
Even though `G` is e... | true |
Bool.sizeOf_eq_one | Init.SizeOf | ∀ (b : Bool), sizeOf b = 1 | null | true |
Filter.isBoundedUnder_ge_inf._simp_1 | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] {f : Filter β} {u v : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f fun a => u a ⊓ v a) =
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) f v) | null | false |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.lift (CochainComplex.mappingCone.inr φ)
(... | null | false |
MvPolynomial.support_sum | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {α : Type u_2} [inst_1 : DecidableEq σ] {s : Finset α}
{f : α → MvPolynomial σ R}, (∑ x ∈ s, f x).support ⊆ s.biUnion fun x => (f x).support | null | true |
NonarchAddGroupNorm.mk.inj | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} {inst : AddGroup G} {toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0}
{toNonarchAddGroupSeminorm_1 : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero'_1 : ∀ (x : G), toNonarchAddGroupSeminorm_1.toFun x = ... | null | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun.visitLambda.match_4 | Mathlib.Tactic.Translate.Core | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam n d b bi)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
Set.mulIndicator_one | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} (M : Type u_3) [inst : One M] (s : Set α), (s.mulIndicator fun x => 1) = fun x => 1 | null | true |
CategoryTheory.Limits.pushout.map._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W X Y Z S T : C} (f₁ : S ⟶ W) (f₂ : S ⟶ X) (g₁ : T ⟶ Y)
(g₂ : T ⟶ Z) [inst_1 : CategoryTheory.Limits.HasPushout g₁ g₂] (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T),
CategoryTheory.CategoryStruct.comp f₁ i₁ = CategoryTheory.CategoryStruct.comp i₃ g₁ →
Cat... | null | false |
Lean.Meta.Sym.Simp.EvalStepConfig.noConfusion | Lean.Meta.Sym.Simp.EvalGround | {P : Sort u} →
{t t' : Lean.Meta.Sym.Simp.EvalStepConfig} → t = t' → Lean.Meta.Sym.Simp.EvalStepConfig.noConfusionType P t t' | null | false |
PMF.mem_support_iff | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} (p : PMF α) (a : α), a ∈ p.support ↔ p a ≠ 0 | null | true |
Lean.Meta.Grind.checkMaxEmatchExceeded | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalM Bool | Returns `true` if the maximum number of E-matching rounds has been reached. | true |
AugmentedSimplexCategory.instMonoidalCategory._proof_4 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ {X₁ X₂ X₃ Y₁ Y₂ Y₃ : AugmentedSimplexCategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom =
... | null | false |
Batteries.AssocList.isEmpty.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2}, Batteries.AssocList.nil.isEmpty = true | null | true |
Aesop.RuleTacDescr.constructors | Aesop.RuleTac.Descr | Array Lean.Name → Lean.Meta.TransparencyMode → Aesop.RuleTacDescr | null | true |
div_lt_div_iff' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LT α] [MulLeftStrictMono α] {a b c d : α}, a / b < c / d ↔ a * d < c * b | null | true |
Module.Basis.empty.congr_simp | Mathlib.RingTheory.Smooth.StandardSmoothOfFree | ∀ {ι : Type u_1} {R : Type u_3} (M : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Subsingleton M] [inst_4 : IsEmpty ι], Module.Basis.empty M = Module.Basis.empty M | null | true |
SNum.lt | Mathlib.Data.Num.Lemmas | LT SNum | null | true |
Std.DTreeMap.Internal.Impl.mem_of_mem_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k a : α}, a ∈ Std.DTreeMap.Internal.Impl.erase! k t → a ∈ t | null | true |
String.Slice.Pos.prevAux.go.eq_def | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ) (h₁ : off < s.utf8ByteSize),
String.Slice.Pos.prevAux.go off h₁ =
if hbyte : (s.getUTF8Byte { byteIdx := off } h₁).IsUTF8FirstByte then { byteIdx := off }
else
have this := ⋯;
match off, h₁, hbyte, this with
| 0, h₁, hbyte, this => ⋯.elim
| off.succ, h₁, ... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_10 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (¬x < y) = (y ≤ x) | null | false |
_private.Mathlib.Tactic.Algebra.Basic.0.Mathlib.Tactic.Algebra.RingCompute.isOne.match_3 | Mathlib.Tactic.Algebra.Basic | {u : Lean.Level} →
{R : Q(Type u)} →
{sR : Q(CommSemiring «$R»)} →
(motive : (r : Q(«$R»)) → Mathlib.Tactic.Ring.ExSum q(«$sR») r → Sort u_1) →
(r : Q(«$R»)) →
(vx : Mathlib.Tactic.Ring.ExSum q(«$sR») r) →
((a : Q(«$R»)) →
(c : Mathlib.Tactic.Ring.RatCoeff a) →
... | null | false |
Descriptive.Tree.take_mem | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {n : ℕ} (x : ↥T), List.take n ↑x ∈ T | null | true |
CategoryTheory.preservesColimits_of_createsColimits_and_hasColimits | Mathlib.CategoryTheory.Limits.Creates | ∀ {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.CreatesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} D],
CategoryTheory.Limits.PreservesColi... | `F` preserves limits if it creates limits and `D` has limits. | true |
CategoryTheory.WithTerminal.starIsoTerminal_inv | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithTerminal.starIsoTerminal.inv =
CategoryTheory.WithTerminal.starTerminal.from (⊤_ CategoryTheory.WithTerminal C) | null | true |
Homeomorph.setCongr._proof_2 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X} (h : s = t), Continuous (Equiv.setCongr h).invFun | null | false |
_private.Init.Core.0.decide_true.match_1_1 | Init.Core | ∀ (motive : Decidable True → Prop) (h : Decidable True),
(∀ (h : True), motive (isTrue h)) → (∀ (h : ¬True), motive (isFalse h)) → motive h | null | false |
MvPolynomial.IsSymmetric.zero | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R], MvPolynomial.IsSymmetric 0 | null | true |
Multiset.countP_attach | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
Multiset.countP (fun a => p ↑a) s.attach = Multiset.countP p s | null | true |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable._simp_1_1 | Mathlib.Analysis.Complex.CauchyIntegral | (Real.pi = 0) = False | null | false |
uniformity_pseudoedist | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} [inst : PseudoEMetricSpace α],
uniformity α = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | Reformulation of the uniform structure in terms of the extended distance | true |
RootPairing.PolarizationEquiv._proof_5 | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {R : Type u_1} [inst : Field R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
Std.HashSet.toList | Std.Data.HashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → Std.HashSet α → List α | Transforms the hash set into a list of elements in some order. | true |
Std.ExtHashMap.mem_insert._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β}, (a ∈ m.insert k v) = ((k == a) = true ∨ a ∈ m) | null | false |
Lean.Meta.AC.PreExpr.op.sizeOf_spec | Lean.Meta.Tactic.AC.Main | ∀ (lhs rhs : Lean.Meta.AC.PreExpr), sizeOf (lhs.op rhs) = 1 + sizeOf lhs + sizeOf rhs | null | true |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.instBEqSplitStatus.beq._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitStatus → Sort u} →
(t : Lean.Meta.Grind.SplitStatus) →
((numCases : ℕ) →
(isRec tryPostpone : Bool) → motive (Lean.Meta.Grind.SplitStatus.ready numCases isRec tryPostpone)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
CompHausLike.LocallyConstant.counit._proof_4 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u_1 + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
[inst_3 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
... | null | false |
unexpandMkArray3 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | null | true |
Orientation.eq_rotation_self_iff | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V) (θ : Real.Angle), x = (o.rotation θ) x ↔ x = 0 ∨ θ = 0 | A vector equals a rotation of that vector if and only if the vector or the angle is zero. | true |
AlgebraicGeometry.Scheme.jointlySurjectiveTopology | Mathlib.AlgebraicGeometry.Sites.Pretopology | CategoryTheory.GrothendieckTopology AlgebraicGeometry.Scheme | The jointly surjective topology on `Scheme` is defined by the same condition as the jointly
surjective pretopology. | true |
_private.Lean.Language.Basic.0.Lean.Language.SnapshotTask.ReportingRange.ofOptionInheriting.match_1 | Lean.Language.Basic | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) → ((range : Lean.Syntax.Range) → motive (some range)) → (Unit → motive none) → motive x | null | false |
Prod.instReflLex_mathlib_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Refl s], Std.Refl (Prod.Lex r s) | null | true |
Applicative.mk.noConfusion | Init.Prelude | {f : Type u → Type v} →
{P : Sort u_1} →
{toFunctor : Functor f} →
{toPure : Pure f} →
{toSeq : Seq f} →
{toSeqLeft : SeqLeft f} →
{toSeqRight : SeqRight f} →
{toFunctor' : Functor f} →
{toPure' : Pure f} →
{toSeq' : Seq f} →
... | null | false |
Finsupp.DegLex.monotone_degree | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], Monotone fun x => Finsupp.degree (ofDegLex x) | null | true |
AlgebraicGeometry.Scheme.ProEt.instFullOverForget | Mathlib.AlgebraicGeometry.Sites.Proetale | ∀ (S : AlgebraicGeometry.Scheme), (AlgebraicGeometry.Scheme.ProEt.forget S).Full | null | true |
Std.Stream.noConfusion | Init.Data.Stream | {P : Sort u_1} →
{stream : Type u} →
{value : Type v} →
{t : Std.Stream stream value} →
{stream' : Type u} →
{value' : Type v} →
{t' : Std.Stream stream' value'} →
stream = stream' → value = value' → t ≍ t' → Std.Stream.noConfusionType P t t' | null | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M.addSizeTerm | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M✝ Unit | null | true |
Mathlib.Tactic.Monoidal.StructuralOfExpr_monoidalComp | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h i : C} [inst_1 : CategoryTheory.MonoidalCoherence g h]
(η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.monoidalIsoComp η' θ').hom = CategoryTheory.monoidalComp η θ | null | true |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.fixingSubgroup_fixedField._simp_1_1 | Mathlib.FieldTheory.Galois.Infinite | ∀ {M : Type u_1} [inst : Mul M] {s : Subsemigroup M} {x : M}, (x ∈ s.carrier) = (x ∈ s) | null | false |
Std.Sat.CNF.Clause.relabel_relabel' | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {α_1 : Type u_2} {r1 : α → α_1} {α_2 : Type u_3} {r2 : α_2 → α},
Std.Sat.CNF.Clause.relabel r1 ∘ Std.Sat.CNF.Clause.relabel r2 = Std.Sat.CNF.Clause.relabel (r1 ∘ r2) | null | true |
Std.Net.instInhabitedSocketAddress.default | Std.Net.Addr | Std.Net.SocketAddress | null | true |
Complex.differentiable_sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | Differentiable ℂ Complex.sinh | null | true |
ONote.fundamentalSequenceProp_inl_some | Mathlib.SetTheory.Ordinal.Notation | ∀ (o a : ONote), o.FundamentalSequenceProp (Sum.inl (some a)) ↔ o.repr = Order.succ a.repr ∧ (o.NF → a.NF) | null | true |
MulMemClass.isRightCancelMul | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : Mul M] [inst_1 : SetLike A M] [hA : MulMemClass A M] [IsRightCancelMul M]
(S : A), IsRightCancelMul ↥S | A submagma of a right cancellative magma inherits right cancellation. | true |
Lean.Parser.atomicFn | Lean.Parser.Basic | Lean.Parser.ParserFn → Lean.Parser.ParserFn | null | true |
AddMonoidAlgebra.symm_mapAddEquiv | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Add M] (e : R ≃+ S),
(AddMonoidAlgebra.mapAddEquiv M e).symm = AddMonoidAlgebra.mapAddEquiv M e.symm | null | true |
LocallyConstant.instMul.eq_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Mul Y],
LocallyConstant.instMul = { mul := fun f g => { toFun := ⇑f * ⇑g, isLocallyConstant := ⋯ } } | null | true |
Lean.Parser.withOpenDeclFn | Lean.Parser.Extension | Lean.Parser.ParserFn → Lean.Parser.ParserFn | If the parsing stack is of the form `#[.., openDecl]`, we process the open declaration, and execute `p` | true |
ValuativeRel.ValueGroupWithZero.mk_one_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R], ValuativeRel.ValueGroupWithZero.mk 1 1 = 1 | null | true |
Module.Basis.algebraMapCoeffs_apply | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_1} (A : Type u_3) {ι : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (b : Module.Basis ι R M) (h : Function.Bijective ⇑(algebraMap R A)) (i : ι),
(Mod... | null | true |
ContinuousLinearMap.mfderiv_eq | 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}, mfderiv% ⇑f x = f | null | true |
MeasureTheory.StronglyAdapted.isStronglyProgressive_of_discrete | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : TopologicalSpace ι] [DiscreteTopology ι]
[SecondCountableTopology ι] [inst_5 : MeasurableSpace ι] [OpensMeasurableSpace ι]
[Topologi... | For filtrations indexed by a discrete order, `StronglyAdapted` and `IsStronglyProgressive` are
equivalent. This lemma provides `StronglyAdapted f u → IsStronglyProgressive f u`.
See `IsStronglyProgressive.stronglyAdapted` for the reverse direction, which is true more generally.
| true |
OrderIso.isBoundedUnder_le_comp | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {l : Filter γ} {u : γ → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => e (u x)) ↔ Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l u | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.