name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ne_zero_of_dvd_ne_zero | Mathlib.Algebra.GroupWithZero.Divisibility | ∀ {α : Type u_1} [inst : MonoidWithZero α] {p q : α}, q ≠ 0 → p ∣ q → p ≠ 0 | null | true |
Lean.Meta.Canonicalizer.CanonM.run' | Lean.Meta.Canonicalizer | {α : Type} →
Lean.Meta.CanonM α →
optParam Lean.Meta.TransparencyMode Lean.Meta.TransparencyMode.instances →
optParam Lean.Meta.Canonicalizer.State { } → Lean.MetaM α | The definitionally equality tests are performed using the given transparency mode.
We claim `TransparencyMode.instances` is a good setting for most applications.
| true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.splitMax_eq.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : ℕ → Ordnode α → α → Ordnode α → Prop) (x : ℕ) (x_1 : Ordnode α) (x_2 : α) (x_3 : Ordnode α),
(∀ (x : ℕ) (x_4 : Ordnode α) (x_5 : α), motive x x_4 x_5 Ordnode.nil) →
(∀ (x : ℕ) (l : Ordnode α) (x_4 : α) (ls : ℕ) (ll : Ordnode α) (lx : α) (lr : Ordnode α),
motive x l x_4 (Ordnode.... | null | false |
Bool.dite_else_false._simp_1 | Init.PropLemmas | ∀ {p : Prop} [inst : Decidable p] {x : p → Bool}, ((if h : p then x h else false) = true) = ∃ (h : p), x h = true | null | false |
LinearMap.BilinForm.Isometry.mk | Mathlib.LinearAlgebra.BilinearForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
{B₁ : LinearMap.BilinForm R M₁} →
{B₂ : L... | null | true |
IntermediateField.add_mem | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{x y : L}, x ∈ S → y ∈ S → x + y ∈ S | An intermediate field is closed under addition. | true |
Order.IsPredPrelimit.subtypeVal | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α},
IsUpperSet s → ∀ {a : ↑s}, Order.IsPredPrelimit a → Order.IsPredPrelimit ↑a | null | true |
Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___macroRules_Mathlib_Tactic_RingNF_ring_1 | Mathlib.Tactic.Ring.RingNF | Lean.Macro | `ring` solves equations in *commutative* (semi)rings, allowing for variables in the
exponent. If the goal is not appropriate for `ring` (e.g. not an equality) `ring_nf` will be
suggested. See also `ring1`, which fails if the goal is not an equality.
* `ring!` will use a more aggressive reducibility setting to determin... | false |
AlgebraicGeometry.instQuasiCompactLiftSchemeIdOfQuasiSeparatedSpaceCarrierCarrierCommRingCat | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [QuasiSeparatedSpace ↥X],
AlgebraicGeometry.QuasiCompact
(CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X)) | null | true |
unitInterval.instLinearOrderedCommMonoidWithZeroElemReal._proof_1 | Mathlib.Topology.UnitInterval | PosMulStrictMono ↑unitInterval | null | false |
CategoryTheory.Limits.multicospanShapeEnd_fst | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ (J : Type u) [inst : CategoryTheory.Category.{v, u} J] (f : CategoryTheory.Arrow J),
(CategoryTheory.Limits.multicospanShapeEnd J).fst f = f.left | null | true |
Con.lift_funext | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass P] {c : Con M} (f g : c.Quotient →* P),
(∀ (a : M), f ↑a = g ↑a) → f = g | Homomorphisms on the quotient of a monoid by a congruence relation are equal if they
are equal on elements that are coercions from the monoid. | true |
Pi.subtractionMonoid.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → SubtractionMonoid (f i)],
Pi.subtractionMonoid = { toSubNegMonoid := Pi.subNegMonoid, neg_neg := ⋯, neg_add_rev := ⋯, neg_eq_of_add := ⋯ } | null | true |
CategoryTheory.regularEpiOfEpi | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
[CategoryTheory.IsRegularEpiCategory C] → (f : X ⟶ Y) → [CategoryTheory.Epi f] → CategoryTheory.RegularEpi f | In a category in which every epimorphism is regular, we can express every epimorphism as
a coequalizer. This is not an instance because it would create an instance loop. | true |
AddAction.toAddSemigroupAction | Mathlib.Algebra.Group.Action.Defs | {G : Type u_9} → {P : Type u_10} → {inst : AddMonoid G} → [self : AddAction G P] → AddSemigroupAction G P | null | true |
SimpContFract.IsContFract | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} → [inst : One α] → [Zero α] → [LT α] → SimpContFract α → Prop | A simple continued fraction is a *(regular) continued fraction* ((r)cf) if all partial denominators
`bᵢ` are positive, i.e. `0 < bᵢ`.
| true |
SimpleGraph.chromaticNumber_eq_iInf | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} (G : SimpleGraph V), G.chromaticNumber = ⨅ n, ↑↑n | null | true |
StrictConvex.is_linear_preimage | Mathlib.Analysis.Convex.Strict | ∀ {𝕜 : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜]
[inst_2 : TopologicalSpace E] [inst_3 : TopologicalSpace F] [inst_4 : AddCommMonoid E] [inst_5 : AddCommMonoid F]
[inst_6 : Module 𝕜 E] [inst_7 : Module 𝕜 F] {s : Set F},
StrictConvex 𝕜 s → ∀ {f : E → F}, IsLinearMa... | null | true |
RBTree.RBNode.Stream.ctorIdx | BatteriesRecycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode.Stream α → ℕ | null | false |
Distribution.lineDerivOpCLM_eq_lineDerivCLM | Mathlib.Analysis.Distribution.Distribution | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : AddCommGroup F] [inst_3 : Module ℝ F] [inst_4 : TopologicalSpace F] [inst_5 : IsTopologicalAddGroup F]
[inst_6 : ContinuousSMul ℝ F] {v : E}, LineDeriv.lineDerivOpCLM ℝ (Distribution Ω F... | null | true |
Mathlib.Meta.FunProp.LambdaTheorem.getProof | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorem → Lean.MetaM Lean.Expr | Return proof of lambda theorem | true |
mem_skewAdjointMatricesSubmodule._simp_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J A₁ : Matrix n n R)
[inst_2 : DecidableEq n], (A₁ ∈ skewAdjointMatricesSubmodule J) = J.IsSkewAdjoint A₁ | null | false |
_private.Mathlib.Algebra.Group.Conj.0.isConj_iff_eq.match_1_1 | Mathlib.Algebra.Group.Conj | ∀ {α : Type u_1} [inst : CommMonoid α] {a b : α} (motive : IsConj a b → Prop) (x : IsConj a b),
(∀ (c : αˣ) (hc : SemiconjBy (↑c) a b), motive ⋯) → motive x | null | false |
ContinuousMultilinearMap.compContinuousLinearMapL._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NormedField 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F],
SMulCommClass 𝕜 𝕜 F | null | false |
TopCat.pullbackHomeoPreimage._proof_7 | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {X : Type u_2} {Y : Type u_3} {Z : Type u_1} (f : X → Z) (g : Y → Z) (x : ↑(f ⁻¹' Set.range g)),
f ↑x = g (Exists.choose ⋯) | null | false |
GaloisInsertion.mk._flat_ctor | Mathlib.Order.GaloisConnection.Defs | {α : Type u_2} →
{β : Type u_3} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{l : α → β} →
{u : β → α} →
(choice : (x : α) → u (l x) ≤ x → β) →
GaloisConnection l u →
(∀ (x : β), x ≤ l (u x)) → (∀ (a : α) (h : u (l a) ≤ a), choice a h = l a) → G... | null | false |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.filter_le.match_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I) (p : BoxIntegral.Box ι → Prop)
(J : BoxIntegral.Box ι) (motive : J ∈ π ∧ p J → Prop) (x : J ∈ π ∧ p J),
(∀ (hπ : J ∈ π) (right : p J), motive ⋯) → motive x | null | false |
Finset.shadow_mono | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 ℬ : Finset (Finset α)}, 𝒜 ⊆ ℬ → 𝒜.shadow ⊆ ℬ.shadow | null | true |
ProofWidgets.RpcEncodablePacket.goals._@.ProofWidgets.Component.Panel.Basic.2840189264._hygCtx._hyg.1 | ProofWidgets.Component.Panel.Basic | ProofWidgets.RpcEncodablePacket✝ → Lean.Json | null | false |
CategoryTheory.LaxMonoidalFunctor.isoOfComponents | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F G : CategoryTheory.LaxMonoidalFunctor C D} →
... | Constructor for isomorphisms between lax monoidal functors. | true |
UInt8.ofFin | Init.Data.UInt.Basic | Fin UInt8.size → UInt8 | Converts a `Fin UInt8.size` into the corresponding `UInt8`. | true |
Affine.Simplex.points_mem_affineSpan_faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] [Nontrivial k] {n : ℕ} [inst_5 : NeZero n] (s : Affine.Simplex k P n) {i j : Fin (n + 1)},
s.points j ∈ affineSpan k (Set.range (s.faceOpposite i).points) ↔ j ≠ i | null | true |
AlgebraicGeometry.Scheme.canonicallyOverPullback | Mathlib.AlgebraicGeometry.Pullbacks | {M S T : AlgebraicGeometry.Scheme} →
[inst : M.Over S] → {f : T ⟶ S} → (CategoryTheory.Limits.pullback (M ↘ S) f).CanonicallyOver T | null | true |
cfc_add_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
LinearMap.FiniteRangeSetoid.equiv_comp_right | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_4} {V₃ : Type u_6} [inst : CommRing K] [inst_1 : AddCommGroup V]
[inst_2 : Module K V] [inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] [inst_5 : AddCommGroup V₃]
[inst_6 : Module K V₃] {u : V →ₗ[K] V₂} {v v' : V₂ →ₗ[K] V₃}, v ≈ v' → v ∘ₗ u ≈ v' ∘ₗ u | null | true |
CategoryTheory.Abelian.Preradical.ι_π | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ : CategoryTheory.Abelian.Preradical C), CategoryTheory.CategoryStruct.comp Φ.ι Φ.π = 0 | null | true |
_private.Plausible.Testable.0.Plausible.Decorations._aux_Plausible_Testable___elabRules_Plausible_Decorations_tacticMk_decorations_1.match_1 | Plausible.Testable | (motive : Lean.Expr → Sort u_1) →
(goalType : Lean.Expr) →
((us : List Lean.Level) →
(body : Lean.Expr) → motive ((Lean.Expr.const `Plausible.Decorations.DecorationsOf us).app body)) →
((x : Lean.Expr) → motive x) → motive goalType | null | false |
Int32.ofIntLE_le_iff_le | Init.Data.SInt.Lemmas | ∀ {a b : ℤ} (ha₁ : Int32.minValue.toInt ≤ a) (ha₂ : a ≤ Int32.maxValue.toInt) (hb₁ : Int32.minValue.toInt ≤ b)
(hb₂ : b ≤ Int32.maxValue.toInt), Int32.ofIntLE a ha₁ ha₂ ≤ Int32.ofIntLE b hb₁ hb₂ ↔ a ≤ b | null | true |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₁ = false →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.diff m₂ ⋯) k fallback = fallback | null | true |
LieEquiv.map_lie | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) (x y : L₁), e ⁅x, y⁆ = ⁅e x, e y⁆ | null | true |
CategoryTheory.StrongEpi.of_arrow_iso | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g) [h : CategoryTheory.StrongEpi f],
CategoryTheory.StrongEpi g | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_filter_key | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] {f : α → Bool}
{k fallback : α} (h : t.WF),
(Std.DTreeMap.Internal.Impl.filter (fun k x => f k) t ⋯).impl.getKeyD k fallback =
(Option.filter f (t.getKey? k)).getD fallback | null | true |
ContinuousAffineMap.vadd_toAffineMap | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {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] [inst_9 : Topolog... | null | true |
_private.Lean.Meta.Match.MatchEqs.0.Lean.Meta.Match.initFn._@.Lean.Meta.Match.MatchEqs.136844199._hygCtx._hyg.2 | Lean.Meta.Match.MatchEqs | IO Unit | null | false |
Dyadic.neg.eq_1 | Init.Data.Dyadic.Basic | Dyadic.zero.neg = Dyadic.zero | null | true |
Lean.PrettyPrinter.Formatter.Context.mk.inj | Lean.PrettyPrinter.Formatter | ∀ {options : Lean.Options} {table : Lean.Parser.TokenTable} {options_1 : Lean.Options}
{table_1 : Lean.Parser.TokenTable},
{ options := options, table := table } = { options := options_1, table := table_1 } →
options = options_1 ∧ table = table_1 | null | true |
AddAction.vadd_mem_of_set_mem_fixedBy | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {s : Set α} {g : G},
s ∈ AddAction.fixedBy (Set α) g → ∀ {x : α}, g +ᵥ x ∈ s ↔ x ∈ s | null | true |
Set.unitEquivUnitsInteger._proof_3 | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K],
Function.RightInverse (fun x => ⟨Units.mk0 ↑↑x ⋯, ⋯⟩) fun x =>
{ val := ⟨↑↑x, ⋯⟩, inv := ⟨↑(↑x)⁻¹, ⋯⟩, val_i... | null | false |
Lean.Lsp.instToJsonCodeActionClientCapabilities | Lean.Data.Lsp.CodeActions | Lean.ToJson Lean.Lsp.CodeActionClientCapabilities | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.mkPairs.loop | Lean.Elab.BuiltinNotation | Array Lean.Term → ℕ → Lean.Term → Lean.MacroM Lean.Term | null | true |
CategoryTheory.IsHomLift.id_comp_lift | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsHomLift f φ],
p.IsHomLift f (CategoryTheory.CategoryStruct.comp φ (CategoryTheory.CategoryStruct.id b)) | null | true |
Std.DTreeMap.Internal.Impl.getEntryLE!_eq_get!_getEntryLE? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {k : α}
[inst_1 : Inhabited ((a : α) × β a)],
Std.DTreeMap.Internal.Impl.getEntryLE! k t = (Std.DTreeMap.Internal.Impl.getEntryLE? k t).get! | null | true |
_private.Lean.ReservedNameAction.0.Lean.initFn._@.Lean.ReservedNameAction.2721971034._hygCtx._hyg.2 | Lean.ReservedNameAction | IO (IO.Ref (Array Lean.ReservedNameAction)) | null | false |
ciSup_eq_top_of_top_mem | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : OrderTop α] {f : ι → α},
⊤ ∈ Set.range f → iSup f = ⊤ | null | true |
DomMulAct.isInducing_mk_symm | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M], Topology.IsInducing ⇑DomMulAct.mk.symm | null | true |
Sym2.toRel_symm | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (s : Set (Sym2 α)), Std.Symm (Sym2.ToRel s) | null | true |
InnerProductSpace.Core.inner_add_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y z : F), inner 𝕜 (x + y) z = inner 𝕜 x z + inner 𝕜 y z | null | true |
CategoryTheory.Abelian.SpectralObject.sc₃._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Basic | Lean.Syntax | null | false |
Homeomorph.mulLeft | Mathlib.Topology.Algebra.Group.Basic | {G : Type w} → [inst : TopologicalSpace G] → [inst_1 : Group G] → [SeparatelyContinuousMul G] → G → G ≃ₜ G | Multiplication from the left in a topological group as a homeomorphism. | true |
AlgebraicGeometry.StructureSheaf.Localizations.comapFun._proof_9 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] {N : Type u_1} [inst_2 : AddCommGroup N]
[inst_3 : Module S N] {σ : R →+* S} (y : ↑(AlgebraicGeometry.PrimeSpectrum.Top S)),
LinearMap.CompatibleSMul N (LocalizedModule y.asIdeal.primeCompl N) R S | null | false |
BitVec.sshiftRight_xor_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (n : ℕ), (x ^^^ y).sshiftRight n = x.sshiftRight n ^^^ y.sshiftRight n | null | true |
AddOreLocalization.zero_add | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S]
(x : AddOreLocalization S R), 0 + x = x | null | true |
AlgebraicTopology.DoldKan.N₁_obj_p | Mathlib.AlgebraicTopology.DoldKan.FunctorN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C), (AlgebraicTopology.DoldKan.N₁.obj X).p = AlgebraicTopology.DoldKan.PInfty | null | true |
GenContFract.convs'_succ | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K) (n : ℕ)
[IsStrictOrderedRing K], (GenContFract.of v).convs' (n + 1) = ↑⌊v⌋ + 1 / (GenContFract.of (Int.fract v)⁻¹).convs' n | The recurrence relation for the `convs'` of the continued fraction expansion
of an element `v` of `K` in terms of the convergents of the inverse of its fractional part.
| true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.instIsTriangulatedOppositeOpOp._proof_2 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | 1 + -1 = 0 | null | false |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.ofList_eq_empty_iff._simp_1_2 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u_1} {l : List α}, (l = []) = (l.isEmpty = true) | null | false |
Cardinal.not_isSingular_succ | Mathlib.SetTheory.Cardinal.Regular | ∀ (c : Cardinal.{u_1}), ¬(Order.succ c).IsSingular | null | true |
Int.Linear.eq_def'_cert | Init.Data.Int.Linear | Int.Linear.Var → Int.Linear.Expr → Int.Linear.Poly → Bool | null | true |
UInt8.or_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a ||| b = 0) = (a = 0 ∧ b = 0) | null | false |
Set.powersetCard.mulActionHom_of_embedding.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] (n : ℕ) [inst_2 : DecidableEq α],
Set.powersetCard.mulActionHom_of_embedding G α n = { toFun := Set.powersetCard.ofFinEmb n α, map_smul' := ⋯ } | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k : ℤ} {c₁_1 c₂_1 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr} {k_1 : ℤ},
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁ c₂ k =
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.combineDivCoeffs c₁_1 c₂_1 k_1 →
c₁ = c₁_1 ∧ c₂ = c₂_1 ∧ k = k_1 | null | true |
CategoryTheory.preserves_mono_of_preservesLimit | Mathlib.CategoryTheory.Limits.Constructions.EpiMono | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f f) F] [CategoryTheory.Mono f],
CategoryTheory.Mono (F.map f) | If `F` preserves pullbacks, then it preserves monomorphisms. | true |
Submonoid.adjoin_eq_span_of_eq_span | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (F : Type u_1) (E : Type u_2) {K : Type u_3} [inst : CommSemiring E] [inst_1 : Semiring K] [inst_2 : SMul F E]
[inst_3 : Algebra E K] [inst_4 : Semiring F] [inst_5 : Module F K] [IsScalarTower F E K] (L : Submonoid K)
{S : Set K}, ↑L = ↑(Submodule.span F S) → Subalgebra.toSubmodule (Algebra.adjoin E ↑L) = Submodu... | If `K / E / F` is a ring extension tower, `L` is a submonoid of `K / F` which is generated by
`S` as an `F`-module, then `E[L]` is generated by `S` as an `E`-module. | true |
Lean.Meta.Grind.CongrKey.ctorIdx | Lean.Meta.Tactic.Grind.Types | {enodes : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodes → ℕ | null | false |
Finpartition.part | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : DecidableEq α] → {s : Finset α} → Finpartition s → α → Finset α | The part of the finpartition that `a` lies in. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
MeasureTheory.Lp.ext_iff | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f g : ↥(MeasureTheory.Lp E p μ)}, f = g ↔ ↑↑f =ᵐ[μ] ↑↑g | null | true |
Std.Internal.List.getKeyD_eq_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [LawfulBEq α] {l : List ((a : α) × β a)} {k fallback : α},
Std.Internal.List.containsKey k l = true → Std.Internal.List.getKeyD k l fallback = k | null | true |
_aux_Init_Notation___unexpand_Dvd_dvd_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | null | false |
LinearMap.coprod_comp_inl_inr | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M × M₂ →ₗ[R] M₃), (f ∘ₗ LinearMap.inl R M M₂).coprod (f ∘ₗ LinearMap.inr R M M₂) = f | null | true |
Std.DHashMap.Internal.Raw.fold_cons_key | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {l : Std.DHashMap.Raw α β} {acc : List α},
Std.DHashMap.Raw.fold (fun acc k x => k :: acc) acc l =
Std.Internal.List.keys (Std.DHashMap.Internal.toListModel l.buckets).reverse ++ acc | null | true |
_private.Mathlib.Util.FormatTable.0.formatTable.match_1 | Mathlib.Util.FormatTable | (motive : ℕ → Alignment → Sort u_1) →
(w : ℕ) →
(a : Alignment) →
((x : Alignment) → motive 0 x) →
((x : Alignment) → motive 1 x) →
((n : ℕ) → motive n.succ.succ Alignment.left) →
((n : ℕ) → motive n.succ.succ Alignment.right) →
((n : ℕ) → motive n.succ.succ Align... | null | false |
mdifferentiableWithinAt_inter | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
Array.findIdx_extract | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {p : α → Bool}, Array.findIdx p (xs.extract 0 i) = min i (Array.findIdx p xs) | null | true |
AddCon.coe_iInf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {ι : Sort u_4} (f : ι → AddCon M), ⨅ i, ⇑(f i) = ⇑(iInf f) | null | false |
Nat.addUnits_eq_zero | Mathlib.Algebra.Group.Nat.Units | ∀ (u : AddUnits ℕ), u = 0 | null | true |
Filter.EventuallyLE.measure_le | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, s ≤ᵐ[μ] t → μ s ≤ μ t | **Alias** of `MeasureTheory.measure_mono_ae`.
---
If `s ⊆ t` modulo a set of measure `0`, then `μ s ≤ μ t`. | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.mk.sizeOf_spec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ∀ (f fType : Lean.Expr) (args mvars : Array Lean.Expr) (bInfos : Array Lean.BinderInfo) (forceRegularApp : Bool),
sizeOf
{ f := f, fType := fType, args := args, mvars := mvars, bInfos := bInfos, forceRegularApp := forceRegularApp } =
1 + sizeOf f + sizeOf fType + sizeOf args + sizeOf mvars + sizeOf bInfos +... | null | true |
Padic.coe_one | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], ↑1 = 1 | null | true |
LocallyConstant.comapRingHom._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_1}
[inst_2 : Semiring Z] (f : C(X, Y)), (↑(LocallyConstant.comapAddMonoidHom f)).toFun 0 = 0 | null | false |
AlgebraicGeometry.Scheme.LocalRepresentability.yonedaGluedToSheaf_app_toGlued | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u)} {ι : Type u}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) {i : ι},
(CategoryTheory.ConcreteCategory.hom
((Algebrai... | null | true |
Subgroup.upperCentralSeriesAux._sunfold | Mathlib.GroupTheory.Nilpotent | (G : Type u_1) → [inst : Group G] → ℕ → (H : Subgroup G) ×' H.Characteristic | null | false |
fderivPolarCoordSymm._proof_8 | Mathlib.Analysis.SpecialFunctions.PolarCoord | Module.Finite ℝ (ℝ × ℝ) | null | false |
RingEquiv.nonUnitalSubringCongr | Mathlib.RingTheory.NonUnitalSubring.Basic | {R : Type u} → [inst : NonUnitalRing R] → {s t : NonUnitalSubring R} → s = t → ↥s ≃+* ↥t | Makes the identity isomorphism from a proof two `NonUnitalSubring`s of a multiplicative
monoid are equal. | true |
ContinuousMap.semilatticeInf | Mathlib.Topology.ContinuousMap.Ordered | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : SemilatticeInf β] → [ContinuousInf β] → SemilatticeInf C(α, β) | null | true |
UniqueFactorizationMonoid.radical_mul | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a b : M},
IsRelPrime a b →
UniqueFactorizationMonoid.radical (a * b) =
UniqueFactorizationMonoid.radical a * UniqueFactorizationMonoid.radical b | Radical is multiplicative for relatively prime elements. | true |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe.eq_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X) (hs : Nonempty ↥s),
s.openPartialHomeomorphSubtypeCoe hs = Topology.IsOpenEmbedding.toOpenPartialHomeomorph Subtype.val ⋯ | null | true |
Real.rpow_eq_const_mul_integral | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 0 1 →
0 ≤ x → x ^ p = (∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₀₁ t 1)⁻¹ * ∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₀₁ t x | The integral representation of the function `x ↦ x^p` (where `p ∈ (0, 1)`) . | true |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.balance2.match_1.eq_2 | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} (motive : RBTree.RBNode α → α → RBTree.RBNode α → Sort u_2) (a : RBTree.RBNode α) (x : α)
(b : RBTree.RBNode α) (y : α) (c : RBTree.RBNode α) (z : α) (d : RBTree.RBNode α)
(h_1 :
(a : RBTree.RBNode α) →
(x : α) →
(b : RBTree.RBNode α) →
(y : α) →
(c : RBTree.... | null | true |
ConcaveOn.sub_strictConvexOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f g : E → β}, ConcaveOn 𝕜 s f → StrictConvexOn 𝕜 s g → Stri... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.