name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Async.Interval._sizeOf_inst | Std.Async.Timer | SizeOf Std.Async.Interval | null | false |
GradedAlgHom.toEnd._proof_2 | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {ι : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] {𝒜 : ι → Submodule R A} [inst_5 : GradedAlgebra 𝒜]
(x x_1 : 𝒜 →ₐᵍ[R] 𝒜), ↑(x * x_1) = ↑(x * x_1) | null | false |
ContMDiffWithinAt.div | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] {E'... | null | true |
_private.Init.Data.String.Lemmas.Splits.0.String.Pos.splits_next_right._simp_1_1 | Init.Data.String.Lemmas.Splits | ∀ {s₁ s₂ s₃ : String}, s₁ ++ (s₂ ++ s₃) = s₁ ++ s₂ ++ s₃ | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_inter_of_contains_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) | null | false |
Std.Time.TimeZone.TransitionRule.mk.noConfusion | Std.Time.Zoned.RecurringRule | {P : Sort u} →
{spec : Std.Time.TimeZone.TransitionSpec} →
{time : Std.Time.Second.Offset} →
{spec' : Std.Time.TimeZone.TransitionSpec} →
{time' : Std.Time.Second.Offset} →
{ spec := spec, time := time } = { spec := spec', time := time' } → (spec = spec' → time = time' → P) → P | null | false |
String.Slice.takeEndWhile_copy | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat]
[inst_1 : String.Slice.Pattern.Model.PatternModel pat] [String.Slice.Pattern.Model.LawfulBackwardPatternModel pat]
{s : String.Slice}, (s.copy.takeEndWhile pat).copy = (s.takeEndWhile pat).copy | null | true |
Polynomial.Sequence.ctorIdx | Mathlib.Algebra.Polynomial.Sequence | {R : Type u_1} → {inst : Semiring R} → Polynomial.Sequence R → ℕ | null | false |
Submodule.Quotient.smulCommClass | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {S : Type u_3}
[inst_3 : SMul S R] [inst_4 : SMul S M] [inst_5 : IsScalarTower S R M] (P : Submodule R M) (T : Type u_4)
[inst_6 : SMul T R] [inst_7 : SMul T M] [inst_8 : IsScalarTower T R M] [SMulCommClass S T M],
SMu... | null | true |
Std.Time.instHAddOffset | Std.Time.Date.Basic | HAdd Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset Std.Time.Nanosecond.Offset | null | true |
MonoidAlgebra.tensorEquiv | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | (R : Type u_1) →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommSemiring R] → TensorProduct R (MonoidAlgebra R M) (MonoidAlgebra R N) ≃ₗ[R] MonoidAlgebra R (M × N) | The tensor product of two monoid algebras is the monoid algebra of their product. | true |
Aesop.Options.useDefaultSimpSet._default | Aesop.Options.Public | Bool | null | false |
R_mul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) {G : Type u_8}
[inst_4 : Semigroup G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [inst_7 : ContMD... | null | true |
LieModule.trivial_iff_lower_central_eq_bot | Mathlib.Algebra.Lie.Nilpotent | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M],
LieModule.IsTrivial L M ↔ LieModule.lowerCentralSeries R L M 1 = ⊥ | null | true |
Complex.sqrt_neg_I | Mathlib.Analysis.RCLike.Sqrt | (-Complex.I).sqrt = ↑√2⁻¹ * (1 - Complex.I) | null | true |
SaturatedAddSubmonoid.instSetLike.eq_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ (M : Type u_1) [inst : AddZeroClass M],
SaturatedAddSubmonoid.instSetLike M = { coe := fun x => x.carrier, coe_injective := ⋯ } | null | true |
IntermediateField.instMulActionSubtypeMem | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] → {X : Type u_4} → [MulAction L X] → (F : IntermediateField K L) → MulAction (↥F) X | The action by an intermediate field is the action by the underlying field. | true |
Set.mem_toFinset | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s] {a : α}, a ∈ s.toFinset ↔ a ∈ s | null | true |
instLipschitzMulMultiplicativeOfLipschitzAdd | Mathlib.Topology.MetricSpace.Algebra | ∀ (α : Type u_1) [inst : PseudoMetricSpace α] [inst_1 : AddMonoid α] [LipschitzAdd α], LipschitzMul (Multiplicative α) | null | true |
Complex.instIsComplete | Mathlib.Analysis.Complex.Norm | CauSeq.IsComplete ℂ fun x => ‖x‖ | null | true |
AddCommGrpCat.addCommGroupObj.eq_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J AddCommGrpCat) (j : J),
AddCommGrpCat.addCommGroupObj F j =
{ toZero := AddCommGrpCat.addCommGroupObj._aux_1 F j, toAdd := AddCommGrpCat.addCommGroupObj._aux_3 F j,
add_assoc := ⋯, zero_add := ⋯, add_zero := ⋯, toNSMul :=... | null | true |
Polynomial.smeval_X | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Semiring R] {S : Type u_2} [inst_1 : AddCommMonoid S] [inst_2 : Pow S ℕ]
[inst_3 : MulActionWithZero R S] (x : S), Polynomial.X.smeval x = x ^ 1 | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.fix?.match_1 | Batteries.Data.MLList.Basic | {α : Type u_1} →
(motive : Option α → Sort u_2) →
(__do_lift : Option α) → (Unit → motive none) → ((x' : α) → motive (some x')) → motive __do_lift | null | false |
Lean.Grind.Linarith.eq_normN | Init.Grind.Module.NatModuleNorm | ∀ {α : Type u_1} [inst : Lean.Grind.NatModule α] (ctx : Lean.Grind.Linarith.Context α)
(lhs rhs : Lean.Grind.Linarith.Expr),
Lean.Grind.Linarith.eq_normN_cert lhs rhs = true →
Lean.Grind.Linarith.Expr.denoteN ctx lhs = Lean.Grind.Linarith.Expr.denoteN ctx rhs | null | true |
CliffordAlgebra.range_ι_le_evenOdd_one | Mathlib.LinearAlgebra.CliffordAlgebra.Grading | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), (CliffordAlgebra.ι Q).range ≤ CliffordAlgebra.evenOdd Q 1 | null | true |
FixedDetMatrices.reduce | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | {m : ℤ} → FixedDetMatrix (Fin 2) ℤ m → FixedDetMatrix (Fin 2) ℤ m | Map from `Δ m → Δ m` which reduces a `FixedDetMatrix` towards a representative element
in reps | true |
ContractibleSpace.recOn | Mathlib.Topology.Homotopy.Contractible | {X : Type u_1} →
[inst : TopologicalSpace X] →
{motive : ContractibleSpace X → Sort u} →
(t : ContractibleSpace X) → ((hequiv_unit' : Nonempty (ContinuousMap.HomotopyEquiv X Unit)) → motive ⋯) → motive t | null | false |
CategoryTheory.Endofunctor.Algebra.equivOfNatIso._proof_1 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {F G : CategoryTheory.Functor C C} (α : F ≅ G),
CategoryTheory.CategoryStruct.id F = CategoryTheory.CategoryStruct.comp α.hom α.inv | null | false |
Std.Time.TimeZone.DaylightSavingRule.recOn | Std.Time.Zoned.RecurringRule | {motive : Std.Time.TimeZone.DaylightSavingRule → Sort u} →
(t : Std.Time.TimeZone.DaylightSavingRule) →
((name : String) →
(offset : Std.Time.TimeZone.Offset) →
(start end_ : Option Std.Time.TimeZone.TransitionRule) →
motive { name := name, offset := offset, start := start, end_ := e... | null | false |
LieSubmodule.instSupSet._proof_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (S : Set (LieSubmodule R L M)) {x : L} {m : M},
m ∈ (sSup {x | ∃ p ∈ S, ↑p = x}).carrier → ⁅x, m⁆ ∈ (sSup {x | ∃ p ∈ S, ↑p = x}).carrier | null | false |
OrderDual.instCommSemigroup._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : CommSemigroup α] (a b : αᵒᵈ), a * b = b * a | null | false |
Std.StreamMap.toArray | Std.Sync.StreamMap | {α β : Type} → Std.StreamMap α β → Array (α × Std.Async.Selector β) | Convert to array of name-selector pairs
| true |
PontryaginDual.ext | Mathlib.Topology.Algebra.PontryaginDual | ∀ {A : Type u_1} [inst : Monoid A] [inst_1 : TopologicalSpace A] {ψ φ : PontryaginDual A},
(∀ (a : A), ψ a = φ a) → ψ = φ | null | true |
Lean.Parser.Term.sufficesDecl.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Mathlib.Data.Set.Order.0.Set.not_monotoneOn_not_antitoneOn_iff_exists_le_le._simp_1_3 | Mathlib.Data.Set.Order | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
AlgebraicGeometry.Spec.basicOpen_hom_ext | Mathlib.AlgebraicGeometry.Spec | ∀ {X : AlgebraicGeometry.RingedSpace} {R : CommRingCat} {α β : X ⟶ AlgebraicGeometry.Spec.sheafedSpaceObj R}
(w : α.hom.base = β.hom.base),
(∀ (r : ↑R),
let U := PrimeSpectrum.basicOpen r;
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
(CommRingCat.ofHom
... | null | true |
subtypeOrEquiv.congr_simp | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} (p q : α → Prop) [inst : DecidablePred p] (h : Disjoint p q),
subtypeOrEquiv p q h = subtypeOrEquiv p q h | null | true |
InnerProductSpace.toInnerProductSpaceable_ofReal | Mathlib.Analysis.InnerProductSpace.OfNorm | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [InnerProductSpace ℝ E], InnerProductSpaceable E | null | true |
MeasureTheory.setIntegral_norm_condExp_le | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_2} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] {s : Set α},
MeasurableSet s → ∀ (f : α → E), ∫ (x : α) in s, ‖μ[f | m] x‖ ∂μ ≤ ∫ (x : α) in s, ‖f x‖ ∂μ | null | true |
Lean.Meta.Sym.Arith.CommRing.mk | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.Ring →
Option Lean.Expr →
Option ℕ → Lean.Expr → Lean.Expr → Option Lean.Expr → Option Lean.Expr → Lean.Meta.Sym.Arith.CommRing | null | true |
String.Pos.next._proof_1 | Init.Data.String.Basic | ∀ {s : String} (pos : s.Pos), pos ≠ s.endPos → String.Pos.ofToSlice pos.toSlice ≠ String.Pos.ofToSlice s.toSlice.endPos | null | false |
Submodule.comapSubtypeEquivOfLe._proof_1 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (hpq : p ≤ q) (x : ↥(Submodule.comap q.subtype p)),
(fun x => ⟨⟨↑x, ⋯⟩, ⋯⟩) ((fun x => ⟨↑↑x, ⋯⟩) x) = x | null | false |
String.Slice.Pattern.Model.IsLongestRevMatchAt.recOn | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{s : String.Slice} →
{startPos endPos : s.Pos} →
{motive : String.Slice.Pattern.Model.IsLongestRevMatchAt pat startPos endPos → Sort u} →
(t : String.Slice.Pattern.Model.IsLongestRevMatchAt pat star... | null | false |
Sigma.isEmpty_fibers | Mathlib.Basic.IsEmpty.Defs | ∀ {α : Type u_1} {E : α → Type v} [∀ (a : α), IsEmpty (E a)], IsEmpty (Sigma E) | null | true |
Subgroup.coe_center | Mathlib.GroupTheory.Subgroup.Center | ∀ (G : Type u_1) [inst : Group G], ↑(Subgroup.center G) = Set.center G | null | true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor_const._simp_1_1 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {α : Type u_2} [inst : LinearOrderedAddCommGroupWithTop α], (⊤ = 0) = False | null | false |
UpperSet.symm_map | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β),
(UpperSet.map f).symm = UpperSet.map f.symm | null | true |
Lean.Lsp.LeanStaleDependencyParams.mk.sizeOf_spec | Lean.Data.Lsp.Internal | ∀ (staleDependency : Lean.Lsp.DocumentUri), sizeOf { staleDependency := staleDependency } = 1 + sizeOf staleDependency | null | true |
MeasureTheory.hasFiniteIntegral_neg_iff | Mathlib.MeasureTheory.Function.L1Space.HasFiniteIntegral | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β}, MeasureTheory.HasFiniteIntegral (-f) μ ↔ MeasureTheory.HasFiniteIntegral f μ | null | true |
_private.Init.Data.Range.Lemmas.0.Std.Legacy.Range.forIn'.eq_1 | Init.Data.Range.Lemmas | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] (range : Std.Legacy.Range) (init : β)
(f : (i : ℕ) → i ∈ range → β → m (ForInStep β)),
range.forIn' init f = Std.Legacy.Range.forIn'.loop✝ range f init range.start ⋯ ⋯ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_inter_of_contains_eq_false_left._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 |
iteratedFDeriv_eq_equiv_comp | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {f : 𝕜 → F},
iteratedFDeriv 𝕜 n f = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F) ∘ iteratedDeriv n f | Write the iterated Fréchet derivative as the composition of a continuous linear equiv and the
iterated derivative. | true |
MaxTropical.untrop_mul | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : Add R] (x y : MaxTropical R),
MaxTropical.untrop (x * y) = MaxTropical.untrop x + MaxTropical.untrop y | null | true |
CategoryTheory.ReflQuiver.recOn | Mathlib.Combinatorics.Quiver.ReflQuiver | {obj : Type u} →
{motive : CategoryTheory.ReflQuiver obj → Sort u_1} →
(t : CategoryTheory.ReflQuiver obj) →
([toQuiver : Quiver obj] → (id : (X : obj) → X ⟶ X) → motive { toQuiver := toQuiver, id := id }) → motive t | null | false |
CategoryTheory.Limits.coconeOfDiagramInitial._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {X : J} (hX : CategoryTheory.Limits.IsInitial X)
(F : CategoryTheory.Functor J C) [∀ (i j : J) (f : j ⟶ i), CategoryTheory.IsIso (F.map f)] (x : J),
CategoryTheory.IsIso (F.map (hX.to x)) | null | false |
Lean.TraceData.tag | Lean.Message | Lean.TraceData → String | Optional tag shown in `trace.profiler.output` output after the trace class name. | true |
Nat.length_toList_ric | Init.Data.Range.Polymorphic.NatLemmas | ∀ {b : ℕ}, (*...=b).toList.length = b + 1 | null | true |
_private.Mathlib.Topology.Compactness.CountablyCompact.0.isCountablyCompact_iff_infinite_subset_has_accPt._proof_1_2 | Mathlib.Topology.Compactness.CountablyCompact | ∀ {E : Type u_1} {A : Set E} (x : ℕ → E), Set.range x \ A ⊆ x '' {a | x a ∉ A} | null | false |
uniformContinuous_sInf_rng | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} {f : α → β} {u₁ : UniformSpace α} {u₂ : Set (UniformSpace β)},
UniformContinuous f ↔ ∀ u ∈ u₂, UniformContinuous f | null | true |
MeasureTheory.Measure.haveLebesgueDecomposition_of_sigmaFinite | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SFinite μ]
[MeasureTheory.SigmaFinite ν], μ.HaveLebesgueDecomposition ν | **The Lebesgue decomposition theorem**:
Any s-finite measure `μ` has Lebesgue decomposition with respect to any σ-finite measure `ν`.
That is to say, there exist a measure `ξ` and a measurable function `f`,
such that `ξ` is mutually singular with respect to `ν` and `μ = ξ + ν.withDensity f` | true |
ENNReal.ofReal_eq_zero._simp_1 | Mathlib.Basic.ENNReal.Real | ∀ {p : ℝ}, (ENNReal.ofReal p = 0) = (p ≤ 0) | null | false |
CategoryTheory.Mon.mkIso'_inv_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {M N : C}
[inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (e : M ≅ N)
[inst_4 : CategoryTheory.IsMonHom e.hom], (CategoryTheory.Mon.mkIso' e).inv.hom = e.inv | null | true |
_private.Batteries.Lean.NameMapAttribute.0.Lean.NameMapExtension.add.match_1 | Batteries.Lean.NameMapAttribute | {α : Type} →
(motive : Option α → Sort u_1) →
(x : Option α) → ((val : α) → motive (some val)) → ((x : Option α) → motive x) → motive x | null | false |
divp.eq_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a : α) (u : αˣ), a /ₚ u = a * ↑u⁻¹ | null | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsCyclotomicExtension.Rat.isIntegralClosure_adjoin_singleton._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ p) = (x ∈ ↑p) | null | false |
_private.Mathlib.Analysis.Polynomial.CauchyBound.0.Polynomial.IsRoot.norm_lt_cauchyBound._simp_1_5 | Mathlib.Analysis.Polynomial.CauchyBound | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.Tactic.Echelon.Cert.0.Mathlib.Tactic.Echelon.certifyDecomposition._proof_3 | Mathlib.Tactic.Echelon.Cert | ∀ {u : Lean.Level} {α : Q(Type u)} (rα : Q(CommRing «$α»)) (mα : Q(Mul «$α»))
(__defeqres : PLift («$mα» =Q instDistribOfSemiring.toMul)), «$mα» =Q instDistribOfSemiring.toMul | null | false |
TensorProduct.directLimitLeft._proof_1 | Mathlib.LinearAlgebra.TensorProduct.DirectLimit | ∀ {R : Type u_4} [inst : CommSemiring R] {ι : Type u_1} [inst_1 : DecidableEq ι] [inst_2 : Preorder ι]
{G : ι → Type u_2} [inst_3 : (i : ι) → AddCommMonoid (G i)] [inst_4 : (i : ι) → Module R (G i)]
(f : (i j : ι) → i ≤ j → G i →ₗ[R] G j) (M : Type u_3) [inst_5 : AddCommMonoid M] [inst_6 : Module R M],
TensorProd... | null | false |
Lean.Lsp.CompletionParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toTextDocumentPositionParams toTextDocumentPositionParams_1 : Lean.Lsp.TextDocumentPositionParams},
{ toTextDocumentPositionParams := toTextDocumentPositionParams } =
{ toTextDocumentPositionParams := toTextDocumentPositionParams_1 } →
toTextDocumentPositionParams = toTextDocumentPositionParams_1 | null | true |
_private.Mathlib.Tactic.ModCases.0.Mathlib.Tactic.ModCases.NatMod.onModCases_succ.match_1 | Mathlib.Tactic.ModCases | {n a : ℕ} →
(b z : ℕ) →
(motive : b ≤ z ∧ z < n ∧ a ≡ z [MOD n] → Sort u_1) →
(x : b ≤ z ∧ z < n ∧ a ≡ z [MOD n]) → ((h₁ : b ≤ z) → (h₂ : z < n ∧ a ≡ z [MOD n]) → motive ⋯) → motive x | null | false |
AddCommGrpCat.factorThruImage | Mathlib.Algebra.Category.Grp.Images | {G H : AddCommGrpCat} → (f : G ⟶ H) → G ⟶ AddCommGrpCat.image f | the corestriction map to the image | true |
Real.Angle.cos_eq_iff_coe_eq_or_eq_neg | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ ψ : ℝ}, Real.cos θ = Real.cos ψ ↔ ↑θ = ↑ψ ∨ ↑θ = -↑ψ | null | true |
NonemptyChain.isChain' | Mathlib.Order.BourbakiWitt | ∀ {α : Type u_4} [inst : LE α] (self : NonemptyChain α), IsChain (fun x1 x2 => x1 ≤ x2) self.carrier | null | true |
LieAlgebra.equivOfRootSystemEquiv._proof_9 | Mathlib.Algebra.Lie.Basis.Base | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_5 : H.IsCartanSubalgebra]
[inst_6 : LieModule.IsTriangularizable K (↥H) L] [inst_7 : LieAlgebra.IsSimple K L],
Nonempty (LieAlgebra.I... | null | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State.ctorIdx | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State → ℕ | null | false |
Fin.castAdd | Init.Data.Fin.Basic | {n : ℕ} → (m : ℕ) → Fin n → Fin (n + m) | Coarsens a bound to one at least as large.
See also `Fin.natAdd` and `Fin.addNat` for addition functions that increase the bound, and
`Fin.castLE` for a version that uses an explicit inequality proof.
| true |
SubMulAction.instCompleteLattice._proof_3 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_1} {M : Type u_2} [inst : SMul R M] {x y : SubMulAction R M}, ↑x ⊂ ↑y ↔ ↑x ⊂ ↑y | null | false |
_private.Mathlib.Data.Sym.Sym2.Card.0.Sym2.boolProdSym2Equiv._proof_9 | Mathlib.Data.Sym.Sym2.Card | ∀ {α : Type u_1},
Function.LeftInverse
(fun x =>
match x with
| (a, some b) => (decide ((Quot.mk (Sym2.Rel α) (a, b)).out.1 = a), Quot.mk (Sym2.Rel α) (a, b))
| (a, none) => (false, Quot.mk (Sym2.Rel α) (a, a)))
fun x =>
match x with
| (true, z) => (z.out.1, some z.out.2)
| (fals... | null | false |
Std.DTreeMap.Raw.get?_union | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t₁.WF → t₂.WF → ∀ {k : α}, (t₁ ∪ t₂).get? k = (t₂.get? k).or (t₁.get? k) | null | true |
MulAction.stabilizerEquivStabilizer.eq_1 | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g : G} {a b : α} (hg : b = g • a),
MulAction.stabilizerEquivStabilizer hg =
(MulEquiv.subgroupMap (MulAut.conj g) (MulAction.stabilizer G a)).trans (MulEquiv.subgroupCongr ⋯) | null | true |
SkewPolynomial.support_neg | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Ring R] {p : SkewPolynomial R}, (-p).support = p.support | null | true |
CategoryTheory.Limits.Fork.op_unop_ι | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f g : X ⟶ Y}
(c : CategoryTheory.Limits.Fork f g), c.op.unop.ι = c.ι | null | true |
Lean.MessageData.Exprs.casesOn | Mathlib.Lean.MessageData.ForExprs | {motive : Lean.MessageData.Exprs → Sort u} →
(t : Lean.MessageData.Exprs) → ((msg : Lean.MessageData) → motive { msg := msg }) → motive t | null | false |
CategoryTheory.Bicategory.leftZigzagIso | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{g : b ⟶ a} →
(CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp f g) →
(CategoryTheory.CategoryStruct.comp g f ≅ CategoryTheory.CategoryStruct.id b) →
(Category... | The isomorphism version of `leftZigzag`. | true |
_private.Mathlib.Order.Filter.Ultrafilter.Cardinality.0.interPairsFilter_neBot._simp_14 | Mathlib.Order.Filter.Ultrafilter.Cardinality | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
LinearIsometry.submoduleMap._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} [inst : Ring R], RingHomSurjective (RingHom.id R) | null | false |
Lean.Linter.MissingDocs.lintField | Lean.Linter.MissingDocs | Lean.Syntax → Lean.Syntax → String → Lean.Elab.Command.CommandElabM Unit | null | true |
ZNum.zneg_pos | Mathlib.Data.Num.ZNum | ∀ (n : PosNum), -ZNum.pos n = ZNum.neg n | null | true |
List.foldlM_filterMap | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : α → Option β} {g : γ → β → m γ} {l : List α} {init : γ},
List.foldlM g init (List.filterMap f l) =
List.foldlM
(fun x y =>
match f y with
| some b => g x b
| none => pure ... | null | true |
Std.ExtTreeMap.getElem?_eq_some_getD | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α}
{fallback : β}, a ∈ t → t[a]? = some (t.getD a fallback) | null | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.norm_jacobiTheta₂_term_fderiv_ge._simp_1_1 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
RBTree.RBNode.all₂ | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → RBTree.RBNode α → RBTree.RBNode β → Bool | Asserts that `t₁` and `t₂` have the same number of elements in the same order,
and `R` holds pairwise between them. The tree structure is ignored.
| true |
Std.Iterators.HetT.prun | Std.Data.Iterators.Lemmas.Equivalence.HetT | {m : Type u_1 → Type u_2} →
{α : Type u_3} → {β : Type u_1} → [Monad m] → (x : Std.Iterators.HetT m α) → ((a : α) → x.Property a → m β) → m β | Applies the given function to the result of the contained `m`-monadic operation with a
proof that the postcondition property holds, returning another operation in `m`.
| true |
RCLike.copy_of_normedField._proof_14 | Mathlib.Analysis.RCLike.Basic | ∀ {𝕜 : Type u_1} (h : RCLike 𝕜) (hk : NormedField 𝕜), hk = h.toNormedField → RCLike.I = 0 ∨ RCLike.I * RCLike.I = -1 | null | false |
_private.Mathlib.Data.Rat.Cast.Lemmas.0.Rat.cast_nnratCast._simp_1_1 | Mathlib.Data.Rat.Cast.Lemmas | ∀ {n : ℕ}, (0 < ↑n) = (0 < n) | null | false |
_private.Mathlib.RingTheory.UniqueFactorizationDomain.Ideal.0.Ideal.setOfPred_isPrincipal_wellFoundedOn_gt._simp_1_2 | Mathlib.RingTheory.UniqueFactorizationDomain.Ideal | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Polynomial.exists_multiset_roots | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] [inst_2 : DecidableEq R] {p : Polynomial R},
p ≠ 0 → ∃ s, ↑s.card ≤ p.degree ∧ ∀ (a : R), Multiset.count a s = Polynomial.rootMultiplicity a p | null | true |
SubMulAction.closure_le | Mathlib.GroupTheory.GroupAction.SubMulAction.Closure | ∀ {R : Type u_1} {M : Type u_2} [inst : SMul R M] {s : Set M} {p : SubMulAction R M},
SubMulAction.closure R s ≤ p ↔ s ⊆ ↑p | null | true |
Set.prod_range_univ_eq | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m₁ : α → γ}, Set.range m₁ ×ˢ Set.univ = Set.range fun p => (m₁ p.1, p.2) | null | true |
smul_le_smul_of_nonneg_right | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : Zero β] [SMulPosMono α β], a₁ ≤ a₂ → 0 ≤ b → a₁ • b ≤ a₂ • b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.