name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
OrderEmbedding.birkhoffSet_sup | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : Fintype α] [inst_2 : DecidablePred SupIrred] (a b : α),
OrderEmbedding.birkhoffSet (a ⊔ b) = OrderEmbedding.birkhoffSet a ∪ OrderEmbedding.birkhoffSet b | null | true |
CategoryTheory.Functor.CorepresentableBy | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (Type v) → C → Type (max (max u₁ v) v₁) | The data which expresses that a functor `F : C ⥤ Type v` is corepresentable by `X : C`. | true |
fderivWithin_congr_set_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s t : Set E},
s =ᶠ[nhdsWithin x {x}ᶜ] t → fderivWit... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_modify._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) | null | false |
CategoryTheory.Equivalence.isAccessibleCategory | Mathlib.CategoryTheory.Presentable.Adjunction | ∀ {C : Type u} {D : Type u'} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Category.{v', u'} D]
(e : C ≌ D) [CategoryTheory.IsAccessibleCategory.{w, v, u} C], CategoryTheory.IsAccessibleCategory.{w, v', u'} D | null | true |
Set.Iic.coe_succ_of_not_isMax | Mathlib.Order.Interval.Set.SuccOrder | ∀ {J : Type u_1} [inst : PartialOrder J] [inst_1 : SuccOrder J] {j : J} {i : ↑(Set.Iic j)},
¬IsMax i → ↑(Order.succ i) = Order.succ ↑i | null | true |
instDistribLatticePrimeMultiset._proof_6 | Mathlib.Data.PNat.Factors | ∀ (x y z : PrimeMultiset), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
ValuativeRel.instTransVltVle | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : Semiring R] → [inst_1 : ValuativeRel R] → Trans ValuativeRel.vlt ValuativeRel.vle ValuativeRel.vlt | null | true |
_private.Mathlib.Probability.Independence.Basic.0.ProbabilityTheory.iIndepSet_iff._simp_1_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {x : MeasurableSpace Ω} (s : ι → Set Ω) (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndepSet s μ = ProbabilityTheory.iIndep (fun i => MeasurableSpace.generateFrom {s i}) μ | null | false |
TopologicalSpace.Opens.map_iSup | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} (f : X ⟶ Y) {ι : Type u_1} (U : ι → TopologicalSpace.Opens ↑Y),
(TopologicalSpace.Opens.map f).obj (iSup U) = iSup ((TopologicalSpace.Opens.map f).obj ∘ U) | null | true |
Option.isSome.eq_2 | Init.Data.Option.Lemmas | ∀ {α : Type u_1}, none.isSome = false | null | true |
Chebyshev.psi.eq_1 | Mathlib.NumberTheory.Chebyshev | ∀ (x : ℝ), Chebyshev.psi x = ∑ n ∈ Finset.Ioc 0 ⌊x⌋₊, ArithmeticFunction.vonMangoldt n | null | true |
_private.Lean.Elab.Tactic.Grind.Config.0.Lean.Elab.Tactic.instEvalExprCutsatConfig | Lean.Elab.Tactic.Grind.Config | Lean.Elab.ConfigEval.EvalExpr Lean.Grind.CutsatConfig | null | true |
WithLp.prod_continuous_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous WithLp.ofLp | null | true |
exteriorPower.zeroEquiv_ιMulti | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Fin 0 → M),
(exteriorPower.zeroEquiv R M) ((exteriorPower.ιMulti R 0) f) = 1 | null | true |
LinearMap.polar_mem | Mathlib.Analysis.LocallyConvex.Polar | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedCommRing 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : AddCommMonoid F] [inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) (s : Set E),
∀ y ∈ B.polar s, ∀ x ∈ s, ‖(B x) y‖ ≤ 1 | null | true |
RingHom.OfLocalizationSpanTarget.ofLocalizationSpan | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.OfLocalizationSpanTarget P →
RingHom.StableUnderCompositionWithLocalizationAwaySource P → RingHom.OfLocalizationSpan P | null | true |
_private.Mathlib.RingTheory.Coalgebra.Convolution.0.TensorProduct.map_convMul_map._simp_1_2 | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
ImportGraph.Widget.RpcEncodablePacket._sizeOf_1._@.ImportGraph.Widget.GoToModule.3734778248._hygCtx._hyg.1 | ImportGraph.Widget.GoToModule | ImportGraph.Widget.RpcEncodablePacket✝ → ℕ | null | false |
MulAction.QuotientAction | Mathlib.GroupTheory.GroupAction.Quotient | {G : Type u} → (X : Type v) → [inst : Group G] → [inst_1 : Monoid X] → [MulAction X G] → Subgroup G → Prop | A typeclass for when a `MulAction X G` descends to the quotient `G ⧸ H`. | true |
AffineEquiv.ofLinearEquiv | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_10} →
{V : Type u_11} →
{P : Type u_12} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] → [inst_2 : Module k V] → [inst_3 : AddTorsor V P] → (V ≃ₗ[k] V) → P → P → P ≃ᵃ[k] P | Construct an affine equivalence from a linear equivalence and two base points.
Given a linear equivalence `A : V ≃ₗ[k] V` and base points `p₀ p₁ : P`, this constructs
the affine equivalence `T x = A (x -ᵥ p₀) +ᵥ p₁`. This is the standard way to convert
a linear automorphism into an affine automorphism with specified b... | true |
QuadraticAlgebra.instField._proof_17 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {K : Type u_1} [inst : Field K] {a b : K} (q : ℚ) (x : QuadraticAlgebra K a b), q • x = ↑q * x | null | false |
_private.Mathlib.GroupTheory.Nilpotent.0.Subgroup.upperCentralSeriesStep._simp_4 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
IntermediateField.fixingSubgroupEquiv._proof_3 | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_2} [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (K : IntermediateField F E)
(x x_1 : ↥K.fixingSubgroup),
(let __src := (↑(x * x_1)).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ }) =
(let __src := (↑x).toRingEquiv;
{ to... | null | false |
ContinuousAlternatingMap.instAddCommGroup._proof_7 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {N : Type u_1} [inst : AddCommGroup N] [inst_1 : TopologicalSpace N] [IsTopologicalAddGroup N], ContinuousAdd N | null | false |
_private.Mathlib.Algebra.Module.Submodule.Map.0.Submodule.gc_map_comap.match_1_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_2} {M₂ : Type u_4} [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₂]
(motive : Submodule R M → Submodule R₂ M₂ → Prop) (x : Submodule R M) (x_1 : Submodule R₂ M₂),
(∀ (x : Sub... | null | false |
Pi.negZeroClass.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → NegZeroClass (f i)],
Pi.negZeroClass = { toZero := Pi.instZero, toNeg := Pi.instNeg, neg_zero := ⋯ } | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_dvd_leadingCoeff_pow._simp_1_1 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime 0 x = IsUnit x | null | false |
MonoidAlgebra.map_single | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+ S) (r : R) (m : M),
MonoidAlgebra.map f (MonoidAlgebra.single m r) = MonoidAlgebra.single m (f r) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Symmetric.0.Matrix.isSymm_comp_iff_forall._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.IsSymm = ∀ (i j : n), A j i = A i j | null | false |
AddCon.instInfSet.eq_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M],
AddCon.instInfSet = { sInf := fun S => { r := fun x y => ∀ c ∈ S, c x y, iseqv := ⋯, add' := ⋯ } } | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso_inv_app_hom_app | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] (X : CategoryTheory.Comon (CategoryTheory.Functor C D)) (x : C),
(CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.unitIso✝.inv.app X).hom.app x... | null | true |
MeasureTheory.SignedMeasure.eq_rnDeriv | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : MeasureTheory.SignedMeasure α}
(t : MeasureTheory.SignedMeasure α) (f : α → ℝ),
MeasureTheory.Integrable f μ →
MeasureTheory.VectorMeasure.MutuallySingular t μ.toENNRealVectorMeasure →
s = t + μ.withDensityᵥ f → f =ᵐ[μ] s.rnDeriv ... | Given a measure `μ`, signed measures `s` and `t`, and a function `f` such that `t` is
mutually singular with respect to `μ` and `s = t + μ.withDensityᵥ f`, we have
`f = rnDeriv s μ`, i.e. `f` is the Radon-Nikodym derivative of `s` and `μ`. | true |
Lean.Grind.Ring.ofNat_sub | Init.Grind.Ring.Basic | ∀ {α : Type u} [inst : Lean.Grind.Ring α] {x y : ℕ}, y ≤ x → OfNat.ofNat (x - y) = OfNat.ofNat x - OfNat.ofNat y | null | true |
Set.mem_prod | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t | null | true |
_private.Mathlib.Algebra.Order.Module.Basic.0.abs_smul._simp_1_3 | Mathlib.Algebra.Order.Module.Basic | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β]
[inst_3 : Preorder α] [inst_4 : Preorder β] [SMulPosMono α β], a ≤ 0 → 0 ≤ b → (a • b ≤ 0) = True | null | false |
QPF.recF_eq | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u → Type v} [q : QPF F] {α : Type u} (g : F α → α) (x : (QPF.P F).W),
QPF.recF g x = g (QPF.abs ((QPF.P F).map (QPF.recF g) x.dest)) | null | true |
ContDiffMapSupportedInClass.map_contDiff | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {B : Type u_5} {E : outParam (Type u_6)} {F : outParam (Type u_7)} {inst : NormedAddCommGroup E}
{inst_1 : NormedAddCommGroup F} {inst_2 : NormedSpace ℝ E} {inst_3 : NormedSpace ℝ F} {n : outParam ℕ∞}
{K : outParam (TopologicalSpace.Compacts E)} {inst_4 : FunLike B E F} [self : ContDiffMapSupportedInClass B E F n... | null | true |
_private.Mathlib.Data.Finset.Insert.0.Finset.ssubset_iff_exists_cons_subset._proof_1_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α}, ∀ w ∉ s, w ∉ s | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.isAtomOrDerivable.match_5 | Mathlib.Tactic.Ring.Common | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
OrderIso.image_symm_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set β), ⇑e '' ⇑e.symm '' s = s | null | true |
Congr!.Config.numArgsOk | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ → Bool | Whether the given number of arguments is allowed to be considered. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._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 |
AddCommGrpCat.zero_apply | Mathlib.Algebra.Category.Grp.Basic | ∀ (G H : AddCommGrpCat) (g : ↑G), (CategoryTheory.ConcreteCategory.hom 0) g = 0 | null | true |
StrictMono.injective | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : LinearOrder α] [inst_1 : Preorder β] {f : α → β},
StrictMono f → Function.Injective f | null | true |
Polynomial.C_eq_intCast | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Ring R] (n : ℤ), Polynomial.C ↑n = ↑n | null | true |
Lean.Meta.AbstractNestedProofs.Context._sizeOf_1 | Lean.Meta.AbstractNestedProofs | Lean.Meta.AbstractNestedProofs.Context → ℕ | null | false |
RBTree.RBNode.IsMonotone.rec | Batteries.Recycling.RBTree.WF | {α : Type u_1} →
{β : Type u_2} →
{cmpα : α → α → Ordering} →
{cmpβ : β → β → Ordering} →
{f : α → β} →
{motive : RBTree.RBNode.IsMonotone cmpα cmpβ f → Sort u} →
((lt_mono : ∀ {x y : α}, RBTree.RBNode.cmpLT cmpα x y → RBTree.RBNode.cmpLT cmpβ (f x) (f y)) → motive ⋯) →
... | null | false |
Function.Antiperiodic.const_inv_smul | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {c : α} [inst : AddMonoid α] [inst_1 : Neg β]
[inst_2 : Group γ] [inst_3 : DistribMulAction γ α],
Function.Antiperiodic f c → ∀ (a : γ), Function.Antiperiodic (fun x => f (a⁻¹ • x)) (a • c) | null | true |
PNat.XgcdType.wp | Mathlib.Data.PNat.Xgcd | PNat.XgcdType → ℕ | `wp` is a variable which changes through the algorithm. | true |
normalize | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_1} → [inst : MonoidWithZero α] → [NormalizationMonoid α] → α → α | Chooses an element of each associate class, by multiplying by `normUnit` | true |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleDocumentSymbol.toDocumentSymbols.match_1 | Lean.Server.FileWorker.RequestHandling | (motive : String × Lean.Syntax → Sort u_1) →
(x : String × Lean.Syntax) → ((name : String) → (selection : Lean.Syntax) → motive (name, selection)) → motive x | null | false |
Monovary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Monovary f g⁻¹ → Antivary f g | **Alias** of the forward direction of `monovary_inv_right`. | true |
Module.supportDim_le_ringKrullDim | Mathlib.RingTheory.KrullDimension.Module | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.supportDim R M ≤ ringKrullDim R | null | true |
MulHom.op_symm_apply_apply | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_3} {N : Type u_4} [inst : Mul M] [inst_1 : Mul N] (f : Mᵐᵒᵖ →ₙ* Nᵐᵒᵖ) (a : M),
(MulHom.op.symm f) a = (MulOpposite.unop ∘ ⇑f ∘ MulOpposite.op) a | null | true |
CategoryTheory.WellPowered | Mathlib.CategoryTheory.Subobject.WellPowered | (C : Type u₁) → [inst : CategoryTheory.Category.{v, u₁} C] → [CategoryTheory.LocallySmall.{w, v, u₁} C] → Prop | A category (with morphisms in `Type v`) is well-powered relative to a universe `w`
if it is locally small and `Subobject X` is `w`-small for every `X`.
We show in `wellPowered_of_essentiallySmall_monoOver` and `essentiallySmall_monoOver`
that this is the case if and only if `MonoOver X` is `w`-essentially small for ev... | true |
DyckWord.semilength_insidePart_add_semilength_outsidePart_add_one | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, p ≠ 0 → p.insidePart.semilength + p.outsidePart.semilength + 1 = p.semilength | null | true |
Subfield.topologicalClosure._proof_4 | Mathlib.Topology.Algebra.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α] (K : Subfield α),
1 ∈ K.topologicalClosure.carrier | null | false |
Lean.Parser.Command.namedName.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
OrderIso.IicTop._proof_2 | Mathlib.Order.Interval.Set.OrderIso | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] (x : α), x ≤ ⊤ | null | false |
SimpleGraph.cliqueFree_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ}, G.CliqueFree n ↔ IsEmpty ((SimpleGraph.completeGraph (Fin n)).Copy G) | **Alias** of `SimpleGraph.cliqueFree_iff_isEmpty_copy_top_fin`. | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.addGate._proof_2 | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf : Std.Sat.CNF ℕ} {lhs rhs : Std.Sat.AIG.Fanin} (cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf),
∀ idx < aig.decls.size,
lhs.gate < idx ∧ rhs.gate < idx → ∀ (idx_1 : ℕ), idx = idx_1 → ¬lhs.gate < aig.decls.size → False | null | false |
op_vadd_eq_add | Mathlib.Algebra.Group.Action.Defs | ∀ {α : Type u_9} [inst : Add α] (a b : α), AddOpposite.op a +ᵥ b = b + a | null | true |
exists_pred_iterate_or | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [IsPredArchimedean α] {a b : α},
(∃ n, Order.pred^[n] a = b) ∨ ∃ n, Order.pred^[n] b = a | null | true |
_private.Mathlib.Tactic.Contrapose.0.Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___elabRules_Mathlib_Tactic_Contrapose_contrapose_1.match_1 | Mathlib.Tactic.Contrapose | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(x x_1 : Option Lean.Expr) →
(Unit → motive none none) →
((p : Lean.Expr) → motive (some p) none) →
((q : Lean.Expr) → motive none (some q)) → ((p q : Lean.Expr) → motive (some p) (some q)) → motive x x_1 | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.ite_then_not_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {w : ℕ} (c0 c1 : Bool) {a b : BitVec w},
(bif c0 then ~~~bif c1 then ~~~a else b else a) = bif c0 && !c1 then ~~~b else a | null | true |
DirectSum.gMulLHom._proof_7 | Mathlib.Algebra.DirectSum.Algebra | ∀ {ι : Type u_3} (R : Type u_2) (A : ι → Type u_1) [inst : CommSemiring R] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : (i : ι) → Module R (A i)] [inst_3 : AddMonoid ι] [inst_4 : DirectSum.GSemiring A]
[inst_5 : DirectSum.GAlgebra R A] {i j : ι} (x x_1 : A i),
{ toFun := fun b => GradedMonoid.GMul.mul (x + ... | null | false |
Std.HashMap.Raw.toListRev_keysIter | Std.Data.HashMap.IteratorLemmas | ∀ {α β : Type u} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α],
m.WF → m.keysIter.toListRev = m.keys.reverse | null | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_notMem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set (OnePoint X)},
IsOpen s = ((OnePoint.infty ∈ s → IsCompact (OnePoint.some ⁻¹' s)ᶜ) ∧ IsOpen (OnePoint.some ⁻¹' s)) | null | false |
CategoryTheory.Functor.IsCartesian.domainUniqueUpToIso.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Fibered | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p p_1 : CategoryTheory.Functor 𝒳 𝒮) (e_p : p = p_1) {R S : 𝒮} {a b : 𝒳} (f f_1 : R ⟶ S) (e_f : f = f_1)
(φ φ_1 : a ⟶ b) (e_φ : φ = φ_1) [inst_2 : p.IsCartesian f φ] {a' : 𝒳} (φ' φ'_1 : a... | null | true |
RootPairingCat.noConfusion | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {P : Sort u_1} →
{R : Type u} →
{inst : CommRing R} →
{t : RootPairingCat R} →
{R' : Type u} →
{inst' : CommRing R'} →
{t' : RootPairingCat R'} → R = R' → inst ≍ inst' → t ≍ t' → RootPairingCat.noConfusionType P t t' | null | false |
AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens},
IsCompact U.carrier →
∀ (x f : ↑(X.presheaf.obj (Opposite.op U))),
TopCat.Presheaf.restrictOpen x (X.basicOpen f) ⋯ = 0 → ∃ n, f ^ n * x = 0 | If `x : Γ(X, U)` is zero on `D(f)` for some `f : Γ(X, U)`, and `U` is quasi-compact, then
`f ^ n * x = 0` for some `n`. | true |
_private.Lean.AddDecl.0.Lean.isNamespaceName._sparseCasesOn_1 | Lean.AddDecl | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Finset.subtypeInsertEquivOption._proof_11 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Finset α} {x : α} (y : ↥(insert x t)), ¬↑y = x → ↑y ∈ t | null | false |
PrimeSpectrum.comap_injective_of_surjective | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
Function.Surjective ⇑f → Function.Injective (PrimeSpectrum.comap f) | null | true |
_private.Mathlib.Tactic.MoveAdd.0.Lean.Expr.getExprInputs.match_1 | Mathlib.Tactic.MoveAdd | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(bt bb : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName bt bb binderInfo)) →
((binderName : Lean.Name) →
(bt bb : Lean.... | null | false |
AlgebraicGeometry.PresheafedSpace.pushforwardDiagramToColimit._proof_2 | Mathlib.Geometry.RingedSpace.PresheafedSpace.HasColimits | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasColimitsOfShape J TopCat]
(F : CategoryTheory.Functor J (AlgebraicGeometry.PresheafedSpace C)) (j : J),
(CategoryTheory.CategoryStruct.comp
((Top... | null | false |
IsLocalizedModule.surj | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {inst : CommSemiring R} {M : Type u_2} {M' : Type u_3} {inst_1 : AddCommMonoid M}
{inst_2 : AddCommMonoid M'} {inst_3 : Module R M} {inst_4 : Module R M'} (S : Submonoid R) (f : M →ₗ[R] M')
[self : IsLocalizedModule S f] (y : M'), ∃ x, x.2 • y = f x.1 | null | true |
Std.ExtHashMap.noConfusion | Std.Data.ExtHashMap.Basic | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Std.ExtHashMap α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Std.ExtHashM... | null | false |
CategoryTheory.WithTerminal.equivComma_counitIso_hom_app_left_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(X : CategoryTheory.Comma (CategoryTheory.Functor.id (CategoryTheory.Functor C D)) (CategoryTheory.Functor.const C))
(X_1 : C),
(CategoryTheory.WithTerminal.equivComma.counitIso.hom.app X).left.... | null | true |
Batteries.AssocList.mapKey | Batteries.Data.AssocList.Basic | {α : Type u_1} → {δ : Type u_2} → {β : Type u_3} → (α → δ) → Batteries.AssocList α β → Batteries.AssocList δ β | `O(n)`. Map a function `f` over the keys of the list. | true |
Submodule.finrank_span_le_finrank_span | Mathlib.LinearAlgebra.Dimension.DivisionRing | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {R : Type u_1}
[inst_3 : CommRing R] [Nontrivial R] [inst_5 : SMulWithZero R K] [FaithfulSMul R K] [IsScalarTower R K K]
[inst_8 : Module R V] [IsScalarTower R K V] {s : Set V},
s.Finite → Module.finrank K ↥(Submod... | The `K`-rank of the `K`-span of a finite set `s` in `V` is at most the `R`-rank of the
`R`-span of `s`.
This is the `Module.finrank` version of `Submodule.rank_span_le_rank_span`; see also
`Submodule.finrank_span_eq_finrank_span` for an equality in a different setting. | true |
HMul.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{γ : Type w} →
{t : HMul α β γ} →
{α' : Type u} →
{β' : Type v} →
{γ' : Type w} → {t' : HMul α' β' γ'} → α = α' → β = β' → γ = γ' → t ≍ t' → HMul.noConfusionType P t t' | null | false |
UniformSpace.isClosed_ball_of_isSymm_of_isTrans_of_mem_uniformity | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} [inst : UniformSpace X] (x : X) {V : SetRel X X} [V.IsSymm] [V.IsTrans],
V ∈ uniformity X → IsClosed (UniformSpace.ball x V) | null | true |
DistribMulActionSemiHomClass.toDistribMulActionHom.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B] {F : Type u_10}
[inst_6 : FunLike F A B] [inst_7 : DistribMulActionSemiHomClass F (⇑φ) A B] (... | null | true |
String.utf8Len_le_of_suffix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+ cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.of_injective._simp_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ : List (α × Bool)} {x : α × Bool}, FreeGroup.Red [x] L₁ = (L₁ = [x]) | null | false |
_private.Mathlib.Probability.Distributions.Binomial.0.ProbabilityTheory.integral_of_hasLaw_binomial._simp_1_3 | Mathlib.Probability.Distributions.Binomial | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
Aesop.LocalNormSimpRule.rec | Aesop.Rule | {motive : Aesop.LocalNormSimpRule → Sort u} →
((id : Lean.Name) → (simpTheorem : Lean.Term) → motive { id := id, simpTheorem := simpTheorem }) →
(t : Aesop.LocalNormSimpRule) → motive t | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.termσ | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | Lean.ParserDescr | null | true |
Lean.Expr.abstractRangeM | Lean.Meta.Basic | Lean.Expr → ℕ → Array Lean.Expr → Lean.MetaM Lean.Expr | Similar to `abstractM` but consider only the first `min n xs.size` entries in `xs`
It is also similar to `Expr.abstractRange`, but handles metavariables correctly.
It uses `elimMVarDeps` to ensure `e` and the type of the free variables `xs` do not
contain a metavariable `?m` s.t. local context of `?m` contains a free ... | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln_complete._simp_1_37 | Mathlib.Computability.PartrecCode | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
Ultrafilter.coe_le_coe._simp_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {f g : Ultrafilter α}, (↑f ≤ ↑g) = (f = g) | null | false |
Function.locallyFinsuppWithin.memAddSubmonoid | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddMonoid Y]
(D : Function.locallyFinsuppWithin U Y), ⇑D ∈ Function.locallyFinsuppWithin.addSubmonoid U | null | true |
Lean.RArray.get_eq_getImpl | Init.Data.RArray | @Lean.RArray.get = @Lean.RArray.getImpl | null | true |
Ideal.nonPrincipals | Mathlib.RingTheory.PrincipalIdealDomain | (R : Type u) → [inst : Semiring R] → Set (Ideal R) | `nonPrincipals R` is the set of all ideals of `R` that are not principal ideals. | true |
Lean.Core.CoreM.parIter | Lean.Elab.Parallel | {α : Type} → List (Lean.CoreM α) → Lean.CoreM (Std.IterM Lean.CoreM (Except Lean.Exception α)) | Runs a list of CoreM computations in parallel (without cancellation hook).
Returns an iterator that yields results in original order, wrapped in `Except Exception α`.
| true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.decompositionMonoid_iff._simp_1_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ (α : Type u_1) [inst : Semigroup α], DecompositionMonoid α = ∀ (a : α), IsPrimal a | null | false |
Algebra.map_bot | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B), Subalgebra.map f ⊥ = ⊥ | null | true |
AddAction.nsmul_vadd_eq_iff_minimalPeriod_dvd | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type v} {G : Type u} [inst : AddGroup G] [inst_1 : AddAction G α] {a : G} {b : α} {n : ℕ},
n • a +ᵥ b = b ↔ Function.minimalPeriod (fun x => a +ᵥ x) b ∣ n | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.