name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Metric.hausdorffDist_comm | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α}, Metric.hausdorffDist s t = Metric.hausdorffDist t s | The Hausdorff distances from `s` to `t` and from `t` to `s` coincide. | true |
Lean.Linter.LinterOptions._sizeOf_inst | Lean.Linter.Init | SizeOf Lean.Linter.LinterOptions | null | false |
Submodule.mem_neg | Mathlib.Algebra.Module.Submodule.Pointwise | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {g : M}
{S : Submodule R M}, g ∈ -S ↔ -g ∈ S | null | true |
_private.Mathlib.Algebra.Field.Subfield.Basic.0.Subfield.mem_map._simp_1_2 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {f : R →+* S} {s : Subring R} {y : S},
(y ∈ Subring.map f s) = ∃ x ∈ s, f x = y | null | false |
Module.Basis.toDual_linearCombination_right | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) (f : ι →₀ R) (i : ι),
(b.toDual (b i)) ((Finsupp.linearCombination R ⇑b) f) = f i | null | true |
Monoid.CoprodI.FreeGroupBasis.coprodI._proof_2 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {X : ι → Type u_3} {G : ι → Type u_2} [inst : (i : ι) → Group (G i)]
(B : (i : ι) → FreeGroupBasis (X i) (G i)),
(FreeGroup.lift fun x => Monoid.CoprodI.of ((B x.fst) x.snd)).comp
(Monoid.CoprodI.lift fun i => (B i).lift fun x => FreeGroup.of ⟨i, x⟩) =
MonoidHom.id (Monoid.CoprodI G) | null | false |
isQuotientCoveringMap_quotientMk_of_properlyDiscontinuousSMul | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} [inst : TopologicalSpace E] {G : Type u_3} [inst_1 : Group G] [inst_2 : MulAction G E]
[ContinuousConstSMul G E] [ProperlyDiscontinuousSMul G E] [LocallyCompactSpace E] [T2Space E] [IsCancelSMul G E],
IsQuotientCoveringMap (Quotient.mk (MulAction.orbitRel G E)) G | null | true |
TopModuleCat.ker._proof_3 | Mathlib.Algebra.Category.ModuleCat.Topology.Homology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R] {M N : TopModuleCat R} (φ : M ⟶ N),
ContinuousSMul R ↥(↑(TopModuleCat.Hom.hom φ)).ker | null | false |
BddDistLat.mk.inj | Mathlib.Order.Category.BddDistLat | ∀ {toDistLat : DistLat} {isBoundedOrder : BoundedOrder ↑toDistLat} {toDistLat_1 : DistLat}
{isBoundedOrder_1 : BoundedOrder ↑toDistLat_1},
{ toDistLat := toDistLat, isBoundedOrder := isBoundedOrder } =
{ toDistLat := toDistLat_1, isBoundedOrder := isBoundedOrder_1 } →
toDistLat = toDistLat_1 ∧ isBoundedOr... | null | true |
NormedSpace.logSeries_apply_eq | Mathlib.Analysis.Normed.Algebra.Logarithm | ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (x : 𝔸) (n : ℕ),
((NormedSpace.logSeries 𝕂 𝔸 n) fun x_1 => x) = ((-1) ^ (n + 1) / ↑n) • x ^ n | null | true |
CategoryTheory.Functor.Initial.limitIso_inv | 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) [inst_4 : CategoryTheory.Limits.HasLimit G],
(C... | null | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mk? | Lean.Meta.CongrTheorems | Bool → Lean.Expr → Lean.Meta.FunInfo → Array Lean.Meta.CongrArgKind → Lean.MetaM (Option Lean.Meta.CongrTheorem) | Create a congruence theorem that is useful for the simplifier.
In this kind of theorem, if the i-th argument is a `cast` argument, then the theorem
contains an input `a_i` representing the i-th argument in the left-hand-side, and
it appears with a cast (e.g., `Eq.rec ... a_i ...`) in the right-hand-side.
The idea is th... | true |
IocProdIoc.eq_1 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
(a b c : ι) (x : ((i : ↥(Finset.Ioc a b)) → X ↑i) × ((i : ↥(Finset.Ioc b c)) → X ↑i)) (i : ↥(Finset.Ioc a c)),
IocProdIoc a b c x i = if h : ↑i ≤ b then x.1 ⟨↑i, ⋯⟩ else x.2 ⟨↑i, ⋯⟩ | null | true |
Aesop.UnorderedArraySet | Aesop.Util.UnorderedArraySet | (α : Type u_1) → [BEq α] → Type u_1 | null | true |
tangentBundleCore._proof_4 | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {H : Type u_1} [inst : TopologicalSpace H] (M : Type u_2) [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(i : ↑(atlas H M)), IsOpen (↑i).source | null | false |
CategoryTheory.Limits.StrongEpiMonoFactorisation.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Limits.StrongEpiMonoFactorisation f → Sort u_1} →
(t : CategoryTheory.Limits.StrongEpiMonoFactorisation f) →
((toMonoFactorisation : CategoryTheory.Limits.MonoFactorisa... | null | false |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.State.ctorIdx | Mathlib.Tactic.GRewrite.Core | Mathlib.Tactic.GRewrite.State✝ → ℕ | null | false |
Std.DHashMap.Internal.AssocList.getCast?._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [LawfulBEq α] → (a : α) → Std.DHashMap.Internal.AssocList α β → Option (β a) | null | false |
AlgHom.extendScalarsHomOfSurjective_symm_apply | Mathlib.Algebra.Algebra.Tower | ∀ {R : Type u} {S : Type v} {A : Type w} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R S A]
(h : Function.Surjective ⇑(algebraMap R S)) (f : A →ₐ[S] A),
(AlgHom.extendScalarsHomOfSurjective h).... | null | true |
Array.attach_map_val | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} (xs : Array α) (f : α → β), Array.map (fun i => f ↑i) xs.attach = Array.map f xs | null | true |
Vector.count_push_self | Init.Data.Vector.Count | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {n : ℕ} {a : α} {xs : Vector α n},
Vector.count a (xs.push a) = Vector.count a xs + 1 | null | true |
AddHom.ENatMap | Mathlib.Data.ENat.Basic | {N : Type u_2} → [inst : Add N] → (ℕ →ₙ+ N) → ℕ∞ →ₙ+ WithTop N | A version of `WithTop.map` for `AddHom`s. | true |
CategoryTheory.Limits.kernel | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasKernel f] → C | The kernel of a morphism, expressed as the equalizer with the 0 morphism. | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenrange_nat._simp_1_3 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | null | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.recordSimpTheorem.match_3 | Lean.Meta.Tactic.Simp.Types | (motive : Lean.Meta.Origin → Sort u_1) →
(thmId : Lean.Meta.Origin) →
((declName : Lean.Name) → (post : Bool) → motive (Lean.Meta.Origin.decl declName post)) →
((x : Lean.Meta.Origin) → motive x) → motive thmId | null | false |
Aesop.IndexingMode.below | Aesop.Index.Basic | {motive_1 : Aesop.IndexingMode → Sort u} →
{motive_2 : Array Aesop.IndexingMode → Sort u} →
{motive_3 : List Aesop.IndexingMode → Sort u} → Aesop.IndexingMode → Sort (max 1 u) | null | false |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.jp.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{name : Lean.Name} →
{jpId : Lean.FVarId} →
{name' : Lean.Name} →
{jpId' : Lean.FVarId} →
Lean.Compiler.LCNF.ParamMap.Key.jp✝ name jpId = Lean.Compiler.LCNF.ParamMap.Key.jp✝ name' jpId' →
(name = name' → jpId = jpId' → P) → P | null | false |
MeasureTheory.FiniteMeasure.map_apply_of_aemeasurable | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} {Ω' : Type u_2} [inst : MeasurableSpace Ω] [inst_1 : MeasurableSpace Ω']
(ν : MeasureTheory.FiniteMeasure Ω) {f : Ω → Ω'},
AEMeasurable f ↑ν → ∀ {A : Set Ω'}, MeasurableSet A → (ν.map f) A = ν (f ⁻¹' A) | null | true |
Std.DTreeMap.Internal.Impl.getEntryGT?ₘ' | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → Option ((a : α) × β a) | Implementation detail of the tree map | true |
FirstOrder.Language.isRelational_sum | Mathlib.ModelTheory.Basic | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} [L.IsRelational] [L'.IsRelational], (L.sum L').IsRelational | null | true |
Convex.setOf_const_imp | Mathlib.Analysis.Convex.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] {s : Set E} {P : Prop}, Convex 𝕜 s → Convex 𝕜 {x | P → x ∈ s} | **Alias** of `Convex.setOfPred_const_imp`. | true |
PLift.down_inj._simp_1 | Mathlib.Logic.Function.ULift | ∀ {α : Sort u_1} {a b : PLift α}, (a.down = b.down) = (a = b) | null | false |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_44 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ') (k : Turing.PartrecToTM2.Cont'),
¬Turing.PartrecToTM2.Λ'.read f = Turing.PartrecToTM2.Λ'.ret k | null | false |
KaehlerDifferential.polynomialEquiv_symm | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u) [inst : CommRing R] (P : Polynomial R),
(KaehlerDifferential.polynomialEquiv R).symm P = P • (KaehlerDifferential.D R (Polynomial R)) Polynomial.X | null | true |
Std.TreeMap.getKeyD_filterMap | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp]
{f : α → β → Option γ} {k fallback : α},
(Std.TreeMap.filterMap f t).getKeyD k fallback = ((t.getKey? k).pfilter fun x h' => (f x t[x]).isSome).getD fallback | null | true |
_private.Mathlib.Data.Fintype.Basic.0.Fin.univ_image_getElem'._proof_1 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} (l : List α) (i : Fin l.length), ¬↑i < l.length → False | null | false |
RingCat.hasForgetToSemiRingCat | Mathlib.Algebra.Category.Ring.Basic | CategoryTheory.HasForget₂ RingCat SemiRingCat | null | true |
GenLoop.fromLoop_symm_toLoop | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] {i : N}
{p : ↑(GenLoop N X x)}, GenLoop.fromLoop i (Path.symm (GenLoop.toLoop i p)) = GenLoop.symmAt i p | null | true |
AddSubmonoid.add_subset_closure | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {M : Type u_3} [inst : AddMonoid M] {s t u : Set M}, s ⊆ u → t ⊆ u → s + t ⊆ ↑(AddSubmonoid.closure u) | null | true |
_private.Mathlib.Topology.CWComplex.Classical.Graph.0.Topology.CWComplex.OneSkeletonGraph.exists_isLoopAt_iff_subsingleton.match_1_1 | Mathlib.Topology.CWComplex.Classical.Graph | ∀ {X : Type u_1} [inst : TopologicalSpace X] {C : Set X} [inst_1 : Topology.CWComplex C]
(e : Topology.RelCWComplex.cell C 1)
(motive : (∃ x, Topology.RelCWComplex.cellFrontier 1 e = Topology.RelCWComplex.closedCell 0 x) → Prop)
(x : ∃ x, Topology.RelCWComplex.cellFrontier 1 e = Topology.RelCWComplex.closedCell 0... | null | false |
CategoryTheory.Pretriangulated.Triangle.instAddCommGroupHom._proof_8 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Preadditive C] [∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (n : ℤ),
CategoryTheory.Functor.Linear ℤ (CategoryTheory.shiftFunctor C n) | null | false |
AddCommGrpCat.instCategory.eq_1 | Mathlib.Algebra.Category.Grp.Basic | AddCommGrpCat.instCategory =
{ Hom := fun X Y => X.Hom Y, id := fun X => { hom' := AddMonoidHom.id ↑X },
comp := fun {X Y Z} f g => { hom' := g.hom'.comp f.hom' }, id_comp := @AddCommGrpCat.instCategory._proof_1,
comp_id := @AddCommGrpCat.instCategory._proof_2, assoc := @AddCommGrpCat.instCategory._proof_3 } | null | true |
SemiconjBy.function_semiconj_mul_left | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Semigroup G] {a b c : G},
SemiconjBy a b c → Function.Semiconj (fun x => a * x) (fun x => b * x) fun x => c * x | null | true |
CategoryTheory.Sheaf.pushforwardOverMapIso_inv_hom_app | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] (F : CategoryTheory.Sheaf J A) {X Y : C} (f : X ⟶ Y)
(X_1 : (CategoryTheory.Over X)ᵒᵖ),
(F.pushforwardOverMapIso f).inv.hom.app X_1 =
CategoryTheory.... | null | true |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.integrable_tilted_iff._simp_1_2 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) | null | false |
AlgebraicGeometry.SheafedSpace.toPresheafedSpace | Mathlib.Geometry.RingedSpace.SheafedSpace | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → AlgebraicGeometry.SheafedSpace C → AlgebraicGeometry.PresheafedSpace C | null | true |
CategoryTheory.instHasImagesSheafType | Mathlib.CategoryTheory.Sites.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C},
CategoryTheory.Limits.HasImages (CategoryTheory.Sheaf J (Type (max v u))) | null | true |
ConcaveOn.mul_convexOn' | Mathlib.Analysis.Convex.Mul | ∀ {𝕜 : Type u_1} {E : Type u_2} {G : Type u_4} [inst : CommRing 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : CommRing E] [inst_4 : LinearOrder E] [IsStrictOrderedRing E] [inst_6 : AddCommGroup G] [inst_7 : Module 𝕜 G]
[inst_8 : Module 𝕜 E] {s : Set G} [IsOrderedModule 𝕜 E] [IsScalarTower 𝕜 ... | null | true |
Std.TreeMap.Raw.compare_maxKeyD_modify_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {f : β → β} {fallback : α}, cmp ((t.modify k f).maxKeyD fallback) (t.maxKeyD fallback) = Ordering.eq | null | true |
AlgCat.limitSemiring._proof_7 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget (... | null | false |
Function.isFixedPt_piMap | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → α i → α i} {x : (i : ι) → α i},
Function.IsFixedPt (Pi.map f) x ↔ ∀ (i : ι), Function.IsFixedPt (f i) (x i) | null | true |
Affine.Triangle.mem_circumsphere_of_two_zsmul_oangle_eq | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{t : Affine.Triangle ℝ P} {p : P} {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ →
i₁ ≠ i₃ →
i₂... | Given a triangle, and a fourth point such that twice the angle between two points of the
triangle at that fourth point equals twice the third angle of the triangle, the fourth point
lies in the circumsphere of the triangle. | true |
_private.Mathlib.Order.SuccPred.Basic.0.WithBot.succ_unbot.match_1_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} (motive : (x : WithBot α) → x ≠ ⊥ → Prop) (x : WithBot α) (x_1 : x ≠ ⊥),
(∀ (ha : ⊥ ≠ ⊥), motive none ha) → (∀ (a : α) (x : ↑a ≠ ⊥), motive (some a) x) → motive x x_1 | null | false |
Lean.Lsp.TextDocumentPositionParams._sizeOf_inst | Lean.Data.Lsp.Basic | SizeOf Lean.Lsp.TextDocumentPositionParams | null | false |
Partition.IsRepFun.forall_apply_eq_apply_iff | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {u : Set α} {P : Partition u} {f : α → α},
P.IsRepFun f → ∀ (a : α), (∀ (x : α), f a = f x ↔ a = x) ∨ ∀ (x : α), f a = f x ↔ P.Rel a x | null | true |
SSet.Edge.InvStruct.invStructInv_homInvId | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X : SSet} {x₀ x₁ : X.obj (Opposite.op { len := 0 })} {hom : SSet.Edge x₀ x₁} (I : hom.InvStruct),
I.invStructInv.homInvId = I.invHomId | null | true |
Vector.range'_eq_mk_range'._proof_1 | Init.Data.Vector.Range | ∀ {start size step : ℕ}, (Array.range' start size step).size = size | null | false |
CategoryTheory.MorphismProperty.CodescendsAlong.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
(∀ {Z X Y A : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ A} {inr : Y ⟶ A},
CategoryTheory.IsPushout f g inl inr → Q f → P inl → P g) →
P.CodescendsAlong Q | null | false |
Cubic.discr._proof_3 | Mathlib.Algebra.CubicDiscriminant | (17 + 1).AtLeastTwo | null | false |
FirstOrder.Language.presburger.instSMulNatTerm | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | {α : Type u_1} → SMul ℕ (FirstOrder.Language.presburger.Term α) | null | true |
instLEOption | Init.Data.Option.Basic | {α : Type u_1} → [LE α] → LE (Option α) | null | true |
MulEquiv.rec | Mathlib.Algebra.Group.Equiv.Defs | {M : Type u_9} →
{N : Type u_10} →
[inst : Mul M] →
[inst_1 : Mul N] →
{motive : M ≃* N → Sort u} →
((toEquiv : M ≃ N) →
(map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) →
motive { toEquiv := toEquiv, map_mul' := map_mul' }) ... | null | false |
AddSubgroup.mem_goursatSnd._simp_1 | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] {I : AddSubgroup (G × H)} {h : H},
(h ∈ I.goursatSnd) = ((0, h) ∈ I) | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.id.match_1.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} (motive : CategoryTheory.WithInitial C → Sort u_2)
(h_1 : (a : C) → motive (CategoryTheory.WithInitial.of a)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of a => h_1 a
| CategoryTheory.WithInitial.star => h_... | null | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.not_subsingleton_iff._simp_1_3 | Mathlib.Data.Set.Subsingleton | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
instAddCommGroupFreeAbelianGroup._aux_1 | Mathlib.GroupTheory.FreeAbelianGroup | (α : Type u_1) → FreeAbelianGroup α | null | false |
CommRingCat.equalizer_ι_isLocalHom | Mathlib.Algebra.Category.Ring.Constructions | ∀ (F : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair CommRingCat),
IsLocalHom (CommRingCat.Hom.hom (CategoryTheory.Limits.limit.π F CategoryTheory.Limits.WalkingParallelPair.zero)) | null | true |
FirstOrder.Language.BoundedFormula.realize_rel₁ | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
{R : L.Relations 1} {t : L.Term (α ⊕ Fin l)},
(R.boundedFormula₁ t).Realize v xs ↔
FirstOrder.Language.Structure.RelMap R ![FirstOrder.Language.Term.realize (Sum.elim v xs) t] | null | true |
Valuation.IsEquiv.valueGroup₀Fun._proof_1 | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_2} {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] {v : Valuation R Γ₀}
(d : { xy // ↑v xy.1 ≠ 0 ∧ ↑v xy.2 ≠ 0 }), ↑v (↑d).1 ≠ 0 | null | false |
ModelWithCorners.continuous_invFun._autoParam | Mathlib.Geometry.Manifold.IsManifold.Basic | Lean.Syntax | null | false |
CategoryTheory.MorphismProperty.transfiniteCompositions_le | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderTransfiniteComposition], CategoryTheory.MorphismProperty.transfiniteCompositions.{w, v, u} W ≤ W | null | true |
ContinuousAlternatingMap.ext | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] {f g : M [⋀^ι]→L[R] N}, (∀ (x : ι → M), f x = g x) → f = g | null | true |
CategoryTheory.Functor.Elements.Hom.recOn | Mathlib.CategoryTheory.Elements | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C (Type w)} →
{x y : F.Elements} →
{motive : x.Hom y → Sort u_1} →
(t : x.Hom y) →
((hom : x.obj ⟶ y.obj) →
(map_val : (CategoryTheory.ConcreteCategory.hom (F.map hom)) x.val ... | null | false |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.insertManyIfNewUnit_list_eq_empty_iff._simp_1_2 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Equiv.0.MvPowerSeries.optionFunLeft | Mathlib.RingTheory.MvPowerSeries.Equiv | (σ : Type u_1) → (R : Type u_2) → [CommSemiring R] → MvPowerSeries (Option σ) R → PowerSeries (MvPowerSeries σ R) | Implementation detail for `optionEquivLeft`. Use `MvPowerSeries.optionEquivLeft` instead. | true |
Finset.affineCombinationLineMapWeights_apply_left | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} [inst : Ring k] {ι : Type u_4} [inst_1 : DecidableEq ι] {i j : ι},
i ≠ j → ∀ (c : k), Finset.affineCombinationLineMapWeights i j c i = 1 - c | null | true |
FirstOrder.Language.LHom.id_comp | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (F : L →ᴸ L'), (FirstOrder.Language.LHom.id L').comp F = F | null | true |
liminf_eq_top._simp_1 | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [FirstCountableTopology α]
[OrderTopology α] {f : Filter β} [CountableInterFilter f] {u : β → α}, (Filter.liminf u f = ⊤) = (u =ᶠ[f] ⊤) | null | false |
toIcoMod_add_nsmul' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α) (m : ℕ), toIcoMod hp (a + m • p) b = toIcoMod hp a b + m • p | null | true |
exp_neg_mul_sq_isLittleO_exp_neg | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | ∀ {b : ℝ}, 0 < b → (fun x => Real.exp (-b * x ^ 2)) =o[Filter.atTop] fun x => Real.exp (-x) | null | true |
Set.Ioc.instMul._proof_1 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (p q : ↑(Set.Ioc 0 1)),
↑p * ↑q ≤ 1 | null | false |
ProbabilityTheory.IsLocalizingSequence.mk._flat_ctor | Mathlib.Probability.Process.LocalProperty | ∀ {ι : Type u_1} {Ω : Type u_2} {mΩ : MeasurableSpace Ω} [inst : Preorder ι] [inst_1 : TopologicalSpace ι]
[inst_2 : OrderTopology ι] {𝓕 : MeasureTheory.Filtration ι mΩ} {τ : ℕ → Ω → WithTop ι}
{P : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.IsLocalizingSequence._auto_1},
(∀ (n : ℕ), MeasureTheory.IsS... | null | false |
Algebra.Generators.CotangentSpace.compEquiv.eq_1 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {R : Type u₁} {S : Type u₂} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u₃}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {ι : Type w₁}
{σ : Type w₂} (Q : Algebra.Generators S T ι) (P : Algebra.Generators R S σ),
Algebra.Generat... | null | true |
QuotSMulTop.map_exact | Mathlib.RingTheory.QuotSMulTop | ∀ {R : Type u_2} [inst : CommRing R] (r : R) {M : Type u_1} {M' : Type u_3} {M'' : Type u_4} [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup M'] [inst_4 : Module R M'] [inst_5 : AddCommGroup M'']
[inst_6 : Module R M''] {f : M →ₗ[R] M'} {g : M' →ₗ[R] M''},
Function.Exact ⇑f ⇑g → Function.Su... | null | true |
Sum.LiftRel.isRight_left | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β} {d : δ},
Sum.LiftRel r s x (Sum.inr d) → x.isRight = true | null | true |
Polynomial.leadingCoeff_divByMonic_of_monic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p q : Polynomial R},
q.Monic → q.degree ≤ p.degree → (p /ₘ q).leadingCoeff = p.leadingCoeff | Division by a monic polynomial doesn't change the leading coefficient. | true |
Module.Dual.eq_of_ker_eq_of_apply_eq | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V₁ : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V₁] [inst_2 : Module K V₁]
[FiniteDimensional K V₁] {f g : Module.Dual K V₁} (x : V₁),
LinearMap.ker f = LinearMap.ker g → f x = g x → f x ≠ 0 → f = g | null | true |
UniformSpace.hasBasis_nhds_prod | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α] (x y : α),
(nhds (x, y)).HasBasis (fun s => s ∈ uniformity α ∧ SetRel.IsSymm s) fun s =>
UniformSpace.ball x s ×ˢ UniformSpace.ball y s | null | true |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.tensor.elim | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} →
{motive : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → Sort u_1} →
(t : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
t.ctorIdx = 1 →
((a : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) → (a_1 : C) → motive (a.tensor a_1)) →
moti... | null | false |
Fin.getElem?_fin | Init.GetElem | ∀ {Cont : Type u_1} {Elem : Type u_2} {Dom : Cont → ℕ → Prop} {n : ℕ} [h : GetElem? Cont ℕ Elem Dom] (a : Cont)
(i : Fin n), a[i]? = a[↑i]? | null | true |
OrderIso.image_eq_preimage_symm | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set α), ⇑e '' s = ⇑e.symm ⁻¹' s | null | true |
Set.FiniteExhaustion.mk.injEq | Mathlib.Data.Set.FiniteExhaustion | ∀ {α : Type u_1} {s : Set α} (toFun : ℕ → Set α) (finite' : ∀ (n : ℕ), Finite ↑(toFun n))
(subset_succ' : ∀ (n : ℕ), toFun n ⊆ toFun (n + 1)) (iUnion_eq' : ⋃ n, toFun n = s) (toFun_1 : ℕ → Set α)
(finite'_1 : ∀ (n : ℕ), Finite ↑(toFun_1 n)) (subset_succ'_1 : ∀ (n : ℕ), toFun_1 n ⊆ toFun_1 (n + 1))
(iUnion_eq'_1 :... | null | true |
_private.Mathlib.Util.Export.0.Lean.Export.exportDef.defn._unsafe_rec | Mathlib.Util.Export | String → Lean.Name → Lean.Expr → Lean.Expr → List Lean.Name → Lean.ExportM Unit | null | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.upShadow_compls._simp_1_1 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {t : Finset α},
(t ∈ 𝒜.shadow) = ∃ s ∈ 𝒜, ∃ a ∈ s, s.erase a = t | null | false |
ProfiniteGrp.diagram.eq_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u}),
P.diagram = P.toFiniteQuotientFunctor.comp (CategoryTheory.forget₂ FiniteGrp.{u} ProfiniteGrp.{u}) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_maxKeyD._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
OrderHom.le_prevFixed | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x) {y : ↑(Function.fixedPoints ⇑f)},
↑y ≤ x → y ≤ f.prevFixed x hx | null | true |
Aesop.UnorderedArraySet.singleton | Aesop.Util.UnorderedArraySet | {α : Type u_1} → [inst : BEq α] → α → Aesop.UnorderedArraySet α | O(1) | true |
IsLocalHomeomorph.apply_self_mem_localInverseAt_source | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y}
(hf : IsLocalHomeomorph f) {x : X}, f x ∈ (hf.localInverseAt x).source | The point `f x` lies in the source of `localInverseAt x`. | true |
AddGroup.fintypeOfDomOfCoker._proof_1 | Mathlib.GroupTheory.QuotientGroup.Finite | ∀ {F : Type u_2} {G : Type u_1} [inst : AddGroup F] [inst_1 : AddGroup G] (f : F →+ G) [inst_2 : f.range.Normal]
(x : G), ↑x = 0 → x ∈ f.range | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.