name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AffineEquiv.constVAdd_apply | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ (k : Type u_1) (P₁ : Type u_2) {V₁ : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁]
[inst_3 : AddTorsor V₁ P₁] (v : V₁) (x : P₁), (AffineEquiv.constVAdd k P₁ v) x = v +ᵥ x | null | true |
ContinuousAlgHom.coe_comp'._simp_1 | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
{C : Type u_4} [inst_7 : Semiring C] [inst_8 : Algebra R C] [inst_9 : TopologicalSpace C] (h : ... | null | false |
Besicovitch.TauPackage.color_lt | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
{i : Ordinal.{u}}, i < p.lastStep → ∀ {N : ℕ}, IsEmpty (Besicovitch.SatelliteConfig α N p.τ) → p.color i < N | If there are no configurations of satellites with `N+1` points, one never uses more than `N`
distinct families in the Besicovitch inductive construction. | true |
Batteries.CodeAction.TacticCodeActionEntry._sizeOf_inst | Batteries.CodeAction.Attr | SizeOf Batteries.CodeAction.TacticCodeActionEntry | null | false |
Monoid.PushoutI.NormalWord.Transversal.noConfusionType | Mathlib.GroupTheory.PushoutI | Sort u →
{ι : Type u_1} →
{G : ι → Type u_2} →
{H : Type u_3} →
[inst : (i : ι) → Group (G i)] →
[inst_1 : Group H] →
{φ : (i : ι) → H →* G i} →
Monoid.PushoutI.NormalWord.Transversal φ →
{ι' : Type u_1} →
{G' : ι' → Type u_2} →
... | null | false |
instRingFreeRing._proof_6 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a : FreeRing α), 0 + a = a | null | false |
Lean.Grind.Order.le_eq_false_k | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [inst_3 : Std.IsPreorder α]
[inst_4 : Lean.Grind.Ring α] [Lean.Grind.OrderedRing α] {a : α} {k : ℤ}, k.blt' 0 = true → (a ≤ a + ↑k) = False | null | true |
Int64.instLawfulEqOrd | Init.Data.Ord.SInt | Std.LawfulEqOrd Int64 | null | true |
Nat.stirlingFirst_succ_self_left | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n : ℕ), (n + 1).stirlingFirst n = (n + 1).choose 2 | null | true |
Submodule.codisjoint_span_image_of_codisjoint | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M],
Submodule.span R (Set.range v) = ⊤ →
∀ {s t : Set ι}, Codisjoint s t → Codisjoint (Submodule.span R (v '' s)) (Submodule.span R (v '' t)) | null | true |
PartOrd.instConcreteCategoryOrderHomCarrier._proof_3 | Mathlib.Order.Category.PartOrd | ∀ {X : PartOrd} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
Lean.Meta.InjectionsResult.ctorIdx | Lean.Meta.Tactic.Injection | Lean.Meta.InjectionsResult → ℕ | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_toInt_add_one_sub_toInt._proof_1_6 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (lo hi : BitVec (n + 1)),
¬(↑(hi.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % ↑(2 ^ (n + 1)) + 1 -
↑(lo.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % ↑(2 ^ (n + 1))).toNat =
(hi.toNat + (BitVec.Signed.intMinSealed✝ (n + 1)).toNat) % 2 ^ (n + 1) + 1 -
(lo.toNa... | null | false |
DoResultPRBC.return.elim | Init.Core | {α β σ : Type u} →
{motive : DoResultPRBC α β σ → Sort u_1} →
(t : DoResultPRBC α β σ) → t.ctorIdx = 1 → ((a : β) → (a_1 : σ) → motive (DoResultPRBC.return a a_1)) → motive t | null | false |
SSet.Subcomplex.mem_ofSimplex_obj_iff | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X : SSet} {n : ℕ} (x : X.obj (Opposite.op { len := n })) {m : SimplexCategoryᵒᵖ} (y : X.obj m),
y ∈ (SSet.Subcomplex.ofSimplex x).obj m ↔ ∃ f, (CategoryTheory.ConcreteCategory.hom (X.map f.op)) x = y | null | true |
CategoryTheory.Comonad.Coalgebra.counit._autoParam | Mathlib.CategoryTheory.Monad.Algebra | Lean.Syntax | null | false |
Set.Ioo_union_right | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b < a → Set.Ioo b a ∪ {a} = Set.Ioc b a | null | true |
CategoryTheory.Functor.mapTriangle._proof_2 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
{X Y : CategoryTheory.Pretriangulated.Triangle C} (f... | null | false |
Batteries.Random.MersenneTwister.State._sizeOf_inst | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) → SizeOf (Batteries.Random.MersenneTwister.State cfg) | null | false |
Quandle | Mathlib.Algebra.Quandle | Type u_1 → Type u_1 | A quandle is a rack such that each automorphism fixes its corresponding element.
| true |
PowerSeries.aeval | Mathlib.RingTheory.PowerSeries.Evaluation | {R : Type u_1} →
[inst : CommRing R] →
{S : Type u_2} →
[inst_1 : CommRing S] →
{a : S} →
[inst_2 : UniformSpace R] →
[inst_3 : UniformSpace S] →
[IsUniformAddGroup R] →
[IsTopologicalSemiring R] →
[IsUniformAddGroup S] →
... | For `HasEval a`,
the evaluation homomorphism at `a` on `PowerSeries`, as an `AlgHom`. | true |
Std.DTreeMap.Internal.Impl.minKey?_le_minKey?_erase! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k km kme : α} (hkme : (Std.DTreeMap.Internal.Impl.erase! k t).minKey? = some kme),
t.minKey?.get ⋯ = km → (compare km kme).isLE = true | null | true |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.isPropFormerTypeQuick._sparseCasesOn_2 | Lean.Compiler.LCNF.Types | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
SelectInsertParams.mk.noConfusion | Mathlib.Tactic.Widget.SelectPanelUtils | {P : Sort u} →
{pos : Lean.Lsp.Position} →
{goals : Array Lean.Widget.InteractiveGoal} →
{selectedLocations : Array Lean.SubExpr.GoalsLocation} →
{replaceRange : Lean.Lsp.Range} →
{pos' : Lean.Lsp.Position} →
{goals' : Array Lean.Widget.InteractiveGoal} →
{selecte... | null | false |
Lean.Meta.Simp.NormCastConfig.zetaDelta._inherited_default | Init.MetaTypes | Bool | null | false |
CategoryTheory.instPreadditiveOppositeShift._proof_4 | Mathlib.CategoryTheory.Shift.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (A : Type u_3) [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] [inst_3 : CategoryTheory.Preadditive C],
autoParam
(∀ (P Q R : CategoryTheory.OppositeShift C A) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g +... | null | false |
Function.Injective.addGroupWithOne._proof_1 | Mathlib.Algebra.Ring.InjSurj | ∀ {R : Type u_1} {S : Type u_2} [inst : Zero S] [inst_1 : One S] [inst_2 : Add S] [inst_3 : SMul ℕ S]
[inst_4 : NatCast S] [inst_5 : IntCast S] [inst_6 : AddGroupWithOne R] (f : S → R) (hf : Function.Injective f)
(zero : f 0 = 0) (one : f 1 = 1) (add : ∀ (x y : S), f (x + y) = f x + f y)
(nsmul : ∀ (n : ℕ) (x : S... | null | false |
ProbabilityTheory.Kernel.compProd_eq_iff | Mathlib.Probability.Kernel.CompProdEqIff | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μ : MeasureTheory.Measure α}
{κ η : ProbabilityTheory.Kernel α β} [MeasurableSpace.CountableOrCountablyGenerated α β]
[MeasureTheory.IsFiniteMeasure μ] [ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel η],
μ.co... | Two finite kernels `κ` and `η` are `μ`-a.e. equal iff the composition-products `μ ⊗ₘ κ`
and `μ ⊗ₘ η` are equal. | true |
Polynomial.newtonMap_apply_of_not_isUnit | Mathlib.Dynamics.Newton | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Polynomial R}
{x : S}, ¬IsUnit ((Polynomial.aeval x) (Polynomial.derivative P)) → P.newtonMap x = x | null | true |
_private.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.replaceRecApps.loop.match_12 | Lean.Elab.PreDefinition.Structural.BRecOn | (motive : Option Lean.Meta.MatcherApp → Sort u_1) →
(__do_lift : Option Lean.Meta.MatcherApp) →
((matcherApp : Lean.Meta.MatcherApp) → motive (some matcherApp)) → (Unit → motive none) → motive __do_lift | null | false |
LightCondensed.discrete._proof_1 | Mathlib.Condensed.Discrete.Basic | CategoryTheory.Precoherent LightProfinite | null | false |
Nat.le_or_le_of_add_eq_add_pred | Init.Data.Nat.Lemmas | ∀ {a c b d : ℕ}, a + c = b + d - 1 → b ≤ a ∨ d ≤ c | null | true |
PseudoMetric.noConfusion | Mathlib.Topology.MetricSpace.BundledFun | {P : Sort u} →
{X : Type u_1} →
{R : Type u_2} →
{inst : Zero R} →
{inst_1 : Add R} →
{inst_2 : LE R} →
{t : PseudoMetric X R} →
{X' : Type u_1} →
{R' : Type u_2} →
{inst' : Zero R'} →
{inst'_1 : Add R'} →
... | null | false |
_private.Mathlib.MeasureTheory.Function.UnifTight.0.MeasureTheory.UnifTight.aeeq._simp_1_1 | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary._proof_2 | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (a₁ : ℤ) (x₁ : Q(«$M»)) (k₁ : ℕ) (t₁ : List ((ℤ × Q(«$M»)) × ℕ)) (a₂ : ℤ)
(x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((ℤ × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun l₁ l₂ => (l₁, l₂)) Prod.instWellFoundedRelation).1 ⟨t₁, ((a₂, x₂), k₂) :: t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂... | null | false |
SzemerediRegularity.bound.eq_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ (ε : ℝ) (l : ℕ),
SzemerediRegularity.bound ε l =
SzemerediRegularity.stepBound^[⌊4 / ε ^ 5⌋₊] (SzemerediRegularity.initialBound ε l) *
16 ^ SzemerediRegularity.stepBound^[⌊4 / ε ^ 5⌋₊] (SzemerediRegularity.initialBound ε l) | null | true |
CategoryTheory.eq_of_comp_left_eq' | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y),
((fun {Z} h => CategoryTheory.CategoryStruct.comp f h) = fun {Z} h => CategoryTheory.CategoryStruct.comp g h) → f = g | null | true |
NormedSpace.expSeries_sum_eq | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_2} [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (x : 𝔸), (NormedSpace.expSeries 𝕂 𝔸).sum x = ∑' (n : ℕ), (↑n.factorial)⁻¹ • x ^ n | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.chevalley_mvPolynomial_mvPolynomial._simp_1_5 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CommRingCat.casesOn | Mathlib.Algebra.Category.Ring.Basic | {motive : CommRingCat → Sort u_1} →
(t : CommRingCat) → ((carrier : Type u) → [commRing : CommRing carrier] → motive (CommRingCat.of carrier)) → motive t | null | false |
CategoryTheory.GrothendieckTopology.MayerVietorisSquare.mk'._proof_2 | Mathlib.CategoryTheory.Sites.MayerVietorisSquare | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasWeakSheafify J (Type u_2)] (sq : CategoryTheory.Square C),
(∀ (F : CategoryTheory.Sheaf J (Type u_2)), (sq.op.map F.obj).IsPullback) →
(sq.map (CategoryTheory.yoneda.comp (Categ... | null | false |
_private.Mathlib.Analysis.LocallyConvex.WithSeminorms.0.WithSeminorms.isVonNBounded_iff_seminorm_bddAbove._simp_1_1 | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α}, BddAbove s = ∃ x, ∀ y ∈ s, y ≤ x | null | false |
AddEquiv.comp_right_injective | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (e : M ≃+ N), Function.Injective fun f => (↑e).comp f | null | true |
BitVec.ofNat_or | Init.Data.BitVec.Lemmas | ∀ {w x y : ℕ}, BitVec.ofNat w (x ||| y) = BitVec.ofNat w x ||| BitVec.ofNat w y | null | true |
LinearEquiv.prodProdProdComm | Mathlib.LinearAlgebra.Prod | (R : Type u) →
(M : Type v) →
(M₂ : Type w) →
(M₃ : Type y) →
(M₄ : Type z) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : AddCommMonoid M₄] →
... | Four-way commutativity of `prod`. The name matches `mul_mul_mul_comm`. | true |
Pi.uniformSpace_comap_restrict | Mathlib.Topology.UniformSpace.Pi | ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)] (S : Set ι),
UniformSpace.comap S.restrict (Pi.uniformSpace fun i => α ↑i) = ⨅ i ∈ S, UniformSpace.comap (Function.eval i) (U i) | null | true |
CategoryTheory.LocalizerMorphism.rec | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{motive : CategoryTheory.LocalizerMorphism W₁ W₂ → Sort u} →... | null | false |
_private.Mathlib.Algebra.CubicDiscriminant.0.Cubic.ext.match_1 | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} (motive : Cubic R → Prop) (h : Cubic R),
(∀ (a b c d : R), motive { a := a, b := b, c := c, d := d }) → motive h | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.withFreshNGen | Lean.Meta.Tactic.Grind.EMatch | {α : Type} → Lean.Meta.Grind.EMatch.M α → Lean.Meta.Grind.EMatch.M α | Use a fresh name generator for creating internal metavariables for theorem instantiation.
This is technique to ensure the metavariables ids do not depend on operations performed before invoking `grind`.
Without this trick, we experience counterintuitive behavior where small changes affect the metavariable ids, and
cons... | true |
Lean.Lsp.instToJsonInitializeResult.toJson | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializeResult → Lean.Json | null | true |
Polynomial.Bivariate.swap | Mathlib.Algebra.Polynomial.Bivariate | {R : Type u_1} → [inst : CommSemiring R] → Polynomial (Polynomial R) ≃ₐ[R] Polynomial (Polynomial R) | The R-algebra automorphism given by `X ↦ Y` and `Y ↦ X`. | true |
Std.HashMap.Raw.isEmpty_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [BEq α] [Hashable α] {c : ℕ}, (Std.HashMap.Raw.emptyWithCapacity c).isEmpty = true | null | true |
Filter.HasBasis.disjoint_iff | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
{s' : ι' → Set α},
l.HasBasis p s → l'.HasBasis p' s' → (Disjoint l l' ↔ ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')) | null | true |
Semiquot.get.congr_simp | Mathlib.Data.Semiquot | ∀ {α : Type u_1} (q q_1 : Semiquot α) (e_q : q = q_1) (h : q.IsPure), q.get h = q_1.get ⋯ | null | true |
Circle.instCommGroup._proof_21 | Mathlib.Analysis.Complex.Circle | autoParam
(∀ (n : ℕ) (a : Circle),
Circle.instCommGroup._aux_17 (Int.negSucc n) a = (Circle.instCommGroup._aux_17 (↑n.succ) a)⁻¹)
DivInvMonoid.zpow_neg'._autoParam | null | false |
CategoryTheory.Limits.IsColimit.nonempty_isColimit_iff_isIso_desc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {s t : CategoryTheory.Limits.Cocone F} (hs : CategoryTheory.Limits.IsColimit s),
Nonempty (CategoryTheory.Limits.IsColimit t) ↔ CategoryTheory.IsIso (hs.desc t) | null | true |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.MorphismProperty C → Prop | A multiplicative morphism property `W` has right calculus of fractions if
any left fraction can be turned into a right fraction and that two morphisms
that can be equalized by postcomposition with a morphism in `W` can also
be equalized by precomposition with a morphism in `W`. | true |
ENNReal.mul_eq_right | Mathlib.Data.ENNReal.Operations | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → (a * b = b ↔ a = 1) | null | true |
CategoryTheory.Mon.instHasZeroMorphisms | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] →
CategoryTheory.Limits.HasZeroMorphisms (CategoryTheory.Mon D) | null | true |
Array.pmap_attachWith | Init.Data.Array.Attach | ∀ {α : Type u_1} {q : α → Prop} {β : Type u_2} {xs : Array α} {p : { x // q x } → Prop}
{f : (a : { x // q x }) → p a → β} (H₁ : ∀ x ∈ xs, q x) (H₂ : ∀ a ∈ xs.attachWith q H₁, p a),
Array.pmap f (xs.attachWith q H₁) H₂ = Array.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) xs ⋯ | null | true |
IntermediateField.fixingSubgroupEquiv._proof_2 | 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),
Function.RightInverse (fun ϕ => ⟨AlgEquiv.restrictScalars F ϕ, ⋯⟩) fun ϕ =>
let __src := (↑ϕ).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ } | null | false |
Finset.Pi.cons_injective | Mathlib.Data.Finset.Pi | ∀ {α : Type u_1} {δ : α → Sort v} [inst : DecidableEq α] {a : α} {b : δ a} {s : Finset α},
a ∉ s → Function.Injective (Finset.Pi.cons s a b) | null | true |
isUpperSet_iff_Ioi_subset | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Set α}, IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Set.Ioi a ⊆ s | null | true |
ULift.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X] [IsIsometricSMul M X],
IsIsometricSMul (ULift.{u_2, u} M) X | null | true |
Composition.recOnSingleAppend | Mathlib.Combinatorics.Enumerative.Composition | {motive : (n : ℕ) → Composition n → Sort u_1} →
{n : ℕ} →
(c : Composition n) →
motive 0 (Composition.ones 0) →
((k n : ℕ) → (c : Composition n) → motive n c → motive (k + 1 + n) ((Composition.single (k + 1) ⋯).append c)) →
motive n c | Induction (recursion) principle on `c : Composition _`
that corresponds to the usual induction on the list of blocks of `c`. | true |
TopRep.toActionFromAction._proof_2 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_2} {G : Type u_3} [inst : TopologicalSpace k] [inst_1 : Ring k] [inst_2 : IsTopologicalRing k]
[inst_3 : Monoid G] (X : TopRep k G),
CategoryTheory.CategoryStruct.comp
(TopRep.ofHom { toContinuousLinearMap := ContinuousLinearMap.id k ↑X, isIntertwining' := ⋯ })
(TopRep.ofHom { toContinuous... | null | false |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.drop.match_1.splitter | Mathlib.Data.Seq.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | true |
_private.Mathlib.Data.Finset.Option.0.Option.mem_toFinset._simp_1_1 | Mathlib.Data.Finset.Option | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Init.Data.List.SplitOn.Basic.0.List.splitOnPTR.go._f | Init.Data.List.SplitOn.Basic | {α : Type u_1} →
(α → Bool) →
(a : List α) →
List.below (motive := fun a => Array α → Array (List α) → List (List α)) a →
Array α → Array (List α) → List (List α) | null | false |
ContinuousOn.continuous_of_mulTSupport_subset | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : One β] [inst_2 : TopologicalSpace β] {f : α → β}
{s : Set α}, ContinuousOn f s → IsOpen s → mulTSupport f ⊆ s → Continuous f | null | true |
Lean.Expr.getUsedConstantsAsSet | Lean.Util.FoldConsts | Lean.Expr → Lean.NameSet | Like `Expr.getUsedConstants`, but produce a `NameSet`. | true |
Aesop.Frontend.Feature.priority | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority → Aesop.Frontend.Feature | null | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Braided.0.CategoryTheory.Localization.Monoidal.instIsLocalizationLocalizedMonoidalToMonoidalCategory_1._proof_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} (ε : ... | null | false |
MulAction.isBlock_top | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {B : Set X},
MulAction.IsBlock (↥⊤) B ↔ MulAction.IsBlock G B | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.killCopies_eq_left._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_3} {p : Nonempty α → Prop}, (∀ (h : Nonempty α), p h) = ∀ (a : α), p ⋯ | null | false |
Function.Periodic.differentiable_qParam | Mathlib.Analysis.Complex.Periodic | ∀ {h : ℝ}, Differentiable ℂ (Function.Periodic.qParam h) | null | true |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.Style.setOption.isSetOption._sparseCasesOn_1 | Mathlib.Tactic.Linter.Style | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
SkewPolynomial.X_mul_monomial | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : MulSemiringAction (Multiplicative ℕ) R] (n : ℕ) (r : R),
SkewPolynomial.X * (SkewPolynomial.monomial n) r = (SkewPolynomial.monomial (n + 1)) (SkewPolynomial.φ r) | null | true |
Lean.Expr.NumApps.State.rec | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
(t : Lean.Expr.NumApps.State) → motive t | null | false |
Subgroup.range_zpowersHom | Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas | ∀ {G : Type u_1} [inst : Group G] (g : G), ((zpowersHom G) g).range = Subgroup.zpowers g | null | true |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.IsAffineOpen.iSup_of_disjoint_aux | Mathlib.AlgebraicGeometry.Limits | ∀ {ι : Type u} {X : AlgebraicGeometry.Scheme} [Finite ι] {U : ι → X.Opens},
(∀ (i : ι), AlgebraicGeometry.IsAffineOpen (U i)) →
Pairwise (Function.onFun Disjoint U) → AlgebraicGeometry.IsAffineOpen (iSup U) | A version with more restrictive universes. See `IsAffineOpen.iSup_of_disjoint`. | true |
Lean.Lsp.Ipc.writeRequest | Lean.Data.Lsp.Ipc | {α : Type u_1} → [Lean.ToJson α] → Lean.JsonRpc.Request α → Lean.Lsp.Ipc.IpcM Unit | null | true |
CategoryTheory.SimplicialObject.Splitting.nondegComplex | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject C} → X.Splitting → [inst_1 : CategoryTheory.Preadditive C] → ChainComplex C ℕ | If `s` is a splitting of a simplicial object `X` in a preadditive category,
`s.nondegComplex` is a chain complex which is given in degree `n` by
the nondegenerate `n`-simplices of `X`. This chain complex should be thought
as the normalized chain complex of `X` because of the isomorphism
`toKaroubiNondegComplexIsoN₁`. | true |
Lean.Elab.Tactic.Do.ProofMode.mCasesExists | Lean.Elab.Tactic.Do.ProofMode.Cases | {α : Type} →
Lean.Expr →
Lean.TSyntax `Lean.binderIdent →
(Lean.Expr → Lean.MetaM (α × Lean.Elab.Tactic.Do.ProofMode.MGoal × Lean.Expr)) →
Lean.MetaM (α × Lean.Elab.Tactic.Do.ProofMode.MGoal × Lean.Expr) | null | true |
Lean.Expr.forallInfo | Lean.Expr | (a : Lean.Expr) → a.isForall = true → Lean.BinderInfo | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex.0.SSet.Subcomplex.Pairing.RankFunction.range_homOfLE_app_union_range_b_app._simp_1_3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
_private.Mathlib.Data.List.Intervals.0.List.Ico.inter_consecutive._simp_1_2 | Mathlib.Data.List.Intervals | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
Ordinal.instOrderTopology | Mathlib.SetTheory.Ordinal.Topology | OrderTopology Ordinal.{u} | null | true |
Add.mk | Init.Prelude | {α : Type u} → (α → α → α) → Add α | null | true |
Lean.Elab.Term.withMacroExpansion | Lean.Elab.Term.TermElabM | {n : Type → Type u_1} →
{α : Type} → [Monad n] → [MonadControlT Lean.Elab.TermElabM n] → Lean.Syntax → Lean.Syntax → n α → n α | Elaborate `x` with `stx` on the macro stack and produce macro expansion info | true |
FractionalIdeal.extendedHom_eq_zero_iff | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ {A : Type u_1} {K : Type u_2} (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A]
[inst_2 : CommRing B] [inst_3 : IsDomain B] [inst_4 : Algebra A B] [inst_5 : Module.IsTorsionFree A B]
[inst_6 : Field K] [inst_7 : Field L] [inst_8 : Algebra A K] [inst_9 : Algebra B L] [inst_10 : IsFractionRing... | null | true |
Function.Embedding.sigmaSet._proof_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u_1} {ι : Type u_2} {s : ι → Set α},
Pairwise (Function.onFun Disjoint s) → Function.Injective fun x => ↑x.snd | null | false |
_private.Mathlib.LinearAlgebra.Reflection.0.Module.reflection_mul_reflection_pow_apply._proof_1_2 | Mathlib.LinearAlgebra.Reflection | ∀ (m : ℕ), ↑m % 2 = 0 ∨ ↑m % 2 = 1 | null | false |
SSet.quasicategory_of_hasLiftingProperty | Mathlib.AlgebraicTopology.Quasicategory.Basic | ∀ (S : SSet) {X : SSet} (t : CategoryTheory.Limits.IsTerminal X),
(∀ {n : ℕ} {i : Fin (n + 1)},
0 < i → i < Fin.last n → CategoryTheory.HasLiftingProperty (SSet.horn n i).ι (t.from S)) →
S.Quasicategory | null | true |
IsClub.casesOn | Mathlib.SetTheory.Cardinal.Cofinality.Club | {α : Type u_1} →
[inst : LinearOrder α] →
{s : Set α} →
{motive : IsClub s → Sort u} →
(t : IsClub s) → ((dirSupClosed : DirSupClosed s) → (isCofinal : IsCofinal s) → motive ⋯) → motive t | null | false |
Configuration.ProjectivePlane.lineCount_eq | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} (L : Type u_2) [inst : Membership P L] [inst_1 : Configuration.ProjectivePlane P L] [Finite P]
[Finite L] (p : P), Configuration.lineCount L p = Configuration.ProjectivePlane.order P L + 1 | null | true |
RootPairing.restrictScalars'._proof_13 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_5} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_2)
[inst_5 : Field K] [inst_6 : Module K M] (i : ι), P.root i ∈ ↑(Submodule.span K (Set.range ⇑P.root)) | null | false |
Equiv.Set.union._proof_2 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} {s t : Set α}, Disjoint s t → ∀ x ∈ t, x ∈ s → False | null | false |
InfHom.id | Mathlib.Order.Hom.Lattice | (α : Type u_2) → [inst : Min α] → InfHom α α | `id` as an `InfHom`. | true |
_private.Lean.Meta.ExprLens.0.Lean.Core.viewBindersCoord.match_1 | Lean.Meta.ExprLens | (motive : ℕ → Lean.Expr → Sort u_1) →
(x : ℕ) →
(x_1 : Lean.Expr) →
((n : Lean.Name) →
(y body : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive 1 (Lean.Expr.lam n y body binderInfo)) →
((n : Lean.Name) →
(y body : Lean.Expr) → (binderInfo : Lean.BinderInfo) → motive 1 (Le... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.