name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
finSuccEquiv'_below | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i : Fin (n + 1)} {m : Fin n}, m.castSucc < i → (finSuccEquiv' i) m.castSucc = some m | null | true |
Lean.Elab.Attribute.stx | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.Syntax | null | true |
CategoryTheory.Functor.splitEpiEquiv._proof_6 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[inst_2 : F.Full] [inst_3 : F.Faithful] (x : CategoryTheory.SplitEpi (F.map f)),
(fun f_1 => f_1.map F) ((fun s => { section_ := F.pr... | null | false |
Std.DTreeMap.Internal.Impl.Const.isSome_apply_of_contains_filterMap | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {γ : Type w} {t : Std.DTreeMap.Internal.Impl α fun x => β}
[inst : Std.TransOrd α] {f : α → β → Option γ} {k : α} (h : t.WF)
(h' : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl = true),
(f (t.getKey k ⋯) (Std.DTreeMap.Internal... | null | true |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.SFinite.0.MeasureTheory.Measure.countable_meas_pos_of_disjoint_iUnion₀._simp_1_4 | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (a ≤ 0) = (a = 0) | null | false |
CategoryTheory.StructuredArrow.isoMk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{S : D} →
{T : CategoryTheory.Functor C D} →
{f f' : CategoryTheory.StructuredArrow S T} →
(g : f.right ≅ f'.right) →
auto... | To construct an isomorphism of structured arrows,
we need an isomorphism of the objects underlying the target,
and to check that the triangle commutes.
| true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.truncate.go.match_1 | Lean.Server.Completion.CompletionCollectors | (motive : Lean.Name × ℕ → Sort u_1) → (x : Lean.Name × ℕ) → ((p' : Lean.Name) → (len : ℕ) → motive (p', len)) → motive x | null | false |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.ListBlank.append.match_1.eq_2 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : List Γ → Turing.ListBlank Γ → Sort u_2) (a : Γ) (l : List Γ)
(L : Turing.ListBlank Γ) (h_1 : (L : Turing.ListBlank Γ) → motive [] L)
(h_2 : (a : Γ) → (l : List Γ) → (L : Turing.ListBlank Γ) → motive (a :: l) L),
(match a :: l, L with
| [], L => h_1 L
| a :: ... | null | true |
_private.Init.TacticsExtra.0.Lean.Parser.Tactic._aux_Init_TacticsExtra___macroRules_Lean_Parser_Tactic_tacticRw_mod_cast____1.match_1 | Init.TacticsExtra | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc | null | false |
isTopologicalBasis_biInter_Ioi_Iio_of_generateFrom._to_dual_1 | Mathlib.Topology.Order.Basic | ∀ {α : Type u} [ts : TopologicalSpace α] [inst : Preorder α] (c : Set α),
ts = TopologicalSpace.generateFrom {s | ∃ a ∈ c, s = Set.Iio a ∨ s = Set.Ioi a} →
TopologicalSpace.IsTopologicalBasis
{s | ∃ f g, f ⊆ c ∧ g ⊆ c ∧ f.Finite ∧ g.Finite ∧ s = (⋂ a ∈ f, Set.Iio a) ∩ ⋂ a ∈ g, Set.Ioi a} | null | false |
MeasureTheory.MemLp.aemeasurable | Mathlib.MeasureTheory.Function.LpSeminorm.Defs | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} [inst : ENorm ε] {μ : MeasureTheory.Measure α}
[inst_1 : MeasurableSpace ε] [inst_2 : TopologicalSpace ε] [TopologicalSpace.PseudoMetrizableSpace ε] [BorelSpace ε]
{f : α → ε} {p : ENNReal}, MeasureTheory.MemLp f p μ → AEMeasurable f μ | null | true |
Cardinal.add_one_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}}, α + 1 = β + 1 ↔ α = β | null | true |
PowerSeries.IsWeierstrassDivision.unique | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] [inst_1 : IsLocalRing A] {f g : PowerSeries A},
(PowerSeries.map (IsLocalRing.residue A)) g ≠ 0 →
∀ [inst_2 : IsAdicComplete (IsLocalRing.maximalIdeal A) A] {q : PowerSeries A} {r : Polynomial A},
f.IsWeierstrassDivision g q r → q = f /ʷ g ∧ r = f %ʷ g | If `q` and `r` are quotient and remainder in the Weierstrass division `f / g`, then they are
equal to `f /ʷ g` and `f %ʷ g`. | true |
Ideal.add_eq_sup | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I J : Ideal R}, I + J = I ⊔ J | null | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Map.0.LinearMap.rTensor_neg._simp_1_1 | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_7) {N : Type u_8} {P : Type u_9} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], LinearMap.rTensor M = ⇑(LinearMap.rTensorHom M) | null | false |
IsRightRegular.mul_right_eq_self_iff | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Monoid R] {a b : R}, IsRightRegular a → (b * a = a ↔ b = 1) | null | true |
StrictAnti.strictAntiOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
StrictAnti f → ∀ (s : Set α), StrictAntiOn f s | null | true |
NonUnitalStarRingHom.copy._proof_2 | Mathlib.Algebra.Star.StarRingHom | ∀ {A : Type u_2} {B : Type u_1} [inst : NonUnitalNonAssocSemiring A] [inst_1 : Star A]
[inst_2 : NonUnitalNonAssocSemiring B] [inst_3 : Star B] (f : A →⋆ₙ+* B) (f' : A → B), f' = ⇑f → f' 0 = 0 | null | false |
Lean.Lsp.FileEvent.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileEvent → Sort u} →
(t : Lean.Lsp.FileEvent) →
((uri : Lean.Lsp.DocumentUri) → (type : Lean.Lsp.FileChangeType) → motive { uri := uri, type := type }) → motive t | null | false |
EuclideanGeometry.inversion_eq_center'._simp_1 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c x : P} {R : ℝ}, (EuclideanGeometry.inversion c R x = c) = (x = c ∨ R = 0) | null | false |
AddMonoidHom.coeToZeroHom | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_4} → {N : Type u_5} → [inst : AddZero M] → [inst_1 : AddZero N] → Coe (M →+ N) (ZeroHom M N) | `AddMonoidHom` down-cast to a `ZeroHom`, forgetting the additive property | true |
Lean.Elab.FixedParams.instToFormatInfo | Lean.Elab.PreDefinition.FixedParams | Std.ToFormat Lean.Elab.FixedParams.Info | null | true |
CategoryTheory.Functor.homologySequence_mono_shift_map_mor₂_iff | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A)
[inst_3 : CategoryTheory.Limits.HasZeroObject C] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (Categ... | null | true |
BitVec.ushiftRight_eq_extractLsb'_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ} (hn : n < w), x >>> n = BitVec.cast ⋯ (0#n ++ BitVec.extractLsb' n (w - n) x) | null | true |
HomologicalComplex.leftUnitor'_inv_comm_assoc | Mathlib.Algebra.Homology.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Limits.HasZeroObject C]
[inst_4 : (CategoryTheory.MonoidalCategory.curriedTensor C).Additive]
[inst_5 : ∀ (X₁ : C), ((CategoryTheory.Monoidal... | null | true |
CategoryTheory.GradedObject.isColimitCofan₃MapBifunctorBifunctor₂₃MapObj._proof_6 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3} {J : Type u_5} {r : I₁ × I₂ × I₃ → J}
(ρ₂₃ : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r) (j : J) (x : ↑(ρ₂₃.q ⁻¹' {j})) (i₂ : I₂) (i₃ : I₃),
(i₂, i₃) ∈ ρ₂₃.p ⁻¹' {x.1.2} →
(x.1.1, i₂, i₃) ∈
(fun x =>
match x with
| (i₁, i₂, ... | null | false |
FirstOrder.Field.FieldAxiom.toProp | Mathlib.ModelTheory.Algebra.Field.Basic | (K : Type u_2) → [Add K] → [Mul K] → [Neg K] → [Zero K] → [One K] → FirstOrder.Field.FieldAxiom → Prop | The Proposition corresponding to each field axiom | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.equiv_zero_of_val_eq_of_equiv_zero.match_1_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {f : PadicSeq p} (ε : ℚ)
(motive : (∃ i, ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε) → Prop) (x : ∃ i, ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε),
(∀ (i : ℕ) (hi : ∀ j ≥ i, padicNorm p (↑(f - 0) j) < ε), motive ⋯) → motive x | null | false |
ProbabilityTheory.Kernel.isProper_iff_inter_eq_indicator_mul | Mathlib.Probability.Kernel.Proper | ∀ {X : Type u_1} {𝓑 𝓧 : MeasurableSpace X} {π : ProbabilityTheory.Kernel X X},
𝓑 ≤ 𝓧 →
(π.IsProper ↔
∀ ⦃A : Set X⦄,
MeasurableSet A → ∀ ⦃B : Set X⦄, MeasurableSet B → ∀ (x : X), (π x) (A ∩ B) = B.indicator 1 x * (π x) A) | null | true |
Std.Net.instDecidableEqIPv6Addr.decEq | Std.Net.Addr | (x x_1 : Std.Net.IPv6Addr) → Decidable (x = x_1) | null | true |
Algebra.WeaklyEtale.instTensorProduct | Mathlib.RingTheory.Etale.Weakly | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u_3}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [Algebra.WeaklyEtale R S], Algebra.WeaklyEtale T (TensorProduct R T S) | [Stacks Tag 092H](https://stacks.math.columbia.edu/tag/092H) ((2)) | true |
IsCancelSMul.toIsLeftCancelSMul | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : SMul G P} [self : IsCancelSMul G P], IsLeftCancelSMul G P | null | true |
_private.Init.Data.Array.Sort.Lemmas.0.Array.MergeSort.merge_eq_listMerge | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs ys : Array α} {le : α → α → Bool},
(Array.MergeSort.Internal.merge✝ xs ys le).toList = xs.toList.merge ys.toList le | null | true |
MeasureTheory.IntegrableOn.comp_neg_Iio | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_4} {F : Type u_6} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.Measure G}
[inst_2 : PartialOrder G] [inst_3 : AddCommGroup G] [IsOrderedAddMonoid G] [MeasurableNeg G] [μ.IsNegInvariant]
{c : G} {f : G → F},
MeasureTheory.IntegrableOn f (Set.Ioi (-c)) μ → MeasureTheor... | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.homologyIso._proof_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ (r r' : ℤ), r + 1 = r' → r ≤ r' | null | false |
Ne.irrefl | Init.Core | ∀ {α : Sort u} {a : α}, a ≠ a → False | null | true |
List.zipWith_rotate_distrib | Mathlib.Data.List.Rotate | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β) (n : ℕ),
l.length = l'.length → (List.zipWith f l l').rotate n = List.zipWith f (l.rotate n) (l'.rotate n) | null | true |
«_aux_Init_Notation___macroRules_term_∘__1» | Init.Notation | Lean.Macro | null | false |
differentIdeal.eq_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (B : Type u_3) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[inst_4 : IsDedekindDomain B] [inst_5 : Module.IsTorsionFree A B],
differentIdeal A B =
Submodule.comap (Algebra.linearMap B (FractionRing B)) (1 / Submodule.traceDual A (FractionRing A) 1) | null | true |
CategoryTheory.Triangulated.TStructure.descTruncGT.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
Std.ExtTreeMap.getKey!_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α} {f : β → β},
(t.modify k f).getKey! k' = if cmp k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k' | null | true |
map_rat_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] [_instM : Module ℚ M]
[_instM₂ : Module ℚ M₂] {F : Type u_3} [inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (c : ℚ) (x : M),
f (c • x) = c • f x | null | true |
DFinsupp.comapDomain'.congr_simp | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) {h' h'_1 : ι → κ}
(e_h' : h' = h'_1) (hh' : Function.LeftInverse h' h) (f f_1 : Π₀ (i : ι), β i),
f = f_1 → DFinsupp.comapDomain' h hh' f = DFinsupp.comapDomain' h ⋯ f_1 | null | true |
_private.Mathlib.Topology.Order.MonotoneConvergence.0.Pi.supConvergenceClass._simp_2 | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range (s.restrict f) | null | false |
NormedRing.induced._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : NormedRing S] (f : F),
Filter.comap (⇑f) (Bornology.cobounded S) ≤ Filter.cofinite | null | false |
CategoryTheory.Precoverage.SubsheafClosure.amalgamate | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : CategoryTheory.Precoverage C}
{F : CategoryTheory.Functor Cᵒᵖ (Type w)} {𝒮 : (Z : C) → Set (F.obj (Opposite.op Z))} {Z : C}
{R : CategoryTheory.Presieve Z},
R ∈ K.coverings Z →
∀ {y : CategoryTheory.Presieve.FamilyOfElements F R},
y.Compatib... | Gluing of sections in the closure. | true |
CategoryTheory.Limits.coconeOfCoconeUncurryIsColimit._proof_3 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_4} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → Cat... | null | false |
Polynomial.natTrailingDegree_mul' | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
p.trailingCoeff * q.trailingCoeff ≠ 0 → (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree | null | true |
VectorField.mlieBracketWithin_congr_set | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : 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} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s t : Set M} {x : M} {V W : (x : M) → ... | null | true |
Representation.isTrivial_def | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) [ρ.IsTrivial] (g : G), ρ g = LinearMap.id | null | true |
Lean.Kernel.Environment.addDeclWithoutChecking | Lean.Environment | Lean.Kernel.Environment → Lean.Declaration → Except Lean.Kernel.Exception Lean.Kernel.Environment | Add declaration to kernel without type checking it.
**WARNING** This function is meant for temporarily working around kernel performance issues.
It compromises soundness because, for example, a buggy tactic may produce an invalid proof,
and the kernel will not catch it if the new option is set to true.
| true |
Finpartition.combine._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {ι : Type u_2} {I : Finset ι}
{a : ι → α} (P : (i : ι) → Finpartition (a i)), (I.biUnion fun i => (P i).parts).sup id = I.sup a | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_umod._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ}, ¬i < w → ¬w ≤ i → False | null | false |
Commute.intCast_right | Mathlib.Data.Int.Cast.Lemmas | ∀ {α : Type u_3} [inst : NonAssocRing α] {a : α} {n : ℤ}, Commute a ↑n | null | true |
CategoryTheory.isNoetherianObject_iff_isEventuallyConstant | Mathlib.CategoryTheory.Subobject.NoetherianObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
CategoryTheory.IsNoetherianObject X ↔
∀ (F : CategoryTheory.Functor ℕ (CategoryTheory.MonoOver X)), CategoryTheory.IsFiltered.IsEventuallyConstant F | null | true |
Nat.monotone_primeCounting | Mathlib.NumberTheory.PrimeCounting | Monotone Nat.primeCounting | null | true |
MulAction.is_one_preprimitive_iff | Mathlib.GroupTheory.GroupAction.MultiplePrimitivity | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α],
MulAction.IsMultiplyPreprimitive M α 1 ↔ MulAction.IsPreprimitive M α | An action is preprimitive iff it is `1`-preprimitive. | true |
CategoryTheory.Functor.leftKanExtensionIsoFiberwiseColimit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_2} {D : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_6} D] (L : CategoryTheory.Functor C D) {H : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} H] (F : CategoryTheory.Functor C H) [L.HasPointwiseLeftKanExtension F]
(X : D),
CategoryTheor... | null | false |
HasFPowerSeriesOnBall.pi | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_9} [inst_3 : Fintype ι] {e : E} {Fm : ι → Type u_10}
[inst_4 : (i : ι) → NormedAddCommGroup (Fm i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (Fm i)] {f : (i : ι) → E → Fm i}
{r : ... | null | true |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.smul.eq_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {S : Type u_3} [inst_1 : SMulZeroClass S k] (x : S) (b : G →₀ k),
SkewMonoidAlgebra.smul✝ x { toFinsupp := b } = { toFinsupp := x • b } | null | true |
alexDiscEquivPreord._proof_5 | Mathlib.Topology.Order.Category.AlexDisc | ∀ (X : AlexDisc),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord).map
((CategoryTheory.NatIso.ofComponents
(fun X => AlexDisc.Iso.mk (id (homeoWithUpperSetTopologyorderIso ↑X.toTopCat)))
@alexDiscEquivPreord._proof_3).hom.ap... | null | false |
Aesop.EqualUpToIdsM.State.mk.inj | Aesop.Util.EqualUpToIds | ∀ {equalMVarIds : Std.HashMap Lean.MVarId Lean.MVarId} {equalLMVarIds : Std.HashMap Lean.LMVarId Lean.LMVarId}
{leftUnassignedMVarValues rightUnassignedMVarValues : Std.HashMap Lean.MVarId Lean.Expr}
{equalMVarIds_1 : Std.HashMap Lean.MVarId Lean.MVarId} {equalLMVarIds_1 : Std.HashMap Lean.LMVarId Lean.LMVarId}
{... | null | true |
MeasureTheory.weightedSMul_union | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (s t : Set α),
MeasurableSet s →
MeasurableSet t →
μ s ≠ ⊤ →
μ t ≠ ⊤ →
Disjoint s t →
MeasureTheory.weightedSMul μ (s ∪ t) = MeasureT... | null | true |
_private.Mathlib.RingTheory.Multiplicity.0.FiniteMultiplicity.or_of_add._simp_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Semigroup α] [LeftDistribClass α] {a b c : α},
a ∣ b → a ∣ c → (a ∣ b + c) = True | null | false |
_private.Mathlib.Data.Nat.Squarefree.0.Nat.minSqFacAux.match_1._arg_pusher | Mathlib.Data.Nat.Squarefree | ∀ (motive : ℕ → ℕ → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x) (rel : ℕ → ℕ → α → Prop) (x x_1 : ℕ)
(h_1 : (n k : ℕ) → ((y : α) → rel n k y → β y) → motive n k),
((match (motive := (x x_2 : ℕ) → ((y : α) → rel x x_2 y → β y) → motive x x_2) x, x_1 with
| n, k => fun x => h_1 n k x)
fu... | null | false |
CochainComplex.augmentTruncate_hom_f_succ | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : CochainComplex V ℕ) (i : ℕ), C.augmentTruncate.hom.f (i + 1) = CategoryTheory.CategoryStruct.id (C.X (i + 1)) | null | true |
_private.Mathlib.Algebra.Lie.SemiDirect.0.LieAlgebra.SemiDirectSum.instLieRing._abel_1 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_2} [inst : CommRing R] {K : Type u_1} [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) (x x_1 x_2 : K ⋊⁅ψ⁆ L),
⁅x.left, x_2.left⁆ + ⁅x_1.left, x_2.left⁆ + ((ψ x.right) x_2.left + (ψ x_1.right) x_2.left) -
... | null | false |
ArzelaAscoli.compactSpace_of_isClosedEmbedding | Mathlib.Topology.UniformSpace.Ascoli | ∀ {ι : Type u_1} {X : Type u_2} {α : Type u_3} [inst : TopologicalSpace X] [inst_1 : UniformSpace α] {F : ι → X → α}
[inst_2 : TopologicalSpace ι] {𝔖 : Set (Set X)},
(∀ K ∈ 𝔖, IsCompact K) →
Topology.IsClosedEmbedding (⇑(UniformOnFun.ofFun 𝔖) ∘ F) →
(∀ K ∈ 𝔖, EquicontinuousOn F K) → (∀ K ∈ 𝔖, ∀ x ∈ K... | A version of the **Arzela-Ascoli theorem**.
Let `X, ι` be topological spaces, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)`. Assume that:
* `F`, viewed as a function `ι → (X →ᵤ[𝔖] α)`, is a closed embedding (in other words, `ι`
identifies to a closed subset of `X →ᵤ[𝔖] α` th... | true |
AddSubgroup.rightCosetEquivAddSubgroup._proof_5 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (g : α) (x : ↑(AddOpposite.op g +ᵥ ↑s)),
∃ a ∈ ↑s, AddOpposite.op g +ᵥ a = ↑⟨↑x + -g, ⋯⟩ + g | null | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.0.Mathlib.Tactic.Coherence.coherenceLoop.match_1 | Mathlib.Tactic.CategoryTheory.Coherence | (motive : ℕ → Sort u_1) →
(maxSteps : ℕ) → (Unit → motive 0) → ((maxSteps' : ℕ) → motive maxSteps'.succ) → motive maxSteps | null | false |
Lean.Level.quote | Lean.Level | Lean.Level → optParam ℕ 0 → optParam Bool true → (Lean.LMVarId → Option ℕ) → Lean.Syntax.Level | null | true |
IsAlgebraic.inv_iff | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K] {x : K},
IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x | null | true |
Ordnode.instInsert | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → Insert α (Ordnode α) | null | true |
Lean.Meta.Grind.TopSort.State.mk.inj | Lean.Meta.Tactic.Grind.EqResolution | ∀ {tempMark permMark : Std.HashSet Lean.Expr} {result : Array Lean.Expr} {tempMark_1 permMark_1 : Std.HashSet Lean.Expr}
{result_1 : Array Lean.Expr},
{ tempMark := tempMark, permMark := permMark, result := result } =
{ tempMark := tempMark_1, permMark := permMark_1, result := result_1 } →
tempMark = temp... | null | true |
Lean.Parser.Term.structInstField | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
ModuleCat.restrictScalarsId | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | (R : Type u₁) → [inst : Ring R] → ModuleCat.restrictScalars (RingHom.id R) ≅ CategoryTheory.Functor.id (ModuleCat R) | The restriction of scalars by the identity morphism identifies to the
identity functor. | true |
List.Sublist.reverse | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.reverse.Sublist l₂.reverse | null | true |
SeparationQuotient.inseparableSetoid_eq_top_iff | Mathlib.Topology.Inseparable | ∀ {α : Type u_4} [inst : TopologicalSpace α], inseparableSetoid α = ⊤ ↔ IndiscreteTopology α | null | true |
MeasureTheory.MemLp.comp_fst | Mathlib.MeasureTheory.Function.LpSeminorm.Prod | ∀ {α : Type u_1} {β : Type u_2} {ε : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] {μ : MeasureTheory.Measure α} {p : ENNReal} {f : α → ε},
MeasureTheory.MemLp f p μ →
∀ (ν : MeasureTheory.Measure β) [MeasureTheory.IsFiniteMeasure ν], Measur... | null | true |
Orientation.definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.Orientation.2114562672._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] (o : Orientation ℝ E (Fin 0)),
o = positiveOrientation ∨ o = -positiveOrientation | null | false |
QuadraticModuleCat.toModuleCat_tensor | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Invertible 2] (X Y : QuadraticModuleCat R),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).toModuleCat =
CategoryTheory.MonoidalCategoryStruct.tensorObj X.toModuleCat Y.toModuleCat | null | true |
List.scanr_ne_nil | Init.Data.List.Scan.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {l : List α} {f : α → β → β}, List.scanr f b l ≠ [] | null | true |
_private.Mathlib.Data.Set.Card.0.Set.three_lt_ncard._simp_1_1 | Mathlib.Data.Set.Card | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
Mathlib.Tactic.Widget.StringDiagram.Node.id.inj | Mathlib.Tactic.Widget.StringDiagram | ∀ {a a_1 : Mathlib.Tactic.Widget.StringDiagram.IdNode},
Mathlib.Tactic.Widget.StringDiagram.Node.id a = Mathlib.Tactic.Widget.StringDiagram.Node.id a_1 → a = a_1 | null | true |
IsDedekindDomain.normalizedFactorsEquivOfQuotEquiv._proof_7 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : IsDedekindDomain A] {I : Ideal R}
{J : Ideal A} [inst_3 : IsDedekindDomain R] (f : R ⧸ I ≃+* A ⧸ J) (hI : I ≠ ⊥) (hJ : J ≠ ⊥) (j : Ideal R)
(hj : j ∈ {L | L ∈ UniqueFactorizationMonoid.normalizedFactors I}),
(fun j => ⟨↑((IsDedeki... | null | false |
CategoryTheory.AddMon.equivLaxMonoidalFunctorPUnit_counitIso_inv_app_hom | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : CategoryTheory.AddMon C),
(CategoryTheory.AddMon.equivLaxMonoidalFunctorPUnit.counitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.X | null | true |
extDerivWithin_constOfIsEmpty | Mathlib.Analysis.Calculus.DifferentialForm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {x : E} (f : E → F),
UniqueDiffWithinAt 𝕜 s x →
extDerivWithin (fun x => ContinuousAlternatingM... | The exterior derivative of a `0`-form given by a function `f` within a set
is the 1-form given by the derivative of `f` within the set. | true |
WithTop.mul_lt_mul | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [OrderBot α]
[inst_4 : CanonicallyOrderedAdd α] [PosMulStrictMono α] {a₁ a₂ b₁ b₂ : WithTop α},
a₁ < a₂ → b₁ < b₂ → a₁ * b₁ < a₂ * b₂ | null | true |
_private.Init.Data.String.Lemmas.Pattern.Memcmp.0.String.Slice.Pattern.Internal.memcmpStr_eq_true_iff._proof_1_18 | Init.Data.String.Lemmas.Pattern.Memcmp | ∀ {lhs rhs : String} {lstart rstart : String.Pos.Raw} {len : String.Pos.Raw} (p : String.Pos.Raw),
p.byteIdx < len.byteIdx → ¬0 < len.byteIdx - p.byteIdx → False | null | false |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical.of | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) | Reify an `Expr` that is a boolean expression containing predicates about `BitVec` as atoms.
Unless this function is called on something that is not a `Bool` it is always going to return `some`.
| true |
_private.Mathlib.Algebra.Order.Field.Basic.0.sub_self_div_two._proof_1_1 | Mathlib.Algebra.Order.Field.Basic | (1 + 1).AtLeastTwo | null | false |
SimpleGraph.Subgraph.comap_equiv_top | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {W : Type v} {G : SimpleGraph V} {H : SimpleGraph W} (f : G →g H), SimpleGraph.Subgraph.comap f ⊤ = ⊤ | null | true |
CategoryTheory.Functor.IsLocallyDirected.recOn | Mathlib.CategoryTheory.LocallyDirected | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{F : CategoryTheory.Functor J (Type u_2)} →
{motive : F.IsLocallyDirected → Sort u} →
(t : F.IsLocallyDirected) →
((cond :
∀ {i j k : J} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
... | null | false |
exteriorPower.presentation.Rels | Mathlib.LinearAlgebra.ExteriorPower.Basic | Type u → Type u_4 → Type u_5 → Type (max (max u u_4) u_5) | The index type for the relations in the standard presentation of `⋀[R]^n M`,
in the particular case `ι` is `Fin n`. | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Bounds.0.norm_iteratedFDerivWithin_comp_le._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Int8.toInt_div | Init.Data.SInt.Lemmas | ∀ (a b : Int8), (a / b).toInt = (a.toInt.tdiv b.toInt).bmod (2 ^ 8) | null | true |
ContinuousMultilinearMap.compAlongComposition._proof_3 | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_4} {E : Type u_1} {F : Type u_3} {G : Type u_2} [inst : CommRing 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : AddCommGroup F] [inst_3 : AddCommGroup G] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜 F] [inst_6 : Module 𝕜 G]
[inst_7 : TopologicalSpace E] [inst_8 : TopologicalSpace F] [inst_9 : TopologicalSpac... | null | false |
String.Slice.Pattern.Model.IsValidRevSearchFrom.below | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.PatternModel pat] →
{s : String.Slice} →
{motive :
(a : s.Pos) →
(a_1 : List (String.Slice.Pattern.SearchStep s)) →
String.Slice.Pattern.Model.IsValidRevSearchFrom pat a a_1 → Prop} →
{a :... | null | true |
CategoryTheory.Pretriangulated.Triangle.rotate_mor₂ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C), T.rotate.mor₂ = T.mor₃ | null | true |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Presentation.Expr.4196812879._hygCtx._hyg.1.recOn | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} →
(t : ProofWidgets.RpcEncodablePacket✝) → ((expr : Lean.Json) → motive { expr := expr }) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.