name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.Widget.StringDiagram.Kind.monoidal.sizeOf_spec | Mathlib.Tactic.Widget.StringDiagram | sizeOf Mathlib.Tactic.Widget.StringDiagram.Kind.monoidal = 1 | null | true |
Matrix.PosDef.fromBlocks₂₂ | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {m : Type u_1} {n : Type u_2} {R' : Type u_4} [inst : CommRing R'] [inst_1 : PartialOrder R'] [inst_2 : StarRing R']
[inst_3 : Fintype n] [StarOrderedRing R'] [Finite m] [inst_6 : DecidableEq n] (A : Matrix m m R') (B : Matrix m n R')
{D : Matrix n n R'},
D.PosDef →
∀ [Invertible D], (Matrix.fromBlocks A B ... | null | true |
_private.Lean.Meta.Tactic.Contradiction.0.Lean.Meta.isGenDiseq | Lean.Meta.Tactic.Contradiction | Lean.Expr → Bool | See `Simp.isEqnThmHypothesis`
| true |
Real.arcosh_lt_arcosh | Mathlib.Analysis.SpecialFunctions.Arcosh | ∀ {x y : ℝ}, 0 < x → 0 < y → (Real.arcosh x < Real.arcosh y ↔ x < y) | This holds for `0 < x, y ≤ 1` due to junk values. | true |
DifferentiableOn.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {s : Set E},
DifferentiableOn ℝ f s → DifferentiableOn ℝ (fun x => Real.sinh (f x)) s | null | true |
Orientation.inner_smul_rotation_pi_div_two_smul_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x : V) (r₁ r₂ : ℝ), inner ℝ (r₂ • x) (r₁ • (o.rotation ↑(Real.pi / 2)) x) = 0 | The inner product between a multiple of a vector and a multiple of a `π / 2` rotation of
that vector is zero. | true |
TopCat.Sheaf.interUnionPullbackCone._proof_3 | Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections | ∀ {X : TopCat} (U V : TopologicalSpace.Opens ↑X), U ⊓ V ≤ V | null | false |
CategoryTheory.ComposableArrows.IsComplex.mk | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S : CategoryTheory.ComposableArrows C n},
(∀ (i : ℕ) (hi : autoParam (i + 2 ≤ n) CategoryTheory.ComposableArrows.IsComplex._auto_1),
CategoryTheory.CategoryStruct.comp (S.map' i (i + 1) ... | null | true |
Commute.zpow_right | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → ∀ (m : ℤ), Commute a (b ^ m) | null | true |
Filter.IsCobounded.mk | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {r : α → α → Prop} {f : Filter α} [IsTrans α r] (a : α),
(∀ s ∈ f, ∃ x ∈ s, r a x) → Filter.IsCobounded r f | To check that a filter is frequently bounded, it suffices to have a witness
which bounds `f` at some point for every admissible set.
This is only an implication, as the other direction is wrong for the trivial filter. | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Cases.0.Lean.Elab.Tactic.Do.ProofMode.mCasesExists.match_3 | Lean.Elab.Tactic.Do.ProofMode.Cases | (motive : Lean.Name × Lean.Syntax → Sort u_1) →
(x : Lean.Name × Lean.Syntax) → ((name : Lean.Name) → (ref : Lean.Syntax) → motive (name, ref)) → motive x | null | false |
SSet.stdSimplex.spineId | Mathlib.AlgebraicTopology.SimplicialSet.Path | (n : ℕ) → (SSet.stdSimplex.obj { len := n }).Path n | The spine of the unique non-degenerate `n`-simplex in `Δ[n]`. | true |
Polynomial.Nontrivial.of_polynomial_ne | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, p ≠ q → Nontrivial R | null | true |
Subfield.instIsScalarTowerSubtypeMem | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] {X : Type u_1} {Y : Type u_2} [inst_1 : SMul X Y] [inst_2 : SMul K X]
[inst_3 : SMul K Y] [IsScalarTower K X Y] (F : Subfield K), IsScalarTower (↥F) X Y | Note that this provides `IsScalarTower F K K` which is needed by `smul_mul_assoc`. | true |
ContDiffAt.csin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {n : WithTop ℕ∞},
ContDiffAt ℂ n f x → ContDiffAt ℂ n (fun x => Complex.sin (f x)) x | null | true |
Std.TreeMap.getElem?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
t[k]? = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ t.toList | null | true |
enorm_add_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] (a b : E), ‖a + b‖ₑ ≤ ‖a‖ₑ + ‖b‖ₑ | null | true |
CategoryTheory.Lax.LaxTrans.isoMk._proof_8 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a)
(naturality :
∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRi... | null | false |
AlgebraicGeometry.Scheme.Hom.mem_smoothLocus | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [inst : AlgebraicGeometry.LocallyOfFinitePresentation f] {x : ↥X},
x ∈ AlgebraicGeometry.Scheme.Hom.smoothLocus f ↔
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.stalkMap f x)).FormallySmooth | null | true |
Complex.arg_exp_mul_I | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (θ : ℝ), (Complex.exp (↑θ * Complex.I)).arg = toIocMod Real.two_pi_pos (-Real.pi) θ | null | true |
Array.isEmpty_toList | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.toList.isEmpty = xs.isEmpty | null | true |
Profinite.NobelingProof.spanCone_isLimit | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} →
{C : Set (I → Bool)} →
[inst : (s : Finset I) → (i : I) → Decidable (i ∈ s)] →
(hC : IsCompact C) → CategoryTheory.Limits.IsLimit (Profinite.NobelingProof.spanCone hC) | `spanCone` is a limit cone. | true |
ContinuousMultilinearMap.smulRight | Mathlib.Topology.Algebra.Module.Multilinear.Basic | {R : Type u} →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
... | Given a continuous `R`-multilinear map `f` taking values in `R`, `f.smulRight z` is the
continuous multilinear map sending `m` to `f m • z`. | true |
_private.Lean.Meta.DiscrTree.Basic.0.Lean.Meta.DiscrTree.keysAsPattern.mkApp | Lean.Meta.DiscrTree.Basic | Lean.MessageData → Array Lean.MessageData → Bool → Lean.CoreM Lean.MessageData | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanlMFast.loop._unary._proof_3 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (n_usize : USize),
n_usize.toNat = n → ∀ (i : USize), i.toNat < n → (i + 1).toNat = i.toNat + 1 → (i + 1).toNat ≤ n | null | false |
LieAlgebra.SemiDirectSum.smul_eq_mk | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_3}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ψ : L →ₗ⁅R⁆ LieDerivation R K K) (t : R) (x : K ⋊⁅ψ⁆ L),
t • x = { left := t • x.left, right := t • x.right } | null | true |
AddUnits.instCoeHead | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : AddMonoid α] → CoeHead (AddUnits α) α | An additive unit can be interpreted as a term in the base `AddMonoid`. | true |
_private.Mathlib.Data.EReal.Operations.0.EReal.add_ne_top_iff_ne_top₂._simp_1_2 | Mathlib.Data.EReal.Operations | ∀ (x : ℝ), (↑x = ⊤) = False | null | false |
List.prod_mul_prod_eq_prod_zipWith_mul_prod_drop | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : CommMonoid M] (l l' : List M),
l.prod * l'.prod =
(List.zipWith (fun x1 x2 => x1 * x2) l l').prod * (List.drop l'.length l).prod * (List.drop l.length l').prod | null | true |
SkewPolynomial.monomial_add_erase | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] (p : SkewPolynomial R) (n : ℕ),
(SkewPolynomial.monomial n) (p.coeff n) + SkewPolynomial.erase n p = p | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.mul_add_mod.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (x : ℕ), motive x.succ) → motive x | null | false |
CategoryTheory.Limits.ChosenPullback₃.p₁₂_p_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ X₃ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S} {f₃ : X₃ ⟶ S}
{h₁₂ : CategoryTheory.Limits.ChosenPullback f₁ f₂} {h₂₃ : CategoryTheory.Limits.ChosenPullback f₂ f₃}
{h₁₃ : CategoryTheory.Limits.ChosenPullback f₁ f₃} (h : CategoryTheory.Limits.ChosenPullback₃ h₁₂ ... | null | true |
Lean.ScopedEnvExtension.State.rec | Lean.ScopedEnvExtension | {σ : Type} →
{motive : Lean.ScopedEnvExtension.State σ → Sort u} →
((state : σ) →
(activeScopes : Lean.NameSet) →
(delimitsLocal : Bool) →
motive { state := state, activeScopes := activeScopes, delimitsLocal := delimitsLocal }) →
(t : Lean.ScopedEnvExtension.State σ) → motive t | null | false |
Std.LawfulOrderMin.mk | Init.Data.Order.Classes | ∀ {α : Type u} [inst : Min α] [inst_1 : LE α] [toMinEqOr : Std.MinEqOr α] [toLawfulOrderInf : Std.LawfulOrderInf α],
Std.LawfulOrderMin α | null | true |
ClassGroup.extendedHom_comp_apply | Mathlib.RingTheory.ClassGroup.ExtendedHom | ∀ (A : Type u_1) (B : Type u_2) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[inst_3 : Module.IsTorsionFree A B] [inst_4 : IsDedekindDomain A] (C : Type u_3) [inst_5 : CommRing C]
[inst_6 : Algebra B C] [inst_7 : Algebra A C] [IsScalarTower A B C] [inst_9 : Module.IsTorsionFree B C]
[inst_10 :... | null | true |
Array.Perm.pairwise | Init.Data.Array.Perm | ∀ {α : Type u_1} {R : α → α → Prop} {xs ys : Array α},
xs.Perm ys → List.Pairwise R xs.toList → (∀ {x y : α}, R x y → R y x) → List.Pairwise R ys.toList | null | true |
Algebra.tensorH1CotangentOfIsLocalization._proof_2 | Mathlib.RingTheory.Etale.Kaehler | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
MonoidHomClass ((Algebra.Generators.self R S).toExtension.Ring →+* S) (Algebra.Generators.self R S).toExtension.Ring S | null | false |
NumberField.Units.dirichletUnitTheorem.map_logEmbedding_sup_torsion | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (s : AddSubgroup (Additive (NumberField.RingOfIntegers K)ˣ)),
AddSubgroup.map (NumberField.Units.logEmbedding K) (s ⊔ Subgroup.toAddSubgroup (NumberField.Units.torsion K)) =
AddSubgroup.map (NumberField.Units.logEmbedding K) s | null | true |
TypeCat.Rel.ofPair | Mathlib.CategoryTheory.EquivalenceRelation | {X R : Type w} → (R ⟶ X) → (R ⟶ X) → X → X → Prop | The relation on a type `X` coming from a pair of maps `R ⟶ X`. | true |
Int.le_floor_add | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsOrderedRing R] (a b : R),
⌊a⌋ + ⌊b⌋ ≤ ⌊a + b⌋ | null | true |
Std.Internal.List.containsKey_maxKey? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {km : α}, Std.Internal.List.maxKey? l = some km → Std.Internal.List.containsKey km l = true | null | true |
Lean.Language.SnapshotBundle.mk | Lean.Language.Basic | {α : Type} →
Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask α)) → IO.Promise α → Lean.Language.SnapshotBundle α | null | true |
FintypeCat.homMk_eq_comp_iff | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y Z : FintypeCat} (f : X.obj → Y.obj) (g : Y.obj → Z.obj) (h : X.obj → Z.obj),
FintypeCat.homMk h = CategoryTheory.CategoryStruct.comp (FintypeCat.homMk f) (FintypeCat.homMk g) ↔ h = g ∘ f | null | true |
Std.IterM.TerminationMeasures.Productive.mk.injEq | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β] (it it_1 : Std.IterM m β),
({ it := it } = { it := it_1 }) = (it = it_1) | null | true |
_private.Mathlib.Order.WithBot.0.WithBot.ofDual_le_iff._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {a : αᵒᵈ} {b : α}, (OrderDual.toDual b ≤ a) = (OrderDual.ofDual a ≤ b) | null | false |
_private.Std.Sync.Semaphore.0.Std.Semaphore.mk.noConfusion | Std.Sync.Semaphore | {P : Sort u} →
{lock lock' : Std.Mutex Std.SemaphoreState✝} → { lock := lock } = { lock := lock' } → (lock = lock' → P) → P | null | false |
CategoryTheory.PreOneHypercover.cylinderX._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} (f g : E.Hom F) {i : E.I₀},
CategoryTheory.CategoryStruct.comp (f.h₀ i) (F.f (f.s₀ i)) =
CategoryTheory.CategoryStruct.comp (g.h₀ i) (F.f (g.s₀ i)) | null | false |
PFunctor.Approx.CofixA.recOn | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} →
{motive : (a : ℕ) → PFunctor.Approx.CofixA F a → Sort u} →
{a : ℕ} →
(t : PFunctor.Approx.CofixA F a) →
motive 0 PFunctor.Approx.CofixA.continue →
({n : ℕ} →
(a : F.A) →
(a_1 : F.B a → PFunctor.Approx.CofixA F n) →
(... | null | false |
ContinuousMultilinearMap.compContinuousLinearMap._proof_1 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_5} {ι : Type u_1} {M₁ : ι → Type u_2} {M₁' : ι → Type u_4} {M₄ : Type u_3} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → AddCommMonoid (M₁' i)] [inst_3 : AddCommMonoid M₄]
[inst_4 : (i : ι) → Module R (M₁ i)] [inst_5 : (i : ι) → Module R (M₁' i)] [inst_6 : Module R ... | null | false |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.toBalancedTree | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub → Std.DTreeMap.Internal.Impl.BalancedTree α β | Transforms an element of `SizedBalancedTree` into a `BalancedTree`. | true |
CategoryTheory.Bicategory.prod._proof_22 | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u_1) [inst : CategoryTheory.Bicategory B] (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
{a b c : B × C} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Bicategory.associator f.1 (CategoryTheory.CategoryStruct.id b).1 g.1).prod
(CategoryTheory.Bicatego... | null | false |
IntermediateField.sup_toSubalgebra_of_isAlgebraic_left | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(E1 E2 : IntermediateField K L) [Algebra.IsAlgebraic K ↥E1],
(E1 ⊔ E2).toSubalgebra = E1.toSubalgebra ⊔ E2.toSubalgebra | null | true |
AddCon.list_sum | Mathlib.GroupTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddZeroClass M] (c : AddCon M) {l : List ι} {f g : ι → M},
(∀ x ∈ l, c (f x) (g x)) → c (List.map f l).sum (List.map g l).sum | Additive congruence relations preserve sum indexed by a list. | true |
List.nil_eq_flatten_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} {L : List (List α)}, [] = L.flatten ↔ ∀ l ∈ L, l = [] | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData.rec | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.PendingSolverPropagationsData✝ → Sort u} →
motive Lean.Meta.Grind.PendingSolverPropagationsData.nil✝ →
((solverId : ℕ) →
(lhs rhs : Lean.Expr) →
(rest : Lean.Meta.Grind.PendingSolverPropagationsData✝) →
motive rest → motive (Lean.Meta.Grind.PendingSolverProp... | null | false |
Rat.commRing._proof_4 | Mathlib.Algebra.Ring.Rat | ∀ (n : ℕ), ↑(Int.negSucc n) = -↑(n + 1) | null | false |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.reduceUntilBadKey.step._unsafe_rec | Lean.Meta.DiscrTree.Main | Lean.Expr → Lean.MetaM Lean.Expr | null | false |
derivWithin_pow | Mathlib.Analysis.Calculus.Deriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedCommRing 𝔸]
[inst_2 : NormedAlgebra 𝕜 𝔸] {f : 𝕜 → 𝔸} {x : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 f s x → ∀ (n : ℕ), derivWithin (f ^ n) s x = ↑n * f x ^ (n - 1) * derivWithin f s x | null | true |
Cardinal.mk_set_nat | Mathlib.SetTheory.Cardinal.Continuum | Cardinal.mk (Set ℕ) = Cardinal.continuum | null | true |
_private.Std.Data.String.ToNat.0.noRepetition_cons_append_append_iff.match_1_10 | Std.Data.String.ToNat | ∀ {α : Type u_1} {a : α} {l : List α} (motive : ¬l = [] ∧ ¬[a, a] <:+: l ∧ ¬[a] <+: l ∧ ¬[a] <:+ l → Prop)
(x : ¬l = [] ∧ ¬[a, a] <:+: l ∧ ¬[a] <+: l ∧ ¬[a] <:+ l),
(∀ (h₁ : ¬l = []) (h₂ : ¬[a, a] <:+: l) (h₃ : ¬[a] <+: l) (h₄ : ¬[a] <:+ l), motive ⋯) → motive x | null | false |
MeasureTheory.Lp.coeFn_fun_finsetSum | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {ι : Type u_6} (s : Finset ι) (f : ι → ↥(MeasureTheory.Lp E p μ)),
↑↑(∑ i ∈ s, f i) =ᵐ[μ] fun x => ∑ i ∈ s, ↑↑(f i) x | null | true |
Submodule.comap_equiv_self_of_inj_of_le.match_1 | Mathlib.Algebra.Module.Submodule.Equiv | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {f : M →ₗ[R] N} {p : Submodule R N}
(motive : ↥(Submodule.comap f p) → Prop) (x : ↥(Submodule.comap f p)),
(∀ (val : M) (hx : val ∈ Submodule.comap f... | null | false |
ProofWidgets.mkRefreshComponent | ProofWidgets.Component.RefreshComponent | optParam ProofWidgets.Html (ProofWidgets.Html.text "") → BaseIO (ProofWidgets.Html × ProofWidgets.RefreshToken) | Create a `RefreshComponent` instance together with a token to manage it. | true |
Char.card_pow_card | Mathlib.NumberTheory.GaussSum | ∀ {F : Type u_1} [inst : Field F] [inst_1 : Fintype F] {F' : Type u_2} [inst_2 : Field F'] [inst_3 : Fintype F']
{χ : MulChar F F'},
χ ≠ 1 →
χ.IsQuadratic →
ringChar F' ≠ ringChar F →
ringChar F' ≠ 2 → (χ (-1) * ↑(Fintype.card F)) ^ (Fintype.card F' / 2) = χ ↑(Fintype.card F') | When `F` and `F'` are finite fields and `χ : F → F'` is a nontrivial quadratic character,
then `(χ(-1) * #F)^(#F'/2) = χ #F'`. | true |
TopRep.Hom.casesOn | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} →
{G : Type v} →
[inst : TopologicalSpace k] →
[inst_1 : Ring k] →
[inst_2 : IsTopologicalRing k] →
[inst_3 : Monoid G] →
{A : TopRep k G} →
{B : TopRep k G} →
{motive : A.Hom B → Sort u_3} →
(t : A.Hom B) → ((hom' : ... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.continuousOn_cfc_setProd_nhdsSet.match_1_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
{s : Set 𝕜}
(motive :
(x : UniformOnFun 𝕜 𝕜 {t | IsCompact t ∧ t ⊆ s} × A) →
x ∈
{f | ContinuousOn ((UniformOnFun.toFun {t | IsCompact t ∧ t ⊆ s}) f) s} ×ˢ
{a |... | null | false |
Std.DHashMap.Const.mem_ofList | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} [EquivBEq α] [LawfulHashable α] {l : List (α × β)} {k : α},
k ∈ Std.DHashMap.Const.ofList l ↔ (List.map Prod.fst l).contains k = true | null | true |
CategoryTheory.Localization.Preadditive.add.congr_simp | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
{L : CategoryTheory.Functor C D} (W W_1 : CategoryTheory.MorphismProperty C) (e_W : W = W_1)
[inst_3 : L.IsLocalization W] [inst_4 : W.HasLeftCalcul... | null | true |
BitVec.getElem_neg | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ} {x : BitVec w} (h : i < w), (-x)[i] = (x[i] ^^ decide (∃ j < i, x.getLsbD j = true)) | null | true |
_private.Mathlib.Order.SupIndep.0.iSupIndep.of_coe_Iic_comp._simp_1_1 | Mathlib.Order.SupIndep | ∀ {ι : Sort u_1} {α : Type u_2} [inst : CompleteLattice α] {a : α} (f : ι → ↑(Set.Iic a)), ⨆ i, ↑(f i) = ↑(⨆ i, f i) | null | false |
LinearIndepOn.image_of_comp | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {ι : Type u'} {ι' : Type u_1} {R : Type u_2} {s : Set ι} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] (f : ι → ι') (g : ι' → M), LinearIndepOn R (g ∘ f) s → LinearIndepOn R g (f '' s) | null | true |
Lean.Elab.addPreDefInfo | Lean.Elab.PreDefinition.Basic | Lean.Elab.PreDefinition → Lean.Elab.TermElabM Unit | Adds constant info to the definition name. This should occur after executing post-compilation
attributes, in case they have an effect on hovers.
| true |
CategoryTheory.Presieve.IsSheafFor.functorInclusion_comp_extend | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Sieve X}
{P : CategoryTheory.Functor Cᵒᵖ (Type v₁)} (h : CategoryTheory.Presieve.IsSheafFor P S.arrows) (f : S.functor ⟶ P),
CategoryTheory.CategoryStruct.comp S.functorInclusion (h.extend f) = f | Show that the extension of `f : S.functor ⟶ P` to all of `yoneda.obj X` is in fact an extension,
i.e. that the triangle below commutes, provided `P` is a sheaf for `S`
```
f
S → P
↓ ↗
yX
```
| true |
HahnSeries.map.congr_simp | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero S]
(x x_1 : HahnSeries Γ R),
x = x_1 →
∀ {F : Type u_5} [inst_3 : FunLike F R S] [inst_4 : ZeroHomClass F R S] (f f_1 : F), f = f_1 → x.map f = x_1.map f_1 | null | true |
CategoryTheory.MorphismProperty.IsStableUnderCobaseChange.hasOfPrecompProperty_epimorphisms | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderCobaseChange], P.HasOfPrecompProperty (CategoryTheory.MorphismProperty.epimorphisms C) | null | true |
LeanSearchClient.SearchResult.mk.noConfusion | LeanSearchClient.Syntax | {P : Sort u} →
{name : String} →
{type? docString? doc_url? kind? : Option String} →
{name' : String} →
{type?' docString?' doc_url?' kind?' : Option String} →
{ name := name, type? := type?, docString? := docString?, doc_url? := doc_url?, kind? := kind? } =
{ name := name', ... | null | false |
GaloisCoinsertion.monotoneIntro._proof_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {u : α → β} {l : β → α},
Monotone l → Monotone u → (∀ (a : α), l (u a) ≤ a) → (∀ (b : β), u (l b) = b) → GaloisConnection l u | null | false |
_private.Mathlib.Probability.Independence.Integration.0.ProbabilityTheory.lintegral_mul_indicator_eq_lintegral_mul_lintegral_indicator._simp_1_2 | Mathlib.Probability.Independence.Integration | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
List.allM._f | Init.Data.List.Control | {m : Type → Type u} → [Monad m] → {α : Type v} → (α → m Bool) → (x : List α) → List.below x → m Bool | null | false |
ContinuousMap.HomotopyRel.symm_bijective | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)} {S : Set X},
Function.Bijective ContinuousMap.HomotopyRel.symm | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.Basic.0.CategoryTheory.CartesianMonoidalCategory.associator_hom_snd_fst._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct... | null | false |
Int32.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int32.ofNat (a + b) = Int32.ofNat a + Int32.ofNat b | null | true |
isDedekindRing_iff | Mathlib.RingTheory.DedekindDomain.Basic | ∀ (A : Type u_2) [inst : CommRing A] (K : Type u_4) [inst_1 : CommRing K] [inst_2 : Algebra A K] [IsFractionRing A K],
IsDedekindRing A ↔
IsNoetherianRing A ∧ Ring.DimensionLEOne A ∧ ∀ {x : K}, IsIntegral A x → ∃ y, (algebraMap A K) y = x | An integral domain is a Dedekind domain if and only if it is
Noetherian, has dimension ≤ 1, and is integrally closed in a given fraction field.
In particular, this definition does not depend on the choice of this fraction field. | true |
Sat.Literal.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} → {t t' : Sat.Literal} → t = t' → Sat.Literal.noConfusionType P t t' | null | false |
MonoidWithZeroHom.instGroupWithZeroSubtypeMemSubmonoidMrange | Mathlib.Algebra.GroupWithZero.Submonoid.Instances | {G : Type u_1} →
{H : Type u_2} →
[inst : GroupWithZero G] → [inst_1 : GroupWithZero H] → (f : G →*₀ H) → GroupWithZero ↥(MonoidHom.mrange f) | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.some_getEntryLE_eq_getEntryLE?._simp_1_9 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {a : α} {o : Option α}, some (o.getD a) = o.or (some a) | null | false |
AddEquiv.withTopCongr._proof_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Add β] (e : α ≃+ β) (x y : WithTop α),
e.toAddHom.withBotMap.toFun (x + y) = e.toAddHom.withBotMap.toFun x + e.toAddHom.withBotMap.toFun y | null | false |
Complex.equivRealProd | Mathlib.Data.Complex.Basic | ℂ ≃ ℝ × ℝ | The equivalence between the complex numbers and `ℝ × ℝ`. | true |
Lean.Elab.Tactic.evalExposeNames | Lean.Elab.Tactic.ExposeNames | Lean.Elab.Tactic.Tactic | null | true |
Lean.TagDeclarationExtension | Lean.EnvExtension | Type | Environment extension for tagging declarations.
Declarations must only be tagged in the module where they were declared. | true |
IsLocalization.AtPrime.mk'_mem_maximal_iff | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (I : Ideal R)
[hI : I.IsPrime] [inst_3 : IsLocalization.AtPrime S I] (x : R) (y : ↥I.primeCompl) (h : optParam (IsLocalRing S) ⋯),
IsLocalization.mk' S x y ∈ IsLocalRing.maximalIdeal S ↔ x ∈ I | null | true |
openSegment_subset_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), openSegment 𝕜 x y ⊆ segment 𝕜 x y | null | true |
CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct.recOn | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{D : Type u₃} →
[inst_4 : CategoryTheory.Cat... | null | false |
Units.isOpenEmbedding_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], Topology.IsOpenEmbedding Units.val | In a normed ring with summable geometric series, the coercion from `Rˣ` (equipped with the
induced topology from the embedding in `R × R`) to `R` is an open embedding. | true |
Equiv.starRing | Mathlib.Algebra.Star.TransferInstance | {R : Type u_1} → {S : Type u_2} → (e : R ≃ S) → [inst : NonUnitalNonAssocSemiring S] → [StarRing S] → StarRing R | Transfer `StarRing` across an `Equiv`. See note [reducible non-instances]. | true |
AlgebraicGeometry.Scheme.instIsOverMapStalkSpecializesCommRingCatPresheaf | Mathlib.AlgebraicGeometry.Stalk | ∀ {X : AlgebraicGeometry.Scheme} {x y : ↥X} (h : x ⤳ y),
AlgebraicGeometry.Scheme.Hom.IsOver (AlgebraicGeometry.Spec.map (X.presheaf.stalkSpecializes h)) X | null | true |
Algebra.Extension.infinitesimal.eq_1 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Extension R S),
P.infinitesimal =
{ Ring := P.Ring ⧸ P.ker ^ 2, commRing := Ideal.Quotient.commRing (P.ker ^ 2),
algebra₁ := Ideal.instAlgebraQuotient R (P.ker ^ 2), algebra₂ := Ideal.Algebra.kerSquar... | null | true |
HSpaces._aux_Mathlib_Topology_Homotopy_HSpaces___unexpand_HSpace_hmul_1 | Mathlib.Topology.Homotopy.HSpaces | Lean.PrettyPrinter.Unexpander | null | false |
Lean.PrettyPrinter.parenthesizeTerm | Lean.PrettyPrinter.Parenthesizer | Lean.Syntax → Lean.CoreM Lean.Syntax | null | true |
List.getRest._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → [DecidableEq α] → List α → List α → Option (List α) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.