name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.size_mkSlice_rco._simp_1_1 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α}, Std.Slice.size xs = (Std.Slice.toList xs).length |
Equiv.Finset.union_symm_right | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} (h : Disjoint s t) {i : α} (hi : i ∈ t) (hi' : i ∈ s ∪ t),
(Equiv.Finset.union s t h).symm ⟨i, hi'⟩ = Sum.inr ⟨i, hi⟩ |
Nat.succ.elim | Init.Prelude | {motive : ℕ → Sort u} → (t : ℕ) → t.ctorIdx = 1 → ((n : ℕ) → motive n.succ) → motive t |
Diffeomorph.coe_refl | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) (M : Type u_9)
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (n : WithTop ℕ∞), ⇑(Diffeomorph.refl I M n) = id |
Plausible.Random.instBoundedRandomFin | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {n : ℕ} → Plausible.BoundedRandom m (Fin n) |
WithTop.LinearOrderedAddCommGroup.instLinearOrderedAddCommGroupWithTopOfIsOrderedAddMonoid._proof_8 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G], WithTop.map (fun a => -a) ⊤ = ⊤ |
Std.DTreeMap.Internal.RxoIterator._sizeOf_inst | Std.Data.DTreeMap.Internal.Zipper | (α : Type u) →
(β : α → Type v) →
{inst : Ord α} → [SizeOf α] → [(a : α) → SizeOf (β a)] → SizeOf (Std.DTreeMap.Internal.RxoIterator α β) |
OpenPartialHomeomorph.subtypeRestr_target_subset | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : TopologicalSpace.Opens X} (hs : Nonempty ↥s),
(e.subtypeRestr hs).target ⊆ e.target |
_private.Mathlib.Geometry.Manifold.Riemannian.Basic.0.setOf_riemannianEDist_lt_subset_nhds._simp_1_3 | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {r : NNReal}, (0 < ↑r) = (0 < r) |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_14 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_1) {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : ↥(Unitization.unitsFstOne R A)),
⟨{
val :=
1 +
↑(PreQuasiregular.equiv.symm
↑{ val := PreQuasiregular.equiv (↑↑x).snd, inv := PreQuasiregular.equiv (↑↑x⁻¹).snd, val_inv := ⋯,
inv_val := ⋯ }),
inv :=
1 +
↑(PreQuasiregular.equiv.symm
↑{ val := PreQuasiregular.equiv (↑↑x).snd, inv := PreQuasiregular.equiv (↑↑x⁻¹).snd, val_inv := ⋯,
inv_val := ⋯ }⁻¹),
val_inv := ⋯, inv_val := ⋯ },
⋯⟩ =
x |
Nat.preimage_Iic | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R},
0 ≤ a → Nat.cast ⁻¹' Set.Iic a = Set.Iic ⌊a⌋₊ |
CategoryTheory.Abelian.Ext.mapExactFunctor._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Map | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u_4}
[inst_2 : CategoryTheory.Category.{u_2, u_4} D] [inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D)
[F.Additive], F.PreservesZeroMorphisms |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.iUnion_Ioc_right._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b |
Finset.smul_finset_univ | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {a : α}
[inst_3 : Fintype β], a • Finset.univ = Finset.univ |
Std.DHashMap.Internal.Raw₀.contains_of_contains_union_of_contains_eq_false_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, (m₁.union m₂).contains k = true → m₂.contains k = false → m₁.contains k = true |
BitVec.ofFin_le | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x : Fin (2 ^ n)} {y : BitVec n}, { toFin := x } ≤ y ↔ x ≤ y.toFin |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.denselyOrdered_iff_denselyOrdered_units_and_nontrivial_units._simp_1_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} [inst : Monoid α] {u v : αˣ}, (u = v) = (↑u = ↑v) |
ContinuousAffineMap.noConfusion | Mathlib.Topology.Algebra.ContinuousAffineMap | {P : Sort u} →
{R : Type u_1} →
{V : Type u_2} →
{W : Type u_3} →
{P_1 : Type u_4} →
{Q : Type u_5} →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P_1} →
{inst_4 : AddTorsor V P_1} →
{inst_5 : AddCommGroup W} →
{inst_6 : Module R W} →
{inst_7 : TopologicalSpace Q} →
{inst_8 : AddTorsor W Q} →
{t : P_1 →ᴬ[R] Q} →
{R' : Type u_1} →
{V' : Type u_2} →
{W' : Type u_3} →
{P' : Type u_4} →
{Q' : Type u_5} →
{inst' : Ring R'} →
{inst'_1 : AddCommGroup V'} →
{inst'_2 : Module R' V'} →
{inst'_3 : TopologicalSpace P'} →
{inst'_4 : AddTorsor V' P'} →
{inst'_5 : AddCommGroup W'} →
{inst'_6 : Module R' W'} →
{inst'_7 : TopologicalSpace Q'} →
{inst'_8 : AddTorsor W' Q'} →
{t' : P' →ᴬ[R'] Q'} →
R = R' →
V = V' →
W = W' →
P_1 = P' →
Q = Q' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 →
inst_6 ≍ inst'_6 →
inst_7 ≍ inst'_7 →
inst_8 ≍ inst'_8 →
t ≍ t' →
ContinuousAffineMap.noConfusionType
P t t' |
FirstOrder.Language.Equiv.coe_toElementaryEmbedding | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Equiv M N), ⇑f.toElementaryEmbedding = ⇑f |
_private.Mathlib.LinearAlgebra.TensorProduct.Graded.External.0.TensorProduct.term𝒜ℬ | Mathlib.LinearAlgebra.TensorProduct.Graded.External | Lean.ParserDescr |
Nat.pairEquiv_symm_apply | Mathlib.Data.Nat.Pairing | ⇑Nat.pairEquiv.symm = Nat.unpair |
CategoryTheory.Functor.mapHomologicalComplex._proof_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_5} {W₁ : Type u_4} {W₂ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} W₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (F : CategoryTheory.Functor W₁ W₂) [F.PreservesZeroMorphisms]
(c : ComplexShape ι) (C : HomologicalComplex W₁ c) (i j : ι), ¬c.Rel i j → F.map (C.d i j) = 0 |
Lean.Meta.hcongrThmSuffixBase | Lean.Meta.CongrTheorems | String |
Lean.IR.Alt.ctorElim | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
(ctorIdx : ℕ) → (t : Lean.IR.Alt) → ctorIdx = t.ctorIdx → Lean.IR.Alt.ctorElimType ctorIdx → motive_1 t |
ProbabilityTheory.mgf_zero_fun | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {t : ℝ},
ProbabilityTheory.mgf 0 μ t = μ.real Set.univ |
Lean.Compiler.LCNF.Simp.JpCasesInfo._sizeOf_inst | Lean.Compiler.LCNF.Simp.JpCases | SizeOf Lean.Compiler.LCNF.Simp.JpCasesInfo |
denseRange_stoneCechUnit | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} [inst : TopologicalSpace α], DenseRange stoneCechUnit |
CategoryTheory.Limits.widePullback.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C)
(arrows arrows_1 : (j : J) → objs j ⟶ B) (e_arrows : arrows = arrows_1)
[inst_1 : CategoryTheory.Limits.HasWidePullback B objs arrows],
CategoryTheory.Limits.widePullback B objs arrows = CategoryTheory.Limits.widePullback B objs arrows_1 |
Lean.Parser.Attr.class.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer |
_private.Mathlib.LinearAlgebra.Span.Basic.0.Submodule.biSup_comap_subtype_eq_top.match_1_1 | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_3}
(s : Set ι) (p : ι → Submodule R M) (motive : (x : ↥(⨆ i ∈ s, p i)) → x ∈ ⊤ → Prop) (x : ↥(⨆ i ∈ s, p i))
(x_1 : x ∈ ⊤), (∀ (x : M) (hx : x ∈ ⨆ i ∈ s, p i) (x_2 : ⟨x, hx⟩ ∈ ⊤), motive ⟨x, hx⟩ x_2) → motive x x_1 |
CategoryTheory.Functor.Initial.extendCone_obj_pt | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} [inst_2 : F.Initial] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (c : CategoryTheory.Limits.Cone (F.comp G)),
(CategoryTheory.Functor.Initial.extendCone.obj c).pt = c.pt |
IsLocalRing.ResidueField.instMulSemiringAction | Mathlib.RingTheory.LocalRing.ResidueField.Basic | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : IsLocalRing R] →
(G : Type u_4) → [inst_2 : Group G] → [MulSemiringAction G R] → MulSemiringAction G (IsLocalRing.ResidueField R) |
LinearMap.isUnit_toMatrix_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_4} [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M₁ : Type u_5}
[inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] (v₁ : Module.Basis n R M₁) {f : M₁ →ₗ[R] M₁},
IsUnit ((LinearMap.toMatrix v₁ v₁) f) = IsUnit f |
FinPartOrd.id_apply | Mathlib.Order.Category.FinPartOrd | ∀ (X : FinPartOrd) (x : ↑X.toPartOrd), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)) x = x |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0.Lean.Meta.Grind.Arith.isNormNatNum | Lean.Meta.Tactic.Grind.Arith.Simproc | Lean.Expr → Lean.Expr → Lean.Expr → Bool |
tendsto_nhds_unique_of_eventuallyEq | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [T2Space X] {f g : Y → X} {l : Filter Y} {a b : X}
[l.NeBot], Filter.Tendsto f l (nhds a) → Filter.Tendsto g l (nhds b) → f =ᶠ[l] g → a = b |
CategoryTheory.Idempotents.Karoubi.decomposition._proof_2 | Mathlib.CategoryTheory.Idempotents.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.lift P.decompId_p P.complement.decompId_p)
(CategoryTheory.Limits.biprod.desc P.decompId_i P.complement.decompId_i) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Idempotents.toKaroubi C).obj P.X) |
CategoryTheory.Iso.inv_ext._to_dual_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : X ⟶ Y},
CategoryTheory.CategoryStruct.comp g f.inv = CategoryTheory.CategoryStruct.id X → f.hom = g |
sdiff_sdiff_sup_sdiff' | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], z \ (x \ y ⊔ y \ x) = z ⊓ x ⊓ y ⊔ z \ x ⊓ z \ y |
RingHom.smulOneHom | Mathlib.Algebra.Module.RingHom | {R : Type u_1} →
{S : Type u_2} →
[inst : Semiring R] → [inst_1 : NonAssocSemiring S] → [inst_2 : Module R S] → [IsScalarTower R S S] → R →+* S |
CategoryTheory.SimplicialObject.equivalenceLeftToRight | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] →
(X : CategoryTheory.SimplicialObject.Augmented C) →
(F : CategoryTheory.Arrow C) →
(CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F) → (X ⟶ F.augmentedCechNerve) |
AffineSubspace.mem_perpBisector_iff_dist_eq' | Mathlib.Geometry.Euclidean.PerpBisector | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c p₁ p₂ : P}, c ∈ AffineSubspace.perpBisector p₁ p₂ ↔ dist p₁ c = dist p₂ c |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._simp_6 | Init.Data.String.Pattern.String | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) |
String.length_ofList | Init.Data.String.Basic | ∀ {l : List Char}, (String.ofList l).length = l.length |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.recOn | Lean.Util.ParamMinimizer | {m : Type → Type} →
{motive : Lean.Util.ParamMinimizer.Context✝ m → Sort u} →
(t : Lean.Util.ParamMinimizer.Context✝¹ m) →
((initialMask : Array Bool) →
(test : Array Bool → m Bool) →
(maxCalls : ℕ) → motive { initialMask := initialMask, test := test, maxCalls := maxCalls }) →
motive t |
AddSubsemigroup.instSetLike.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M], AddSubsemigroup.instSetLike = { coe := AddSubsemigroup.carrier, coe_injective' := ⋯ } |
Lean.Elab.Structural.IndGroupInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.IndGroupInfo | Lean.Elab.Structural.IndGroupInfo → ℕ |
_private.Mathlib.Algebra.Order.GroupWithZero.Bounds.0.BddAbove.range_comp_of_nonneg._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Bounds | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x |
Lean.Server.StatefulRequestHandler.mk | Lean.Server.Requests | (Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri) →
(Lean.Json → Dynamic → Lean.Server.RequestM (Lean.Server.SerializedLspResponse × Dynamic)) →
(Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse)) →
(Lean.Lsp.DidChangeTextDocumentParams → StateT Dynamic Lean.Server.RequestM Unit) →
(Lean.Lsp.DidChangeTextDocumentParams → Lean.Server.RequestM Unit) →
Std.Mutex (Lean.Server.ServerTask Unit) →
Dynamic → IO.Ref Dynamic → Lean.Server.RequestHandlerCompleteness → Lean.Server.StatefulRequestHandler |
NormedAddGroupHom.Equalizer.liftEquiv._proof_4 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_3} {V₁ : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W},
Function.RightInverse (fun ψ => ⟨(NormedAddGroupHom.Equalizer.ι f g).comp ψ, ⋯⟩) fun φ =>
NormedAddGroupHom.Equalizer.lift ↑φ ⋯ |
ULift.divisionRing._proof_1 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : DivisionRing α] (a b : ULift.{u_1, u_2} α), a / b = a * b⁻¹ |
CategoryTheory.Limits.PushoutCocone.inl | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} → {f : X ⟶ Y} → {g : X ⟶ Z} → (t : CategoryTheory.Limits.PushoutCocone f g) → Y ⟶ t.pt |
_private.Lean.Environment.0.Lean.RealizationContext | Lean.Environment | Type |
BoolAlg.hom_id | Mathlib.Order.Category.BoolAlg | ∀ {X : BoolAlg}, BoolAlg.Hom.hom (CategoryTheory.CategoryStruct.id X) = BoundedLatticeHom.id ↑X |
AddLocalization.addEquivOfQuotient_mk | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
{f : S.LocalizationMap N} (x : M) (y : ↥S),
(AddLocalization.addEquivOfQuotient f) (AddLocalization.mk x y) = f.mk' x y |
CompactlySupportedContinuousMap.integralPositiveLinearMap._proof_2 | Mathlib.MeasureTheory.Integral.CompactlySupported | ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOrderedAddMonoid (CompactlySupportedContinuousMap X ℝ) |
NonUnitalStarAlgHom.fst_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ (R : Type u_1) (A : Type u_2) (B : Type u_3) [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : Star B] (self : A × B), (NonUnitalStarAlgHom.fst R A B) self = self.1 |
Lean.Meta.Grind.Arith.Cutsat.reorderVarMap | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | {α : Type u_1} → [Inhabited α] → Lean.PArray α → Array Int.Linear.Var → Lean.PArray α |
QuadraticModuleCat.Hom._sizeOf_inst | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → {inst : CommRing R} → (V W : QuadraticModuleCat R) → [SizeOf R] → SizeOf (V.Hom W) |
List.getLast_filterMap | Init.Data.List.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α} (h : List.filterMap f l ≠ []),
(List.filterMap f l).getLast h = (List.findSome? f l.reverse).get ⋯ |
PosMulReflectLT.toPosMulMono | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLT α], PosMulMono α |
Ideal.Quotient.mkₐ._proof_5 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_2) {A : Type u_1} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided] (x : R₁),
(↑↑{ toFun := fun a => Submodule.Quotient.mk a, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
((algebraMap R₁ A) x) =
(↑↑{ toFun := fun a => Submodule.Quotient.mk a, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ }).toFun
((algebraMap R₁ A) x) |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_cons_zero._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {a : α},
List.findIdxNth p (a :: xs) 0 = if p a = true then 0 else List.findIdxNth p xs 0 + 1 |
CategoryTheory.LocalizerMorphism.IsLocalizedEquivalence.mk._flat_ctor | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂},
(Φ.localizedFunctor W₁.Q W₂.Q).IsEquivalence → Φ.IsLocalizedEquivalence |
CategoryTheory.InducedCategory.isGroupoid | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u} (D : Type u₂) [inst : CategoryTheory.Category.{v, u₂} D] [CategoryTheory.IsGroupoid D] (F : C → D),
CategoryTheory.IsGroupoid (CategoryTheory.InducedCategory D F) |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.checkForInductionWithNoAlts.match_1 | Lean.Elab.Tactic.Induction | (motive : Lean.Syntax → Sort u_1) →
(optInductionAlts : Lean.Syntax) →
((info info_1 info_2 info_3 info_4 : Lean.SourceInfo) →
(var : Lean.Syntax) →
motive
(Lean.Syntax.node info `null
#[Lean.Syntax.node info_1 `Lean.Parser.Tactic.inductionAlts
#[Lean.Syntax.atom info_2 "with",
Lean.Syntax.node info_3 `null
#[Lean.Syntax.node info_4 `Lean.Parser.Tactic.unknown #[var, Lean.Syntax.missing]]]])) →
((x : Lean.Syntax) → motive x) → motive optInductionAlts |
CategoryTheory.ShortComplex.QuasiIso.congr_simp | Mathlib.Algebra.Homology.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ φ_1 : S₁ ⟶ S₂),
φ = φ_1 → CategoryTheory.ShortComplex.QuasiIso φ = CategoryTheory.ShortComplex.QuasiIso φ_1 |
PosSMulReflectLT.rec | Mathlib.Algebra.Order.Module.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : SMul α β] →
[inst_1 : Preorder α] →
[inst_2 : Preorder β] →
[inst_3 : Zero α] →
{motive : PosSMulReflectLT α β → Sort u} →
((lt_of_smul_lt_smul_left : ∀ ⦃a : α⦄, 0 ≤ a → ∀ ⦃b₁ b₂ : β⦄, a • b₁ < a • b₂ → b₁ < b₂) → motive ⋯) →
(t : PosSMulReflectLT α β) → motive t |
Std.Time.PlainDateTime.weekOfMonth | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Internal.Bounded.LE 1 5 |
_private.Mathlib.MeasureTheory.Measure.SeparableMeasure.0.MeasureTheory.Lp.SecondCountableTopology.match_3 | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_2} {E : Type u_1} [m : MeasurableSpace X] [inst : NormedAddCommGroup E] {μ : MeasureTheory.Measure X}
{p : ENNReal} (u : Set E) (a : E) {s : Set X} (ε : ℝ)
(motive : (∃ b ∈ u, ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)))) → Prop)
(x : ∃ b ∈ u, ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)))),
(∀ (b : E) (b_mem : b ∈ u) (hb : ‖a - b‖ < ε / (3 * (1 + μ.real s ^ (1 / p.toReal)))), motive ⋯) → motive x |
OrderIso.mapSetOfMaximal._proof_9 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t)
(x : ↑{x | Maximal (fun x => x ∈ t) x}), ⟨↑(f ⟨↑⟨↑(f.symm ⟨↑x, ⋯⟩), ⋯⟩, ⋯⟩), ⋯⟩ = x |
NNReal.natCast_iInf | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_3} (f : ι → ℕ), ↑(⨅ i, f i) = ⨅ i, ↑(f i) |
IsCoprime.divRadical | Mathlib.RingTheory.Radical.Basic | ∀ {E : Type u_1} [inst : EuclideanDomain E] [inst_1 : NormalizationMonoid E] [inst_2 : UniqueFactorizationMonoid E]
{a b : E}, IsCoprime a b → IsCoprime (EuclideanDomain.divRadical a) (EuclideanDomain.divRadical b) |
Std.DTreeMap.Const.compare_minKey?_modify_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : β → β} {km kmm : α} (hkm : t.minKey? = some km),
(Std.DTreeMap.Const.modify t k f).minKey?.get ⋯ = kmm → cmp kmm km = Ordering.eq |
EST.Out.noConfusion | Init.System.ST | {P : Sort u} →
{ε σ α : Type} →
{t : EST.Out ε σ α} →
{ε' σ' α' : Type} → {t' : EST.Out ε' σ' α'} → ε = ε' → σ = σ' → α = α' → t ≍ t' → EST.Out.noConfusionType P t t' |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanMap.match_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u_4} →
{C : Type u_5} →
[inst : CategoryTheory.Category.{u_2, u_4} C₀] →
[inst_1 : CategoryTheory.Category.{u_3, u_5} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} →
(data : F.PreOneHypercoverDenseData X) →
(motive : CategoryTheory.Limits.WalkingMulticospan data.multicospanShape → Sort u_6) →
(x : CategoryTheory.Limits.WalkingMulticospan data.multicospanShape) →
((i : data.multicospanShape.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((j : data.multicospanShape.R) → motive (CategoryTheory.Limits.WalkingMulticospan.right j)) →
motive x |
_private.Lean.Compiler.LCNF.Passes.0.Lean.Compiler.LCNF.addPass._sparseCasesOn_3 | Lean.Compiler.LCNF.Passes | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Topology.IsClosedEmbedding.comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsClosedEmbedding g → Topology.IsClosedEmbedding f → Topology.IsClosedEmbedding (g ∘ f) |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstanceImp | Lean.Meta.Basic | {α : Type} → Lean.Name → Lean.Expr → Lean.MetaM α → Lean.MetaM α |
Simps.ProjectionData.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {name : Lean.Name} {expr : Lean.Expr} {projNrs : List ℕ} {isDefault isPrefix : Bool} {name_1 : Lean.Name}
{expr_1 : Lean.Expr} {projNrs_1 : List ℕ} {isDefault_1 isPrefix_1 : Bool},
{ name := name, expr := expr, projNrs := projNrs, isDefault := isDefault, isPrefix := isPrefix } =
{ name := name_1, expr := expr_1, projNrs := projNrs_1, isDefault := isDefault_1, isPrefix := isPrefix_1 } →
name = name_1 ∧ expr = expr_1 ∧ projNrs = projNrs_1 ∧ isDefault = isDefault_1 ∧ isPrefix = isPrefix_1 |
instContinuousNegElemBallOfNat | Mathlib.Analysis.Normed.Group.BallSphere | ∀ {E : Type u_1} [i : SeminormedAddCommGroup E] {r : ℝ}, ContinuousNeg ↑(Metric.ball 0 r) |
Std.Time.TimeZone.GMT | Std.Time.Zoned.TimeZone | Std.Time.TimeZone |
Coalgebra.Repr.mk.sizeOf_spec | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] {a : A} [inst_4 : SizeOf R] [inst_5 : SizeOf A] {ι : Type u_1} (index : Finset ι)
(left right : ι → A) (eq : ∑ i ∈ index, left i ⊗ₜ[R] right i = CoalgebraStruct.comul a),
sizeOf { ι := ι, index := index, left := left, right := right, eq := eq } = 1 + sizeOf ι + sizeOf index + sizeOf eq |
Action.res._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_4} {H : Type u_3} [inst_1 : Monoid G]
[inst_2 : Monoid H] (f : G →* H) {X Y Z : Action V H} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
{ hom := (CategoryTheory.CategoryStruct.comp f_1 g).hom, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := f_1.hom, comm := ⋯ } { hom := g.hom, comm := ⋯ } |
CategoryTheory.ComonObj._aux_Mathlib_CategoryTheory_Monoidal_Comon____unexpand_CategoryTheory_ComonObj_comul_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.PrettyPrinter.Unexpander |
_private.Mathlib.Data.Finset.Sups.0.Finset.filter_sups_le._simp_1_2 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ ↑s) |
IsUnit.unit_map | Mathlib.Algebra.Group.Units.Hom | ∀ {F : Type u_1} {M : Type u_3} {N : Type u_4} [inst : FunLike F M N] [inst_1 : Monoid M] [inst_2 : Monoid N]
[inst_3 : MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x), ↑⋯.unit = f ↑h.unit |
Char.succ?_eq | Init.Data.Char.Ordinal | ∀ {c : Char}, c.succ? = Option.map Char.ofOrdinal (c.ordinal.addNat? 1) |
PartialEquiv.transEquiv_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ),
(e.transEquiv f').target = ⇑f'.symm ⁻¹' e.target |
PerfectClosure.lift._proof_3 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (L : Type u_2)
[inst_3 : CommSemiring L] [inst_4 : CharP L p] [inst_5 : PerfectRing L p],
Function.LeftInverse (fun f => f.comp (PerfectClosure.of K p)) fun f =>
{ toFun := fun e => e.liftOn (fun x => (⇑(frobeniusEquiv L p).symm)^[x.1] (f x.2)) ⋯, map_one' := ⋯, map_mul' := ⋯,
map_zero' := ⋯, map_add' := ⋯ } |
mul_neg_mem | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : HasDistribNeg R] [inst_2 : SetLike S R] [MulMemClass S R]
{s : S} {x y : R}, x ∈ s → -y ∈ s → -(x * y) ∈ s |
Set.Iic_union_Ici | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Iic a ∪ Set.Ici a = Set.univ |
LLVM.moduleToString | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Module ctx → BaseIO String |
Real.exp_neg_one_lt_d9 | Mathlib.Analysis.Complex.ExponentialBounds | Real.exp (-1) < 0.3678794412 |
subset_supClosure | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeSup α] {s : Set α}, s ⊆ supClosure s |
Function.support_mul' | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] (f g : ι → M₀),
Function.support (f * g) = Function.support f ∩ Function.support g |
Homeomorph.contractibleSpace_iff | Mathlib.Topology.Homotopy.Contractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
ContractibleSpace X ↔ ContractibleSpace Y |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_1.eq_2 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3) (it : Std.IterM m α)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.skip it with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it => h_2 it
| Std.IterStep.done => h_3 ()) =
h_2 it |
List.IsChain.nil._simp_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {R : α → α → Prop}, List.IsChain R [] = True |
Matrix.GeneralLinearGroup.upperRightHom._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : Ring R] (x : R), !![1, x; 0, 1] * !![1, -x; 0, 1] = 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.