name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.RingTheory.Spectrum.Maximal.Localization.0.MaximalSpectrum.toPiLocalization_not_surjective_of_infinite._simp_1_3 | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ {ι : Type u_4} {R : ι → Type u_5} [inst : (i : ι) → CommSemiring (R i)] {i : ι} (I : Ideal (R i)) [inst_1 : I.IsPrime]
{r : (i : ι) → R i},
(algebraMap (R i) (Localization.AtPrime I)) (r i) =
(Localization.AtPrime.mapPiEvalRingHom I)
((algebraMap ((i : ι) → R i) (Localization.AtPrime (Ideal.comap (Pi.evalRingHom R i) I))) r) |
Ordinal.cof_blsub_le_lift | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{max u v}), (o.blsub f).cof ≤ Cardinal.lift.{v, u} o.card |
BotHom.symm_dual_id | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} [inst : LE α] [inst_1 : OrderBot α], BotHom.dual.symm (TopHom.id αᵒᵈ) = BotHom.id α |
ComplexShape.not_rel_of_eq | Mathlib.Algebra.Homology.HasNoLoop | ∀ {ι : Type u_1} (c : ComplexShape ι) [c.HasNoLoop] {j j' : ι}, j = j' → ¬c.Rel j j' |
Ideal.Quotient.mkₐ_toRingHom | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_3} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided], (Ideal.Quotient.mkₐ R₁ I).toRingHom = Ideal.Quotient.mk I |
Algebra.adjoin.powerBasisAux._proof_4 | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_2} {S : Type u_1} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S],
SubmonoidClass (Subalgebra K S) S |
ContinuousLinearEquiv.toContinuousAffineEquiv._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_3} [inst : Ring k] {E : Type u_1} {F : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module k E]
[inst_3 : TopologicalSpace E] [inst_4 : AddCommGroup F] [inst_5 : Module k F] [inst_6 : TopologicalSpace F]
(L : E ≃L[k] F), Continuous (↑L.toLinearEquiv).toFun |
WithTop.untopD_le | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : PartialOrder α] {y : WithTop α} {a b : α}, y ≤ ↑b → WithTop.untopD a y ≤ b |
SkewMonoidAlgebra.liftNC_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {R : Type u_5} [inst_1 : NonUnitalNonAssocSemiring R]
(f : k →+ R) (g : G → R) (a : G) (b : k), (SkewMonoidAlgebra.liftNC f g) (SkewMonoidAlgebra.single a b) = f b * g a |
LinearMap.IsSymmetric.iSup_eigenspace_inf_eigenspace_of_commute | Mathlib.Analysis.InnerProductSpace.JointEigenspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{α : 𝕜} {A B : E →ₗ[𝕜] E} [FiniteDimensional 𝕜 E],
B.IsSymmetric → Commute A B → ⨆ γ, Module.End.eigenspace A α ⊓ Module.End.eigenspace B γ = Module.End.eigenspace A α |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_union_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
ContinuousMap.HomotopyWith.Simps.apply | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} → {P : C(X, Y) → Prop} → f₀.HomotopyWith f₁ P → ↑unitInterval × X → Y |
Std.ExtTreeMap.getKeyLE | Std.Data.ExtTreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[inst : Std.TransCmp cmp] → (t : Std.ExtTreeMap α β cmp) → (k : α) → (∃ a ∈ t, (cmp a k).isLE = true) → α |
MeasureTheory.Measure.inv.instIsMulRightInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : DivisionMonoid G] [MeasurableMul G] [MeasurableInv G]
{μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant], μ.inv.IsMulRightInvariant |
Lean.Parser.Tactic.allGoals | Init.Tactics | Lean.ParserDescr |
Bundle.RiemannianMetric.casesOn | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_4} →
{E : B → Type u_6} →
[inst : (b : B) → TopologicalSpace (E b)] →
[inst_1 : (b : B) → AddCommGroup (E b)] →
[inst_2 : (b : B) → Module ℝ (E b)] →
{motive : Bundle.RiemannianMetric E → Sort u} →
(t : Bundle.RiemannianMetric E) →
((inner : (b : B) → E b →L[ℝ] E b →L[ℝ] ℝ) →
(symm : ∀ (b : B) (v w : E b), ((inner b) v) w = ((inner b) w) v) →
(pos : ∀ (b : B) (v : E b), v ≠ 0 → 0 < ((inner b) v) v) →
(continuousAt : ∀ (b : B), ContinuousAt (fun v => ((inner b) v) v) 0) →
(isVonNBounded : ∀ (b : B), Bornology.IsVonNBounded ℝ {v | ((inner b) v) v < 1}) →
motive
{ inner := inner, symm := symm, pos := pos, continuousAt := continuousAt,
isVonNBounded := isVonNBounded }) →
motive t |
isωSup_ωSup | Mathlib.Topology.OmegaCompletePartialOrder | ∀ {α : Type u_1} [inst : OmegaCompletePartialOrder α] (c : OmegaCompletePartialOrder.Chain α),
Scott.IsωSup c (OmegaCompletePartialOrder.ωSup c) |
AddCommGrpCat.ofHom | Mathlib.Algebra.Category.Grp.Basic | {X Y : Type u} →
[inst : AddCommGroup X] → [inst_1 : AddCommGroup Y] → (X →+ Y) → (AddCommGrpCat.of X ⟶ AddCommGrpCat.of Y) |
CategoryTheory.SingleObj.differenceFunctor_obj | Mathlib.CategoryTheory.SingleObj | ∀ {G : Type u} [inst : Group G] {C : Type v} [inst_1 : CategoryTheory.Category.{w, v} C] (f : C → G) (x : C),
(CategoryTheory.SingleObj.differenceFunctor f).obj x = () |
CategoryTheory.ComposableArrows.homMk₅._proof_6 | Mathlib.CategoryTheory.ComposableArrows.Basic | 5 < 5 + 1 |
String.Slice.Pos.lt_next_iff_le | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} {h : q ≠ s.endPos}, p < q.next h ↔ p ≤ q |
Lean.PrettyPrinter.Parenthesizer.Context.mk.inj | Lean.PrettyPrinter.Parenthesizer | ∀ {cat : Lean.Name} {forceParens : Bool} {cat_1 : Lean.Name} {forceParens_1 : Bool},
{ cat := cat, forceParens := forceParens } = { cat := cat_1, forceParens := forceParens_1 } →
cat = cat_1 ∧ forceParens = forceParens_1 |
CategoryTheory.CostructuredArrow.mkIdTerminal._proof_6 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Y : C} {S : CategoryTheory.Functor C D} [inst_2 : S.Full]
[S.Faithful]
(s : CategoryTheory.Limits.Cone (CategoryTheory.Functor.empty (CategoryTheory.CostructuredArrow S (S.obj Y))))
(m :
s.pt ⟶
(CategoryTheory.Limits.asEmptyCone
(CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.id (S.obj Y)))).pt),
(∀ (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp m
((CategoryTheory.Limits.asEmptyCone
(CategoryTheory.CostructuredArrow.mk (CategoryTheory.CategoryStruct.id (S.obj Y)))).π.app
j) =
s.π.app j) →
m = CategoryTheory.CostructuredArrow.homMk (S.preimage s.pt.hom) ⋯ |
Int.tmod_tmod_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ (n : ℤ) {m k : ℤ}, m ∣ k → (n.tmod k).tmod m = n.tmod m |
Fin.prod_univ_two' | Mathlib.Algebra.BigOperators.Fin | ∀ {ι : Type u_1} {M : Type u_2} [inst : CommMonoid M] (f : ι → M) (a b : ι), ∏ i, f (![a, b] i) = f a * f b |
Lean.IR.EmitLLVM.emitJp | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → Lean.IR.JoinPointId → Lean.IR.EmitLLVM.M llvmctx (LLVM.BasicBlock llvmctx) |
Lean.Meta.Grind.Arith.Cutsat.propagateDvd | Lean.Meta.Tactic.Grind.Arith.Cutsat.DvdCnstr | Lean.Meta.Grind.Propagator |
ENNReal.tsum_eq_limsup_sum_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = Filter.limsup (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop |
NumberField.mixedEmbedding.fundamentalCone.expMap_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (c : ℝ) (x : NumberField.mixedEmbedding.realSpace K),
↑NumberField.mixedEmbedding.fundamentalCone.expMap (c • x) = ↑NumberField.mixedEmbedding.fundamentalCone.expMap x ^ c |
LieRinehartAlgebra.instDerivation | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommRing R] [inst_1 : CommRing A₁] [inst_2 : Algebra R A₁],
LieRinehartAlgebra R A₁ (Derivation R A₁ A₁) |
Prod.instStarMul._proof_1 | Mathlib.Algebra.Star.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : Mul S] [inst_2 : StarMul R] [inst_3 : StarMul S]
(x x_1 : R × S), star (x * x_1) = star x_1 * star x |
instLawfulOrderLTInt64 | Init.Data.SInt.Lemmas | Std.LawfulOrderLT Int64 |
Lean.Meta.Occurrences.pos.injEq | Init.MetaTypes | ∀ (idxs idxs_1 : List ℕ), (Lean.Meta.Occurrences.pos idxs = Lean.Meta.Occurrences.pos idxs_1) = (idxs = idxs_1) |
IsMaxOn.bddAbove | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMaxOn f s a → BddAbove (f '' s) |
CategoryTheory.biproduct_ι_comp_leftDistributor_hom_assoc | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] (X : C) (f : J → C) (j : J)
{Z : C} (h : (⨁ fun j => CategoryTheory.MonoidalCategoryStruct.tensorObj X (f j)) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.Limits.biproduct.ι f j))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.leftDistributor X f).hom h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biproduct.ι (fun j => CategoryTheory.MonoidalCategoryStruct.tensorObj X (f j)) j) h |
MeasureTheory.exists_measure_symmDiff_lt_of_generateFrom_isSetSemiring | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Type u_1} [mα : MeasurableSpace α] {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
{C : Set (Set α)},
MeasureTheory.IsSetSemiring C →
(∃ D, D.Countable ∧ D ⊆ C ∧ μ (⋃₀ D)ᶜ = 0) →
mα = MeasurableSpace.generateFrom C →
∀ {s : Set α}, MeasurableSet s → ∀ {ε : ENNReal}, 0 < ε → ∃ t ∈ supClosure C, μ (symmDiff t s) < ε |
NonemptyInterval.coe_top | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α], ↑⊤ = Set.univ |
eq_const_of_unique | Mathlib.Logic.Unique | ∀ {α : Sort u_1} {β : Sort u_2} [inst : Unique α] (f : α → β), f = Function.const α (f default) |
Affine.Simplex.exradius.congr_simp | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s s_1 : Affine.Simplex ℝ P n),
s = s_1 → ∀ (signs signs_1 : Finset (Fin (n + 1))), signs = signs_1 → s.exradius signs = s_1.exradius signs_1 |
Std.TreeSet.Equiv.atIdxD_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {i : ℕ} {fallback : α},
t₁.Equiv t₂ → t₁.atIdxD i fallback = t₂.atIdxD i fallback |
IsLocalization.algEquivOfAlgEquiv_eq_map | Mathlib.RingTheory.Localization.Basic | ∀ {A : Type u_4} [inst : CommSemiring A] {R : Type u_5} [inst_1 : CommSemiring R] [inst_2 : Algebra A R]
{M : Submonoid R} {S : Type u_6} [inst_3 : CommSemiring S] [inst_4 : Algebra A S] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower A R S] [inst_7 : IsLocalization M S] {P : Type u_7} [inst_8 : CommSemiring P]
[inst_9 : Algebra A P] {T : Submonoid P} {Q : Type u_8} [inst_10 : CommSemiring Q] [inst_11 : Algebra A Q]
[inst_12 : Algebra P Q] [inst_13 : IsScalarTower A P Q] [inst_14 : IsLocalization T Q] {h : R ≃ₐ[A] P}
(H : Submonoid.map h M = T), ↑(IsLocalization.algEquivOfAlgEquiv S Q h H) = IsLocalization.map Q ↑h ⋯ |
Nat.Linear.monomialToExpr | Init.Data.Nat.Linear | ℕ → Nat.Linear.Var → Nat.Linear.Expr |
Lean.IRPhases.recOn | Lean.Environment | {motive : Lean.IRPhases → Sort u} →
(t : Lean.IRPhases) →
motive Lean.IRPhases.runtime → motive Lean.IRPhases.comptime → motive Lean.IRPhases.all → motive t |
Std.DHashMap.Internal.Raw₀.Const.get!_of_isEmpty | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m).WF → ∀ {a : α}, (↑m).isEmpty = true → Std.DHashMap.Internal.Raw₀.Const.get! m a = default |
Lean.Elab.InlayHintInfo.textEdits | Lean.Elab.InfoTree.InlayHints | Lean.Elab.InlayHintInfo → Array Lean.Elab.InlayHintTextEdit |
Orientation.kahler_rightAngleRotation_right | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x y : E), (o.kahler x) (o.rightAngleRotation y) = Complex.I * (o.kahler x) y |
CategoryTheory.Square.noConfusionType | Mathlib.CategoryTheory.Square | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.Square C →
{C' : Type u} → [inst' : CategoryTheory.Category.{v, u} C'] → CategoryTheory.Square C' → Sort u_1 |
LinearMap.zero_apply | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂} (x : M), 0 x = 0 |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.keyAtIdx_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
IsUnit.mul_right_dvd._simp_1 | Mathlib.Algebra.Divisibility.Units | ∀ {α : Type u_1} [inst : Monoid α] {a b u : α}, IsUnit u → (a * u ∣ b) = (a ∣ b) |
instSliceableListSliceNat_5 | Init.Data.Slice.List.Basic | {α : Type u} → Std.Roi.Sliceable (ListSlice α) ℕ (ListSlice α) |
Batteries.ByteSubarray.mk.sizeOf_spec | Batteries.Data.ByteSlice | ∀ (array : ByteArray) (start stop : ℕ) (start_le_stop : start ≤ stop) (stop_le_array_size : stop ≤ array.size),
sizeOf
{ array := array, start := start, stop := stop, start_le_stop := start_le_stop,
stop_le_array_size := stop_le_array_size } =
1 + sizeOf array + sizeOf start + sizeOf stop + sizeOf start_le_stop + sizeOf stop_le_array_size |
HomotopicalAlgebra.FibrantObject.instIsFibrantObjι | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : HomotopicalAlgebra.FibrantObject C),
HomotopicalAlgebra.IsFibrant (HomotopicalAlgebra.FibrantObject.ι.obj X) |
USize.zero_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a : USize}, 0 <<< a = 0 |
Equiv.Perm.instDecidableRelSameCycleInv | Mathlib.GroupTheory.Perm.Cycle.Basic | {α : Type u_2} → (f : Equiv.Perm α) → [DecidableRel f.SameCycle] → DecidableRel f⁻¹.SameCycle |
MonomialOrder.degree_prod_of_regular | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {ι : Type u_3} {P : ι → MvPolynomial σ R}
{s : Finset ι}, (∀ i ∈ s, IsRegular (m.leadingCoeff (P i))) → m.degree (∏ i ∈ s, P i) = ∑ i ∈ s, m.degree (P i) |
Lean.PersistentHashSet.recOn | Lean.Data.PersistentHashSet | {α : Type u} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.PersistentHashSet α → Sort u_1} →
(t : Lean.PersistentHashSet α) → ((set : Lean.PersistentHashMap α Unit) → motive { set := set }) → motive t |
Cardinal.mk_embedding_le_arrow | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ (α : Type u) (β' : Type v), Cardinal.mk (α ↪ β') ≤ Cardinal.mk (α → β') |
CategoryTheory.Subobject.lower | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{Y : D} →
CategoryTheory.Functor (CategoryTheory.MonoOver X) (CategoryTheory.MonoOver Y) →
CategoryTheory.Functor (CategoryTheory.Subobject X) (CategoryTheory.Subobject Y) |
_private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.realizeExtIffTheorem | Lean.Elab.Tactic.Ext | Lean.Name → Lean.Elab.Command.CommandElabM Lean.Name |
Matrix.PosDef.of_toQuadraticForm' | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] {M : Matrix n n ℝ},
M.IsSymm → M.toQuadraticMap'.PosDef → M.PosDef |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.Equiv.Perm.count_le_one_of_centralizer_le_alternating._simp_1_6 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b |
SemigroupIdeal.subset_closure | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : Mul M] {s : Set M}, s ⊆ ↑(SemigroupIdeal.closure s) |
Lean.Grind.NoopConfig.funCC._default | Init.Grind.Config | Bool |
ExteriorAlgebra.instGradedMonoidNatSubmoduleExteriorPower | Mathlib.LinearAlgebra.ExteriorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
SetLike.GradedMonoid fun i => ⋀[R]^i M |
AlgebraicGeometry.pointsPi.eq_1 | Mathlib.AlgebraicGeometry.PointsPi | ∀ {ι : Type u} (R : ι → CommRingCat) (X : AlgebraicGeometry.Scheme)
(f : AlgebraicGeometry.Spec (CommRingCat.of ((i : ι) → ↑(R i))) ⟶ X) (i : ι),
AlgebraicGeometry.pointsPi R X f i =
CategoryTheory.CategoryStruct.comp
(AlgebraicGeometry.Spec.map (CommRingCat.ofHom (Pi.evalRingHom (fun x => ↑(R x)) i))) f |
Filter.HasBasis.tendstoUniformlyOn_iff_of_uniformity | Mathlib.Topology.UniformSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace β] {X : Type u_5} {ιβ : Type u_8} {F : X → α → β} {f : α → β}
{l : Filter X} {s : Set α} {pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)},
(uniformity β).HasBasis pβ sβ →
(TendstoUniformlyOn F f l s ↔ ∀ (i : ιβ), pβ i → ∀ᶠ (n : X) in l, ∀ x ∈ s, (f x, F n x) ∈ sβ i) |
Algebra.TensorProduct.lTensor_ker | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_4} [inst : CommRing R] {A : Type u_6} {C : Type u_8} {D : Type u_9} [inst_1 : Ring A] [inst_2 : Ring C]
[inst_3 : Ring D] [inst_4 : Algebra R A] [inst_5 : Algebra R C] [inst_6 : Algebra R D] (g : C →ₐ[R] D),
Function.Surjective ⇑g →
RingHom.ker (Algebra.TensorProduct.map (AlgHom.id R A) g) =
Ideal.map Algebra.TensorProduct.includeRight (RingHom.ker g) |
Convex.add_smul_sub_mem_interior' | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
[AddRightMono 𝕜] {s : Set E},
Convex 𝕜 s → ∀ {x y : E}, x ∈ closure s → y ∈ interior s → ∀ {t : 𝕜}, t ∈ Set.Ioc 0 1 → x + t • (y - x) ∈ interior s |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.inferResultingUniverse.match_4 | Lean.Elab.MutualInductive | (motive : Lean.Level × ℤ → Sort u_1) →
(x : Lean.Level × ℤ) → ((level : Lean.Level) → (k : ℤ) → motive (level, k)) → motive x |
Lean.Meta.Grind.SolverExtension.mbtc | Lean.Meta.Tactic.Grind.Types | {σ : Type} → Lean.Meta.Grind.SolverExtension σ → Lean.Meta.Grind.GoalM Bool |
Std.DTreeMap.Raw.Const.getKeyD_insertMany_list_of_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF →
∀ {l : List (α × β)} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
k ∈ List.map Prod.fst l → (Std.DTreeMap.Raw.Const.insertMany t l).getKeyD k' fallback = k |
isPrimitiveRoot_of_mem_primitiveRoots | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {k : ℕ} [inst : CommRing R] [inst_1 : IsDomain R] {ζ : R}, ζ ∈ primitiveRoots k R → IsPrimitiveRoot ζ k |
CategoryTheory.Subfunctor.preimage._proof_2 | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F F' : CategoryTheory.Functor C (Type u_3)}
(G : CategoryTheory.Subfunctor F) (p : F' ⟶ F) {U V : C} (f : U ⟶ V),
p.app U ⁻¹' G.obj U ⊆ F'.map f ⁻¹' (p.app V ⁻¹' G.obj V) |
LieHom.mem_range | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {L₂ : Type w}
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L →ₗ⁅R⁆ L₂) (x : L₂), x ∈ f.range ↔ ∃ y, f y = x |
quotAdjoinEquivQuotMap.congr_simp | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R}
(hx : Ideal.comap (algebraMap R S) (conductor R x) ⊔ I = ⊤)
(h_alg : Function.Injective ⇑(algebraMap (↥(Algebra.adjoin R {x})) S)),
quotAdjoinEquivQuotMap hx h_alg = quotAdjoinEquivQuotMap hx h_alg |
IsLocalization.smul_toInvSubmonoid | Mathlib.RingTheory.Localization.InvSubmonoid | ∀ {R : Type u_1} [inst : CommRing R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsLocalization M S] (m : ↥M), m • ↑((IsLocalization.toInvSubmonoid M S) m) = 1 |
Sym2.irreflexive_iff_fromRel_subset_diagSet_compl | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (sym : Symmetric r), Std.Irrefl r ↔ Sym2.fromRel sym ⊆ Sym2.diagSetᶜ |
LieDerivation.instBracket._proof_3 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L], IsScalarTower R R L |
Rat.padicValuation.congr_simp | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p p_1 : ℕ) (e_p : p = p_1) [inst : Fact (Nat.Prime p)], Rat.padicValuation p = Rat.padicValuation p_1 |
Lean.Meta.Origin.other.noConfusion | Lean.Meta.Tactic.Simp.SimpTheorems | {P : Sort u} →
{name name' : Lean.Name} → Lean.Meta.Origin.other name = Lean.Meta.Origin.other name' → (name = name' → P) → P |
Lean.Doc.Data.instImpl._@.Lean.Elab.DocString.Builtin.984454940._hygCtx._hyg.8 | Lean.Elab.DocString.Builtin | TypeName Lean.Doc.Data.Const |
Lean.Elab.InfoTree.brecOn_4 | Lean.Elab.InfoTree.Types | {motive_1 : Lean.Elab.InfoTree → Sort u} →
{motive_2 : Lean.PersistentArray Lean.Elab.InfoTree → Sort u} →
{motive_3 : Lean.PersistentArrayNode Lean.Elab.InfoTree → Sort u} →
{motive_4 : Array Lean.Elab.InfoTree → Sort u} →
{motive_5 : Array (Lean.PersistentArrayNode Lean.Elab.InfoTree) → Sort u} →
{motive_6 : List Lean.Elab.InfoTree → Sort u} →
{motive_7 : List (Lean.PersistentArrayNode Lean.Elab.InfoTree) → Sort u} →
(t : Array (Lean.PersistentArrayNode Lean.Elab.InfoTree)) →
((t : Lean.Elab.InfoTree) → t.below → motive_1 t) →
((t : Lean.PersistentArray Lean.Elab.InfoTree) → Lean.Elab.InfoTree.below_1 t → motive_2 t) →
((t : Lean.PersistentArrayNode Lean.Elab.InfoTree) → Lean.Elab.InfoTree.below_2 t → motive_3 t) →
((t : Array Lean.Elab.InfoTree) → Lean.Elab.InfoTree.below_3 t → motive_4 t) →
((t : Array (Lean.PersistentArrayNode Lean.Elab.InfoTree)) →
Lean.Elab.InfoTree.below_4 t → motive_5 t) →
((t : List Lean.Elab.InfoTree) → Lean.Elab.InfoTree.below_5 t → motive_6 t) →
((t : List (Lean.PersistentArrayNode Lean.Elab.InfoTree)) →
Lean.Elab.InfoTree.below_6 t → motive_7 t) →
motive_5 t |
Turing.TM2to1.addBottom_modifyNth | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} (f : ((k : K) → Option (Γ k)) → (k : K) → Option (Γ k))
(L : Turing.ListBlank ((k : K) → Option (Γ k))) (n : ℕ),
Turing.ListBlank.modifyNth (fun a => (a.1, f a.2)) n (Turing.TM2to1.addBottom L) =
Turing.TM2to1.addBottom (Turing.ListBlank.modifyNth f n L) |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality.0.groupCohomology.cochainsMap_f_map_mono._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {R : Type u} [inst : Ring R] {X Y : ModuleCat R} (f : X ⟶ Y),
CategoryTheory.Mono f = Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) |
ContinuousOn.strictMonoOn_of_injOn_Icc' | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b →
ContinuousOn f (Set.Icc a b) →
Set.InjOn f (Set.Icc a b) → StrictMonoOn f (Set.Icc a b) ∨ StrictAntiOn f (Set.Icc a b) |
Set.instIsTransSubset | Mathlib.Data.Set.Basic | ∀ {α : Type u}, IsTrans (Set α) fun x1 x2 => x1 ⊆ x2 |
CategoryTheory.Limits.cokernelOrderHom._proof_2 | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasCokernels C] (X : C) (P Q : CategoryTheory.Subobject X),
P ≤ Q →
CategoryTheory.Subobject.lift (fun x f x_1 => CategoryTheory.Subobject.mk (CategoryTheory.Limits.cokernel.π f).op) ⋯
P ≤
CategoryTheory.Subobject.lift (fun x f x_1 => CategoryTheory.Subobject.mk (CategoryTheory.Limits.cokernel.π f).op)
⋯ Q |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.sum.match_1.eq_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} (motive : (x : ℕ) → (Fin x → α) → Sort u_1) (x : Fin 0 → α) (h_1 : (x : Fin 0 → α) → motive 0 x)
(h_2 : (v : Fin 1 → α) → motive 1 v) (h_3 : (n : ℕ) → (v : Fin (n + 2) → α) → motive n.succ.succ v),
(match 0, x with
| 0, x => h_1 x
| 1, v => h_2 v
| n.succ.succ, v => h_3 n v) =
h_1 x |
ConvexCone.coe_closure._simp_1 | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] {E : Type u_2} [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : SMul 𝕜 E] [inst_6 : ContinuousConstSMul 𝕜 E]
(K : ConvexCone 𝕜 E), closure ↑K = ↑K.closure |
Cardinal.range_aleph | Mathlib.SetTheory.Cardinal.Aleph | Set.range ⇑Cardinal.aleph = Set.Ici Cardinal.aleph0 |
_private.Mathlib.Order.ConditionallyCompleteLattice.Finset.0.Set.Finite.ciSup_lt_iff._simp_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x |
Turing.ToPartrec.Cfg.halt.noConfusion | Mathlib.Computability.TuringMachine.Config | {P : Sort u} → {a a' : List ℕ} → Turing.ToPartrec.Cfg.halt a = Turing.ToPartrec.Cfg.halt a' → (a = a' → P) → P |
lt_emultiplicity_of_lt_multiplicity | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a b : α} {n : ℕ}, n < multiplicity a b → ↑n < emultiplicity a b |
Num.pred_succ | Mathlib.Data.Num.ZNum | ∀ (n : ZNum), n.pred.succ = n |
BitVec.sshiftRight_eq_sshiftRightRec | Init.Data.BitVec.Bitblast | ∀ {w₁ w₂ i : ℕ} (x : BitVec w₁) (y : BitVec w₂), (x.sshiftRight' y).getLsbD i = (x.sshiftRightRec y (w₂ - 1)).getLsbD i |
Graph.ext | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {G₁ G₂ : Graph α β},
G₁.vertexSet = G₂.vertexSet → (∀ (e : β) (x y : α), G₁.IsLink e x y ↔ G₂.IsLink e x y) → G₁ = G₂ |
IsometryEquiv.instGroup | Mathlib.Topology.MetricSpace.Isometry | {α : Type u} → [inst : PseudoEMetricSpace α] → Group (α ≃ᵢ α) |
and_self | Init.SimpLemmas | ∀ (p : Prop), (p ∧ p) = p |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorArbitraryShiftTargetBlastArithShiftRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.ArbitraryShiftTarget fun {len} =>
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRight |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.