name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IntermediateField.isSeparable_of_mem_isSeparable | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : IntermediateField F E}
[Algebra.IsSeparable F ↥L] {x : E}, x ∈ L → IsSeparable F x | null | true |
RootPairing.nsmul_notMem_range_root | Mathlib.LinearAlgebra.RootSystem.Reduced | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [CharZero R]
[IsAddTorsionFree M] [P.IsReduced] {n : ℕ} [n.AtLeastTwo] {i : ι}, n • P.root i ∉ Set.range ⇑P.root | null | true |
Continuous.enorm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {X : Type u_8} [inst_2 : TopologicalSpace X]
{f : X → E}, Continuous f → Continuous fun x => ‖f x‖ₑ | null | true |
Aesop.GoalId.casesOn | Aesop.Tree.Data | {motive : Aesop.GoalId → Sort u} → (t : Aesop.GoalId) → ((toNat : ℕ) → motive { toNat := toNat }) → motive t | null | false |
CompleteLat.Iso.mk | Mathlib.Order.Category.CompleteLat | {α β : CompleteLat} → ↑α ≃o ↑β → (α ≅ β) | Constructs an isomorphism of complete lattices from an order isomorphism between them. | true |
CategoryTheory.EnrichedFunctor.comp_map | Mathlib.CategoryTheory.Enriched.Basic | ∀ (V : Type v) [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
{D : Type u₂} {E : Type u₃} [inst_2 : CategoryTheory.EnrichedCategory V C]
[inst_3 : CategoryTheory.EnrichedCategory V D] [inst_4 : CategoryTheory.EnrichedCategory V E]
(F : CategoryTheory.EnrichedF... | null | true |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.toOplax | Mathlib.CategoryTheory.Bicategory.Monad.Basic | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B →
CategoryTheory.OplaxFunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Discrete PUnit.{1})) B | The oplax functor from the trivial bicategory to `B` associated with the comonad. | true |
tendsto_atTop_iSup | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {ι : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α] [inst_2 : CompleteLattice α]
[SupConvergenceClass α] {f : ι → α}, Monotone f → Filter.Tendsto f Filter.atTop (nhds (⨆ i, f i)) | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.isCongruent.goEq | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.ENodeMap → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Bool | null | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_sq_not_dvd_a_add_eta_sq_mul_b._simp_1_3 | Mathlib.NumberTheory.FLT.Three | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
Nucleus.coe_toInfHom | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : SemilatticeInf X] (n : Nucleus X), ⇑n.toInfHom = ⇑n | null | true |
_private.Lean.Data.Lsp.Internal.0.Lean.Lsp.instBEqRefIdent.beq.match_1 | Lean.Data.Lsp.Internal | (motive : Lean.Lsp.RefIdent → Lean.Lsp.RefIdent → Sort u_1) →
(x x_1 : Lean.Lsp.RefIdent) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.const a a_1) (Lean.Lsp.RefIdent.const b b_1)) →
((a a_1 b b_1 : String) → motive (Lean.Lsp.RefIdent.fvar a a_1) (Lean.Lsp.RefIdent.fvar b b_1)) →
((x x_2 : ... | null | false |
Unitization.inrNonUnitalAlgHom._proof_1 | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (r : R)
(m : A), ↑(r • m) = r • ↑m | null | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_13 | Lean.Meta.LitValues | (motive : Option UInt16 → Sort u_1) →
(__do_lift : Option UInt16) → ((n : UInt16) → motive (some n)) → ((x : Option UInt16) → motive x) → motive __do_lift | null | false |
ImplicitFunctionData.hasStrictFDerivAt | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | null | true |
SchwartzMap.toLp.eq_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_5} {F : Type u_6} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] [inst_4 : MeasurableSpace E] [inst_5 : OpensMeasurableSpace E]
[inst_6 : SecondCountableTopologyEither E F] (f : SchwartzMap E F) (p : ENNReal) (μ : MeasureTheory.Measu... | null | true |
_private.Init.Data.Int.Order.0.Int.toNat_sub''.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a b : ℤ) → (∃ n, a = ↑n) → (∃ n, b = ↑n) → 0 ≤ a → 0 ≤ b → Prop) (a b : ℤ) (x : ∃ n, a = ↑n)
(x_1 : ∃ n, b = ↑n) (ha : 0 ≤ a) (hb : 0 ≤ b),
(∀ (w w_1 : ℕ) (ha : 0 ≤ ↑w) (hb : 0 ≤ ↑w_1), motive ↑w ↑w_1 ⋯ ⋯ ha hb) → motive a b x x_1 ha hb | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.PSigma.casesOn._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
List.IsChain.induction | Mathlib.Data.List.Chain | ∀ {α : Type u} {r : α → α → Prop} (p : α → Prop) (l : List α),
List.IsChain r l → (∀ ⦃x y : α⦄, r x y → p x → p y) → (∀ (lne : l ≠ []), p (l.head lne)) → ∀ i ∈ l, p i | Given a chain `l`, such that a predicate `p` holds for its head if it is nonempty,
and if `r x y → p x → p y`, then the predicate is true everywhere in the chain.
That is, we can propagate the predicate down the chain.
| true |
_private.Lean.Elab.Tactic.Grind.Sym.0.Lean.Elab.Tactic.Grind.trivialDSimproc | Lean.Elab.Tactic.Grind.Sym | Lean.Meta.Sym.DSimp.DSimproc | null | true |
_private.Mathlib.RingTheory.Flat.Basic.0.Module.Flat.directSum_iff._simp_1_3 | Mathlib.RingTheory.Flat.Basic | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_9} {M₂ : Type u_10} {M₃ : Type u_11} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ ... | null | false |
PresentedAddMonoid.instAddMonoid._proof_11 | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_1} {rels : FreeAddMonoid α → FreeAddMonoid α → Prop},
autoParam
(∀ (n : ℕ) (x : PresentedAddMonoid rels),
PresentedAddMonoid.instAddMonoid._aux_8 (n + 1) x = PresentedAddMonoid.instAddMonoid._aux_8 n x + x)
AddMonoid.nsmul_succ._autoParam | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_85 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (tail : List α) {n : ℕ},
n - 1 + 1 ≤ (List.findIdxs (fun x_1 => x_1 == x) tail 1).length →
n - 1 < (List.findIdxs (fun x_1 => x_1 == x) tail 1).length | null | false |
CategoryTheory.Over.left | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} T] → {X : T} → CategoryTheory.Over X → T | The underlying object of an object in `Over X`. | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.toList_zip_of_finite_right._simp_1_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α : Type u_1} {a : α} {p : Prop} {x : Decidable p} {b : Option α},
((if p then b else none) = some a) = (p ∧ b = some a) | null | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._proof_1_6 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ (a b : ℕ), a + 1 ≤ b → a ≤ b + 1 | null | false |
SchwartzMap.instAddCommGroup._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (a : SchwartzMap E F), a + 0 = a | null | false |
Std.DHashMap.Internal.Raw₀.Const.insertMany_nil | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β),
↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m []) = m | null | true |
CategoryTheory.Functor.relativelyRepresentable.symmetryIso_inv | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {Y : D} {b : C} {f' : F.obj b ⟶ Y} (hf' : F.relativelyRepresentable f') {a : C}
{g : F.obj a ⟶ Y} (hg : F.relativelyRepresentable g) [inst_2 : F.Full] [inst_3 : F.... | null | true |
AddGroupExtension._sizeOf_inst | Mathlib.GroupTheory.GroupExtension.Defs | (N : Type u_1) →
(E : Type u_2) →
(G : Type u_3) →
{inst : AddGroup N} →
{inst_1 : AddGroup E} →
{inst_2 : AddGroup G} → [SizeOf N] → [SizeOf E] → [SizeOf G] → SizeOf (AddGroupExtension N E G) | null | false |
List.dropLast_append_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {b : α} {l₂ : List α}, (l₁ ++ b :: l₂).dropLast = l₁ ++ (b :: l₂).dropLast | null | true |
Subarray.scanlM.eq_1 | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (init : β)
(as : Subarray α), Subarray.scanlM f init as = Array.scanlM f init as.array as.start as.stop | null | true |
MeasureTheory.Measure.sum_fintype | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [inst : Fintype ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.Measure.sum μ = ∑ i, μ i | null | true |
LightCondensed.instMonoidalClosedFunctorOppositeLightProfiniteModuleCat._proof_1 | Mathlib.Condensed.Light.Monoidal | ∀ (R : Type u_1) [inst : CommRing R], (CategoryTheory.equivSmallModel LightProfinite).op.congrLeft.functor.IsEquivalence | null | false |
Finset.preimage_add_right_zero' | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {b : α}, Finset.preimage 0 (fun x => x + -b) ⋯ = {b} | null | true |
_private.Std.Data.Iterators.Combinators.Monadic.Zip.0.Std.Iterators.Types.Zip.instFinitenessRelation₂.match_3 | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type u_1 → Type u_2} {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ m β₁]
(motive : Option { out // ∃ it, it.IsPlausibleOutput out } × Std.IterM.TerminationMeasures.Productive α₁ m → Prop)
(x : Option { out // ∃ it, it.IsPlausibleOutput out } × Std.IterM.TerminationMeasures.Productive α₁ m),
(∀ (a : Option { o... | null | false |
LinearMap.quotKerEquivOfSurjective_symm_apply | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {M : Type u_2} {M₂ : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂] (f : M →ₗ[R] M₂) (hf : Function.Surjective ⇑f) (x : M),
(f.quotKerEquivOfSurjective hf).symm (f x) = Submodule.Quotient.mk x | null | true |
FreeAddMagma.add | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → FreeAddMagma α → FreeAddMagma α | null | true |
Lean.Meta.FindSplitImpl.Context.recOn | Lean.Meta.Tactic.SplitIf | {motive : Lean.Meta.FindSplitImpl.Context → Sort u} →
(t : Lean.Meta.FindSplitImpl.Context) →
((exceptionSet : Lean.ExprSet) →
(kind : Lean.Meta.SplitKind) → motive { exceptionSet := exceptionSet, kind := kind }) →
motive t | null | false |
Lean.Lsp.FoldingRange.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{startLine endLine : ℕ} →
{kind? : Option Lean.Lsp.FoldingRangeKind} →
{startLine' endLine' : ℕ} →
{kind?' : Option Lean.Lsp.FoldingRangeKind} →
{ startLine := startLine, endLine := endLine, kind? := kind? } =
{ startLine := startLine', endLine := endLine', kin... | null | false |
Quiver.IsSStronglyConnected | Mathlib.Combinatorics.Quiver.ConnectedComponent | (V : Type u_2) → [Quiver V] → Prop | Positive strong connectivity: every ordered pair of vertices is joined by a directed path
of positive length. | true |
_private.Mathlib.FieldTheory.SeparablyGenerated.0.exists_isTranscendenceBasis_and_isSeparable_of_linearIndepOn_pow_of_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.SeparablyGenerated | ∀ {k : Type u_2} {K : Type u_3} {ι : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {a : ι → K}
(motive :
(∃ i, (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparable (↥(IntermediateField.adjoin k (a '' {i}ᶜ))) (a i)) →
Prop)
(x : ∃ i, (IsTranscendenceBasis k fun j => a ↑j) ∧ IsSeparab... | null | false |
Lean.Meta.AC.PreExpr.brecOn.go | Lean.Meta.Tactic.AC.Main | {motive : Lean.Meta.AC.PreExpr → Sort u} →
(t : Lean.Meta.AC.PreExpr) →
((t : Lean.Meta.AC.PreExpr) → Lean.Meta.AC.PreExpr.below t → motive t) → motive t ×' Lean.Meta.AC.PreExpr.below t | null | true |
StieltjesFunction.zero_apply | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : R), ↑0 x = 0 | null | true |
MulAut.instInhabited.eq_1 | Mathlib.Algebra.Group.End | ∀ (M : Type u_2) [inst : Mul M], MulAut.instInhabited M = { default := 1 } | null | true |
subsetInfSet._proof_1 | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_1} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] (t : Set ↑s),
t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s → sInf (Subtype.val '' t) ∈ s | null | false |
CategoryTheory.Grothendieck.comp.eq_1 | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y Z : CategoryTheory.Grothendieck F} (f : X.Hom Y) (g : Y.Hom Z),
CategoryTheory.Grothendieck.comp f g =
{ base := CategoryTheory.CategoryStruct.comp f.base g.base,
fiber :=
CategoryTheory... | null | true |
derivationQuotKerSq._proof_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (R : Type u_3) (P : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
LinearMap.CompatibleSMul Ω[P⁄R] (TensorProduct P S Ω[P⁄R]) R P | null | false |
_private.Init.Data.List.Erase.0.List.eraseP_filterMap.match_1.eq_2 | Init.Data.List.Erase | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : (y : β) → motive (some y)) (h_2 : Unit → motive none),
(match none with
| some y => h_1 y
| none => h_2 ()) =
h_2 () | null | true |
Lean.Meta.Grind.Arith.Linear.instMonadGetStructLinearM | Lean.Meta.Tactic.Grind.Arith.Linear.LinearM | Lean.Meta.Grind.Arith.Linear.MonadGetStruct Lean.Meta.Grind.Arith.Linear.LinearM | null | true |
MulOpposite.instAdd | Mathlib.Algebra.Opposites | {α : Type u_1} → [Add α] → Add αᵐᵒᵖ | null | true |
List.hasDecEq._f | Init.Prelude | {α : Type u} →
[DecidableEq α] →
(x : List α) →
List.below (motive := fun x => (x_1 : List α) → Decidable (x = x_1)) x → (x_1 : List α) → Decidable (x = x_1) | null | false |
ContinuousOn.prodMk | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] {f : α → β} {g : α → γ} {s : Set α},
ContinuousOn f s → ContinuousOn g s → ContinuousOn (fun x => (f x, g x)) s | null | true |
Set.opEquiv_self | Mathlib.Data.Set.Opposite | {α : Type u_1} → (s : Set α) → ↑s.op ≃ ↑s | The members of the opposite of a set are in bijection with the members of the set itself. | true |
Bundle.Pretrivialization.continuousAlternatingMapCoordChange._proof_4 | Mathlib.Topology.VectorBundle.ContinuousAlternatingMap | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F₂ : Type u_2} [inst_1 : NormedAddCommGroup F₂]
[inst_2 : NormedSpace 𝕜 F₂], ContinuousConstSMul 𝕜 F₂ | null | false |
Complex.sin_surjective | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Function.Surjective Complex.sin | null | true |
PrincipalSeg.ofElement | Mathlib.Order.InitialSeg | {α : Type u_4} → (r : α → α → Prop) → (a : α) → PrincipalSeg (Subrel r fun x => r x a) r | Any element of a well order yields a principal segment. | true |
Module.FinitePresentation.linearEquivMap._proof_3 | Mathlib.Algebra.Module.FinitePresentation | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
_private.Mathlib.Geometry.Euclidean.Sphere.OrthRadius.0.EuclideanGeometry.Sphere.inter_orthRadius_eq_empty_iff._simp_1_5 | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {a : Prop}, (¬¬a) = a | null | false |
Algebra.IsAlgebraic.algHomEquivAlgHomOfSplits._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (A : Type u_1) [Field A], Nontrivial A | null | false |
Order.le_pred_iff._simp_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], (b ≤ Order.pred a) = (b < a) | null | false |
_private.Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas.0.IsDedekindDomain.quotientEquivPiOfProdEq._proof_3 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} (P : ι → Ideal R), (∀ (i : ι), Prime (P i)) → ∀ (i : ι), P i ≠ 0 | null | false |
AddCon.ker.congr_simp | Mathlib.Algebra.Colimit.Module | ∀ {M : Type u_1} {N : Type u_2} {F : Type u_4} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f f_1 : F), f = f_1 → AddCon.ker f = AddCon.ker f_1 | null | true |
CategoryTheory.Functor.chosenProd.fst | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.SemiCartesianMonoidalCategory C] →
(X Y : C) → CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ⟶ X | **Alias** of `CategoryTheory.SemiCartesianMonoidalCategory.fst`. | true |
AlgebraicGeometry.Scheme.Pullback.gluedLift._proof_2 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
(s : CategoryTheory.Limits.PullbackCone f g) (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ s.fst 𝒰).I₀),
CategoryTheory.Limits.HasPullback s.fst (𝒰.f i) | null | false |
FinBoolAlg.hasForgetToFinBddDistLat._proof_4 | Mathlib.Order.Category.FinBoolAlg | { obj := fun X => FinBddDistLat.of ↑X.toBoolAlg, map := fun {X Y} f => FinBddDistLat.ofHom (BoolAlg.Hom.hom f.hom),
map_id := FinBoolAlg.hasForgetToFinBddDistLat._proof_1,
map_comp := @FinBoolAlg.hasForgetToFinBddDistLat._proof_2 }.comp
(CategoryTheory.forget FinBddDistLat) =
CategoryTheory.forget... | null | false |
NumberField.instCommRingRingOfIntegers._proof_7 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] (a : NumberField.RingOfIntegers K), a + 0 = a | null | false |
PresheafOfModules.pushforward₀._proof_3 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ RingCat) (X : PresheafOfModules R),
{ app := fun X_1 => (CategoryTheory.CategoryStruct.id X).app (F.op.obj X_1), naturality... | null | false |
AddSubgroup.distribSMulToLinearMap_injective_of_isTorsionFree | Mathlib.GroupTheory.IndexNSmul | ∀ {M : Type u_1} [inst : AddCommGroup M] [Module.IsTorsionFree ℤ M] {n : ℕ},
n ≠ 0 → Function.Injective ⇑(DistribSMul.toLinearMap ℤ M n) | On an additive group that is torsion-free as a `ℤ`-module, the linear map given by
multiplication by `n : ℕ` is injective (when `n ≠ 0`). | true |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.image_sub_const_Ico._proof_1_3 | Mathlib.Order.Interval.Finset.Nat | ∀ {a b c : ℕ} (x : ℕ), a - c ≤ x ∧ x < b - c → (a ≤ x + c ∧ x + c < b) ∧ x + c - c = x | null | false |
CategoryTheory.Presieve.yonedaFamilyOfElements_fromCocone | Mathlib.CategoryTheory.Sites.SheafOfTypes | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
(R : CategoryTheory.Presieve X) →
(s : CategoryTheory.Limits.Cocone R.diagram) →
CategoryTheory.Presieve.FamilyOfElements (CategoryTheory.yoneda.obj s.pt) R | Construct a family of elements from a cocone. | true |
AffineSubspace.smul_vsub_vadd_mem | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (self : AffineSubspace k P) (c : k) {p₁ p₂ p₃ : P},
p₁ ∈ self.carrier → p₂ ∈ self.carrier → p₃ ∈ self.carrier → c • (p₁ -ᵥ p₂) +ᵥ p₃ ∈ self.carrier | null | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.outerYield | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{it₁ it₁' : Std.IterM m (Std.IterM m β)} {it₂' : Std.IterM m β},
it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂') →
Std.Iterators.Types.Flatten.IsPlausibleStep { internalState := { it₁ := it₁, i... | null | true |
RelSeries.ctorIdx | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → RelSeries r → ℕ | null | false |
CategoryTheory.IsMonHom.one_hom._autoParam | Mathlib.CategoryTheory.Monoidal.Mon | Lean.Syntax | null | false |
ENNReal.add_halves | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal), a / 2 + a / 2 = a | null | true |
Finset.map_insert | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq β] (f : α ↪ β) (a : α) (s : Finset α),
Finset.map f (insert a s) = insert (f a) (Finset.map f s) | null | true |
RingCon.finsuppProd | Mathlib.RingTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {β : Type u_2} {M : Type u_3} [inst : Add M] [inst_1 : CommMonoid M] [inst_2 : Zero β] (c : RingCon M)
(h h' : ι → β → M) {f g : ι →₀ β},
(∀ (i : ι), c (h i 0) 1) →
(∀ (i : ι), c (h' i 0) 1) → (∀ (i : ι), c (h i (f i)) (h' i (g i))) → c (f.prod h) (g.prod h') | null | true |
_private.Qq.ForLean.ToExpr.0.toExprLevel.match_1 | Qq.ForLean.ToExpr | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((l : Lean.Level) → motive l.succ) →
((l₁ l₂ : Lean.Level) → motive (l₁.max l₂)) →
((l₁ l₂ : Lean.Level) → motive (l₁.imax l₂)) →
((n : Lean.Name) → motive (Lean.Level.param n)) →
... | null | false |
SimpleGraph.instMax | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u} → Max (SimpleGraph V) | The supremum of two graphs `x ⊔ y` has edges where either `x` or `y` have edges. | true |
DirectSum.liftRingHom._proof_3 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] {A : ι → Type u_2} {R : Type u_3} [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] [inst_4 : Semiring R]
(f :
{ f //
f GradedMonoid.GOne.one = 1 ∧ ∀ {i j : ι} (ai : A i) (aj : A j), f (GradedMonoid.GMul.mul ai aj) = f ... | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.NormedSpace.0.MeasureTheory.Measure.setIntegral_comp_smul._simp_1_1 | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {s : Set γ}, f ⁻¹' g ⁻¹' s = g ∘ f ⁻¹' s | null | false |
Rep.Hom.noConfusionType | Mathlib.RepresentationTheory.Rep.Basic | Sort u_1 →
{k : Type u} →
{G : Type v} →
[inst : Semiring k] →
[inst_1 : Monoid G] →
{A B : Rep.{w, u, v} k G} →
A.Hom B →
{k' : Type u} →
{G' : Type v} →
[inst' : Semiring k'] → [inst'_1 : Monoid G'] → {A' B' : Rep.{w, u, v} k' G... | null | false |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop.match_1 | Init.Data.Array.InsertionSort | (motive : ℕ → Sort u_1) → (j : ℕ) → (j = 0 → motive 0) → ((j' : ℕ) → j = j'.succ → motive j'.succ) → motive j | null | false |
NNReal.instLinearOrder._aux_6 | Mathlib.Data.NNReal.Defs | DecidableEq NNReal | null | false |
_private.Mathlib.RingTheory.PowerSeries.NoZeroDivisors.0.PowerSeries.instNoZeroDivisors._simp_1 | Mathlib.RingTheory.PowerSeries.NoZeroDivisors | ∀ {R : Type u_1} [inst : Semiring R] {φ : PowerSeries R}, (φ = 0) = (φ.order = ⊤) | null | false |
RingHomId.eq_id | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R : Type u_4} {inst : Semiring R} {σ : R →+* R} [self : RingHomId σ], σ = RingHom.id R | null | true |
TopologicalSpace.IsTopologicalBasis.of_isOpen_of_subset | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {s s' : Set (Set α)},
(∀ u ∈ s', IsOpen u) → TopologicalSpace.IsTopologicalBasis s → s ⊆ s' → TopologicalSpace.IsTopologicalBasis s' | null | true |
LinearEquiv.piRing | Mathlib.LinearAlgebra.Pi | (R : Type u) →
(M : Type v) →
(ι : Type x) →
[inst : Semiring R] →
(S : Type u_4) →
[Fintype ι] →
[DecidableEq ι] →
[inst_3 : Semiring S] →
[inst_4 : AddCommMonoid M] →
[inst_5 : Module R M] →
[inst_6 : Module ... | Linear equivalence between linear functions `Rⁿ → M` and `Mⁿ`. The spaces `Rⁿ` and `Mⁿ`
are represented as `ι → R` and `ι → M`, respectively, where `ι` is a finite type.
This as an `S`-linear equivalence, under the assumption that `S` acts on `M` commuting with `R`.
When `R` is commutative, we can take this to be the ... | true |
Std.Internal.List.maxKeyD_le_maxKeyD_insertEntry | 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 →
l.isEmpty = false →
∀ {k : α} {v : β k} {fallback : α},
(compare (Std.Internal.List.maxKeyD l fallback)
(Std.Internal.L... | null | true |
Lean.Parser.Tactic.Grind.grindAdmit | Init.Grind.Interactive | Lean.ParserDescr | `admit` is a synonym for `sorry`. | true |
Finset.prod_ite_of_false | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_3} {s : Finset ι} [inst : CommMonoid M] {p : ι → Prop} [inst_1 : DecidablePred p],
(∀ x ∈ s, ¬p x) → ∀ (f g : ι → M), (∏ x ∈ s, if p x then f x else g x) = ∏ x ∈ s, g x | null | true |
_private.Lean.Meta.ExprTraverse.0.Lean.Meta.traverseForallWithPos.visit.match_1 | Lean.Meta.ExprTraverse | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (c : Lean.BinderInfo) → motive (Lean.Expr.forallE n d b c)) →
((e : Lean.Expr) → motive e) → motive x | null | false |
Equiv.recOn | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} →
{β : Sort u_2} →
{motive : α ≃ β → Sort u} →
(t : α ≃ β) →
((toFun : α → β) →
(invFun : β → α) →
(left_inv : Function.LeftInverse invFun toFun) →
(right_inv : Function.RightInverse invFun toFun) →
motive { toFun := toFun, i... | null | false |
Continuous.cfcₙ_nnreal'._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
topologicalAddGroup_inf | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : AddGroup G] {t₁ t₂ : TopologicalSpace G},
IsTopologicalAddGroup G → IsTopologicalAddGroup G → IsTopologicalAddGroup G | null | true |
ContinuousLinearMapWOT.continuous_inner_apply | Mathlib.Analysis.InnerProductSpace.WeakOperatorTopology | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : NormedAddCommGroup F] [inst_5 : InnerProductSpace 𝕜 F] [CompleteSpace F]
{α : Type u_4} [inst_7 : TopologicalSpace α] {f : α → E →WOT[𝕜] F},
Continuous f → ... | **Alias** of the forward direction of `ContinuousLinearMapWOT.continuous_iff`. | true |
Acc.casesOn | Init.WF | {α : Sort u} →
{r : α → α → Prop} →
{motive : (a : α) → Acc r a → Sort u_1} →
{a : α} → (t : Acc r a) → ((x : α) → (h : ∀ (y : α), r y x → Acc r y) → motive x ⋯) → motive a t | null | false |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_2 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ),
¬acc + ↑(Std.Time.Month.Ordinal.days leap idx) - acc = ↑(Std.Time.Month.Ordinal.days leap idx) → False | null | false |
Function.Embedding.instAddAction._proof_1 | Mathlib.GroupTheory.GroupAction.Embedding | ∀ {α : Type u_1} {β : Type u_2}, Function.Injective DFunLike.coe | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.