name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
vadd_vsub_vadd_comm | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_1} {P : Type u_2} [inst : AddCommGroup G] [inst_1 : AddTorsor G P] (v₁ v₂ : G) (p₁ p₂ : P),
(v₁ +ᵥ p₁) -ᵥ (v₂ +ᵥ p₂) = v₁ - v₂ + (p₁ -ᵥ p₂) | null | true |
BitVec.recOn | Init.Prelude | {w : ℕ} → {motive : BitVec w → Sort u} → (t : BitVec w) → ((toFin : Fin (2 ^ w)) → motive { toFin := toFin }) → motive t | null | false |
LibraryNote.forgetful_inheritance | Mathlib.Algebra.Group.Monoid | Batteries.Util.LibraryNote | Suppose that one can put two mathematical structures on a type, a rich one `R` and a poor one
`P`, and that one can deduce the poor structure from the rich structure through a map `F` (called a
forgetful functor) (think `R = MetricSpace` and `P = TopologicalSpace`). A possible
implementation would be to have a type cla... | true |
_private.Lean.Server.FileWorker.InlayHints.0.Lean.Server.FileWorker.handleInlayHintsDidChange.updateOldInlayHints | Lean.Server.FileWorker.InlayHints | Lean.Lsp.DidChangeTextDocumentParams →
Array Lean.Elab.InlayHintInfo → Lean.Server.RequestM (Array Lean.Elab.InlayHintInfo) | null | true |
Ideal.IsHopfIdeal.rec | Mathlib.RingTheory.HopfAlgebra.Quotient | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring A] →
[inst_2 : HopfAlgebraStruct R A] →
{I : Ideal A} →
{motive : Ideal.IsHopfIdeal R I → Sort u} →
([toIsCoideal : (Submodule.restrictScalars R I).IsCoideal] →
(antipode_mem ... | null | false |
CategoryTheory.FreeBicategory.normalizeAux.eq_def | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ {B : Type u} [inst : Quiver B] {a : B} (x x_1 : B) (x_2 : Quiver.Path a x)
(x_3 : CategoryTheory.FreeBicategory.Hom x x_1),
CategoryTheory.FreeBicategory.normalizeAux x_2 x_3 =
match x, x_1, x_2, x_3 with
| x, x_4, p, CategoryTheory.FreeBicategory.Hom.of f => p.cons f
| x, .(x), p, CategoryTheory.Free... | null | true |
OpenPartialHomeomorph.coe_restrOpen_symm | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {s : Set X} (hs : IsOpen s), ↑(e.restrOpen s hs).symm = ↑e.symm | null | true |
Besicovitch.TauPackage.index.eq_def | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {β : Type u} [inst_1 : Nonempty β] (p : Besicovitch.TauPackage β α)
(x : Ordinal.{u}),
p.index x =
have i := x;
have Z := ⋃ j, Metric.ball (p.c (p.index ↑j)) (p.r (p.index ↑j));
have R := ⨆ b, p.r ↑b;
Classical.epsilon fun b => p.c b ∉ Z ∧ R ≤ p.τ * p.r b | null | true |
Topology.IsLower.mk | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_3} [t : TopologicalSpace α] [inst : Preorder α], t = Topology.lower α → Topology.IsLower α | null | true |
TopRep.coind₁ι_app | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u} [inst : TopologicalSpace k] [inst_1 : Ring k] {G : Type v} [inst_2 : Group G]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (rep : TopRep k G),
TopRep.coind₁ι.app rep = TopRep.ofHom rep.ρ.coind₁ι | null | true |
IsDomain.toIsCancelMulZero | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} {inst : Semiring α} [self : IsDomain α], IsCancelMulZero α | null | true |
Aesop.OrderedHashSet.noConfusion | Aesop.Util.OrderedHashSet | {P : Sort u} →
{α : Type u_1} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Aesop.OrderedHashSet α} →
{α' : Type u_1} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Aesop.OrderedHashSet α'} →
α = α' → inst ≍ inst' → inst_1... | null | false |
Submonoid.unop_sInf | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] (S : Set (Submonoid Mᵐᵒᵖ)), (sInf S).unop = sInf (Submonoid.op ⁻¹' S) | null | true |
ChainComplex.mkHomAux._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(P Q : ChainComplex V ℕ) (zero : P.X 0 ⟶ Q.X 0) (one : P.X 1 ⟶ Q.X 1)
(one_zero_comm : CategoryTheory.CategoryStruct.comp one (Q.d 1 0) = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero)
(succ :
... | null | false |
Prod.Lex.casesOn | Init.WF | ∀ {α : Type u} {β : Type v} {ra : α → α → Prop} {rb : β → β → Prop}
{motive : (a a_1 : α × β) → Prod.Lex ra rb a a_1 → Prop} {a a_1 : α × β} (t : Prod.Lex ra rb a a_1),
(∀ {a₁ : α} (b₁ : β) {a₂ : α} (b₂ : β) (h : ra a₁ a₂), motive (a₁, b₁) (a₂, b₂) ⋯) →
(∀ (a : α) {b₁ b₂ : β} (h : rb b₁ b₂), motive (a, b₁) (a, ... | null | false |
MvPolynomial.degrees_X | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] [Nontrivial R] (n : σ), (MvPolynomial.X n).degrees = {n} | null | true |
MeasureTheory.measurePreserving_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Add G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddLeftInvariant] (g : G), MeasureTheory.MeasurePreserving (fun x => g + x) μ μ | null | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.prevAux._proof_5 | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ), off + 1 < s.utf8ByteSize → ¬off < s.utf8ByteSize → False | null | false |
Std.DTreeMap.Internal.Impl.contains_minKeyD | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → t.isEmpty = false → ∀ {fallback : α}, Std.DTreeMap.Internal.Impl.contains (t.minKeyD fallback) t = true | null | true |
_aux_Mathlib_Algebra_Order_Module_PositiveLinearMap___unexpand_PositiveLinearMap_1 | Mathlib.Algebra.Order.Module.PositiveLinearMap | Lean.PrettyPrinter.Unexpander | null | false |
TestFunction.mkCLM._proof_2 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace ℝ F] [inst_3 : NormedSpace 𝕜 F] [inst_4 : Algebra ℝ 𝕜] [IsScalarTower ℝ 𝕜 F],
SMulCommClass ℝ 𝕜 F | null | false |
Std.HashSet.Raw.getD_filter | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α]
{f : α → Bool} {k fallback : α},
m.WF → (Std.HashSet.Raw.filter f m).getD k fallback = (Option.filter f (m.get? k)).getD fallback | null | true |
_private.Init.Data.Range.Polymorphic.Char.0.Char.map._proof_1 | Init.Data.Range.Polymorphic.Char | ∀ (a : Char), a.ordinal.addNat? 1 = Option.map Char.ordinal (Std.PRange.succ? a) | null | false |
Lean.Lsp.TextDocumentChangeRegistrationOptions.mk | Lean.Data.Lsp.TextSync | Option Lean.Lsp.DocumentSelector → Lean.Lsp.TextDocumentSyncKind → Lean.Lsp.TextDocumentChangeRegistrationOptions | null | true |
EckmannHilton.AddZeroClass.IsUnital | Mathlib.GroupTheory.EckmannHilton | ∀ {X : Type u} [_G : AddZeroClass X], EckmannHilton.IsUnital (fun x1 x2 => x1 + x2) 0 | null | true |
MulRingSeminorm.mk.injEq | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : NonAssocRing R] (toAddGroupSeminorm : AddGroupSeminorm R)
(map_one' : toAddGroupSeminorm.toFun 1 = 1)
(map_mul' : ∀ (x y : R), toAddGroupSeminorm.toFun (x * y) = toAddGroupSeminorm.toFun x * toAddGroupSeminorm.toFun y)
(toAddGroupSeminorm_1 : AddGroupSeminorm R) (map_one'_1 : toAddGroupSe... | null | true |
Setoid.IsPartition.ncard_eq_finsum._auto_1 | Mathlib.Order.Setoid.Partition.Card | Lean.Syntax | null | false |
tsub_le_self | Mathlib.Algebra.Order.Sub.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] [inst_3 : Sub α]
[OrderedSub α] {a b : α}, a - b ≤ a | null | true |
LaurentPolynomial.smul_eq_C_mul | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (r : R) (f : LaurentPolynomial R), r • f = LaurentPolynomial.C r * f | null | true |
OrderDual.instRing._proof_3 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : Ring R],
autoParam (∀ (n : ℕ) (a : Rᵒᵈ), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
CategoryTheory.Limits.HasLimitsOfShape.has_limit._autoParam | Mathlib.CategoryTheory.Limits.HasLimits | Lean.Syntax | null | false |
DirectSum.sigmaLcurry_apply | Mathlib.Algebra.DirectSum.Module | ∀ (R : Type u) [inst : Semiring R] {ι : Type v} {α : ι → Type u_1} {δ : (i : ι) → α i → Type w} [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)] [inst_3 : (i : ι) → (j : α i) → Module R (δ i j)]
(f : DirectSum ((x : ι) × α x) fun i => δ i.fst i.snd) (i : ι) (j : α i),
(((DirectSum.s... | null | true |
UInt8.le_trans | Init.Data.UInt.Lemmas | ∀ {a b c : UInt8}, a ≤ b → b ≤ c → a ≤ c | null | true |
ValuationRing.commGroupWithZero._proof_3 | Mathlib.RingTheory.Valuation.ValuationRing | ∀ (A : Type u_1) [inst : CommRing A] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra A K]
(a : ValuationRing.ValueGroup A K), a * 1 = a | null | false |
LinearEquiv.baseChange_one | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_4) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M], LinearEquiv.baseChange R A M M 1 = 1 | null | true |
SSet.Truncated.Edge.id_tensor_id | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ {X Y : SSet.Truncated 2}
(x : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge.tensor._proof_1 }))
(y : Y.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge.tensor._proof_1 })),
(SSet.Truncated.Edge.id x).tensor (SSet.Truncated.Edge.id y) = SSet.Truncated.Edge.id (x... | null | true |
Sum.Lex.denselyOrdered_of_noMinOrder | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] [DenselyOrdered α] [DenselyOrdered β] [NoMinOrder β],
DenselyOrdered (α ⊕ₗ β) | null | true |
ProjectiveSpectrum.not_irrelevant_le | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] (self : ProjectiveSpectrum 𝒜), ¬HomogeneousIdeal.irrelevant 𝒜 ≤ self.asHomogeneousIdeal | null | true |
Seminorm.absorbent_closedBall_zero | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedDivisionRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(p : Seminorm 𝕜 E) {r : ℝ}, 0 < r → Absorbent 𝕜 (p.closedBall 0 r) | Closed seminorm-balls at the origin are absorbent. | true |
CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f}
{cc' : CategoryTheory.Limits.CokernelCofork f'} (hf : CategoryTheory.Limits.IsColimit cc)
(hf' : CategoryTheor... | null | true |
Std.Iter.anyM_filterMapM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad m]
[inst_3 : MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] {it : Std.Iter β} {f : β → m (Option β')}
{p : β' → m (ULift.{w, 0} Bool)},
Std.IterM.anyM p (Std.Iter.filterMapM f it) =
... | null | true |
List.mapIdxMAux'_eq_mapIdxMGo | Mathlib.Data.List.Indexes | ∀ {m : Type u → Type v} [inst : Monad m] [LawfulMonad m] {α : Type u_1} (f : ℕ → α → m PUnit.{u + 1}) (as : List α)
(arr : Array PUnit.{u + 1}), List.mapIdxMAux' f arr.size as = List.mapIdxM.go f as arr *> pure PUnit.unit | null | true |
AlgEquiv.funUnique_apply | Mathlib.Algebra.Algebra.Pi | ∀ {R : Type u_3} {ι : Type u_4} [inst : CommSemiring R] (S : Type u_8) [inst_1 : Semiring S] [inst_2 : Algebra R S]
[inst_3 : Unique ι] (x : ι → S), (AlgEquiv.funUnique R ι S) x = (Equiv.funUnique ι S) x | null | true |
_private.Batteries.Data.List.Basic.0.List.zipWithLeftTR.go._unsafe_rec | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (α → Option β → γ) → List α → List β → Array γ → List γ | null | false |
PiTensorProduct.map_pow | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (f : (i : ι) → s i →ₗ[R] s i) (n : ℕ),
PiTensorProduct.map (f ^ n) = PiTensorProduct.map f ^ n | null | true |
SimpleGraph.mulCayley_inv | Mathlib.Combinatorics.SimpleGraph.Cayley | ∀ {M : Type u_1} (s : Set M) [inst : Group M], SimpleGraph.mulCayley s⁻¹ = SimpleGraph.mulCayley s | null | true |
BesselPotentialSpace.toDistr_neg | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : CompleteSpace F] [inst_7 : NormedSpace ℂ F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)]
(f : ... | null | true |
Std.Time.instDecidableEqPlainDateTime.decEq | Std.Time.DateTime.PlainDateTime | (x x_1 : Std.Time.PlainDateTime) → Decidable (x = x_1) | null | true |
AddOreLocalization.sub_eq_zero | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {s : ↥S},
↑s -ₒ s = 0 | null | true |
Measurable.inf | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {f g : α → M} [inst_1 : Min M]
[MeasurableInf₂ M], Measurable f → Measurable g → Measurable (f ⊓ g) | null | true |
Fin.sum_univ_eight | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] (f : Fin 8 → M), ∑ i, f i = f 0 + f 1 + f 2 + f 3 + f 4 + f 5 + f 6 + f 7 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_inter_eq_size_right._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Matrix.sum_row_of_mem_rowStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {M : Matrix n n R},
M ∈ Matrix.rowStochastic R n → ∀ (i : n), ∑ j, M i j = 1 | Each row sum of a row stochastic matrix is 1. | true |
Lex.instGroupWithZero._proof_4 | Mathlib.Algebra.Order.GroupWithZero.Synonym | ∀ {α : Type u_1} [inst : GroupWithZero α],
autoParam (∀ (n : ℕ) (a : Lex α), a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹) DivInvMonoid.zpow_neg'._autoParam | null | false |
IsLocalMin.hasFDerivAt_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.Basic | ∀ {E : Type u} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {f' : StrongDual ℝ E} {a : E},
IsLocalMin f a → HasFDerivAt f f' a → f' = 0 | **Fermat's Theorem**: the derivative of a function at a local minimum equals zero. | true |
instProperSpaceSubtypeMemSubmoduleOfCompleteSpaceOfLocallyCompactSpace | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] [LocallyCompactSpace E] (S : Submodule 𝕜 E), ProperSpace ↥S | A submodule of a locally compact space over a complete field is also locally compact (and even
proper). | true |
Lean.bignumToJson | Lean.Data.Json.FromToJson.Basic | ℕ → Lean.Json | null | true |
Bool.cond_else_not_self | Init.Data.Bool | ∀ (c b : Bool), (bif c then b else !c) = (!c || b) | null | true |
FiniteMultiplicity.not_dvd_of_one_right | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a : α}, FiniteMultiplicity a 1 → ¬a ∣ 1 | null | true |
PiTensorProduct.liftEquiv._proof_3 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] (𝕜 : Type u_4) (E : ι → Type u_2) [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)] (F : Type u_3)
[inst_4 : SeminormedAddCommGroup F] [inst_5 : NormedSpace 𝕜 F] (f : ContinuousMultilinearMap 𝕜 E F... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.FrullaniIntegral.0.Frullani.tendsto_integral_inv_smul_atTop._simp_1_5 | Mathlib.Analysis.SpecialFunctions.FrullaniIntegral | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Lean.Util.CollectMVars.0.Lean.CollectMVars.main._sparseCasesOn_1 | Lean.Util.CollectMVars | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderNam... | null | false |
List.unzip._f | Init.Data.List.Basic | {α : Type u} → {β : Type v} → (x : List (α × β)) → List.below x → List α × List β | null | false |
String.push_inj | Init.Data.String.Lemmas.Basic | ∀ {s : String} {c : Char} {t : String} {d : Char}, s.push c = t.push d ↔ s = t ∧ c = d | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.visitCases.match_13 | Lean.Compiler.LCNF.ToLCNF | (motive : Option (Lean.CasesAltInfo × Subarray Lean.CasesAltInfo) → Sort u_1) →
(x : Option (Lean.CasesAltInfo × Subarray Lean.CasesAltInfo)) →
(Unit → motive none) →
((numParams : Lean.CasesAltInfo) → (s' : Subarray Lean.CasesAltInfo) → motive (some (numParams, s'))) → motive x | null | false |
Lean.Compiler.InlineAttributeKind.macroInline.sizeOf_spec | Lean.Compiler.InlineAttrs | sizeOf Lean.Compiler.InlineAttributeKind.macroInline = 1 | null | true |
CategoryTheory.FreeBicategory.Rel.brecOn | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B]
{motive :
{a b : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g) → CategoryTheory.FreeBicategory.Rel a_1 a_2 → Prop}
{a b : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} {a_1 a_2 : CategoryTheory.FreeBicategory... | null | true |
Bool.cond_true_right | Init.Data.Bool | ∀ (c t : Bool), (bif c then t else true) = (!c || t) | null | true |
_private.Mathlib.Order.Bounds.Image.0.bddAbove_prod.match_1_1 | Mathlib.Order.Bounds.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set (α × β)} (motive : BddAbove s → Prop)
(x : BddAbove s), (∀ (p : α × β) (hp : p ∈ upperBounds s), motive ⋯) → motive x | null | false |
NormedAddGroupHom.Equalizer.liftEquiv_apply | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ : { φ // f.comp φ = g.comp φ }),
NormedAddGroupHom.Equalizer.liftEquiv φ = NormedAddGroupHom.Equalizer.lift ↑φ ⋯ | null | true |
instCanLiftAddUnitsValIsAddUnit | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M], CanLift M (AddUnits M) AddUnits.val IsAddUnit | null | true |
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.TendstoLocallyUniformlyOn.deriv._simp_1_1 | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {α : Type u} {p : α → Prop}, (∀ᶠ (x : α) in ⊥, p x) = True | null | false |
_private.Lean.Compiler.LCNF.Simp.DiscrM.0.Lean.Compiler.LCNF.Simp.getIndInfo?._sparseCasesOn_4 | Lean.Compiler.LCNF.Simp.DiscrM | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
(Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Functor.sheafPushforwardContinuousComp_inv_app_hom_app | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) (A : Type u) [inst_3 : CategoryTheory.Category.{t, u} A]
(J : Catego... | null | true |
AlgebraicClosure.Monics.splits_finsetProd | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ {k : Type u} [inst : Field k] {s : Finset (AlgebraicClosure.Monics k)} {f : AlgebraicClosure.Monics k},
f ∈ s → (Polynomial.map (algebraMap k (∏ f ∈ s, ↑f).SplittingField) ↑f).Splits | null | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.upperSemicontinuousAt_inv_iff._simp_1_2 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β} {x : α},
UpperSemicontinuousAt f x = UpperSemicontinuousWithinAt f Set.univ x | null | false |
Mathlib.PrintSorries.State.sorryMsgs | Mathlib.Util.PrintSorries | Mathlib.PrintSorries.State → Array Lean.MessageData | The uses of `sorry` that were found. | true |
Orientation.rotation_eq_self_iff | 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) (θ : Real.Angle), (o.rotation θ) x = x ↔ x = 0 ∨ θ = 0 | A rotation of a vector equals that vector if and only if the vector or the angle is zero. | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.pushArgsTodo._sunfold | Lean.Meta.Sym.Simp.DiscrTree | Array Lean.Expr → Lean.Expr → Array Lean.Expr | null | false |
IsNilpotent.smul | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : MonoidWithZero R] [inst_1 : MonoidWithZero S] [inst_2 : MulActionWithZero R S]
[SMulCommClass R S S] [IsScalarTower R S S] {a : S}, IsNilpotent a → ∀ (t : R), IsNilpotent (t • a) | null | true |
continuousSubgroup.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Group β]
[inst_3 : IsTopologicalGroup β], continuousSubgroup α β = { toSubmonoid := continuousSubmonoid α β, inv_mem' := ⋯ } | null | true |
RegularExpression.noConfusionType | Mathlib.Computability.RegularExpressions | Sort u_1 → {α : Type u} → RegularExpression α → {α' : Type u} → RegularExpression α' → Sort u_1 | null | false |
IsDedekindDomain.HeightOneSpectrum.instFaithfulSMulSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
FaithfulSMul (↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v))
(IsDedekindDomain.HeightOneSpectru... | null | true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.Measure.withDensity.instSFinite._simp_1 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → ∀ (f : α → ENNReal), (μ.restrict s).withDensity f = (μ.withDensity f).restrict s | null | false |
not_or_of_imp | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (a → b) → ¬a ∨ b | null | true |
RootPairing.Base.exists_cartanMatrix_mul_diagaonal_posDef | Mathlib.LinearAlgebra.RootSystem.CartanMatrix | ∀ {ι : 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} (b : P.Base)
[inst_5 : P.IsCrystallographic] [CharZero R] [IsDomain R] [Finite ι] [inst_9 : DecidableEq ι] [P.Is... | null | true |
MonoidAlgebra.domCongr_refl | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Monoid M], MonoidAlgebra.domCongr R A (MulEquiv.refl M) = AlgEquiv.refl | null | true |
CategoryTheory.AddGrp.instInhabited.eq_1 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.AddGrp.instInhabited = { default := CategoryTheory.AddGrp.trivial C } | null | true |
Cardinal.ofENat_le_nat | Mathlib.SetTheory.Cardinal.ENat | ∀ {m : ℕ∞} {n : ℕ}, ↑m ≤ ↑n ↔ m ≤ ↑n | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_comp_equiv._simp_1_3 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
Submodule.inf_orthogonal | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K₁ K₂ : Submodule 𝕜 E), K₁ᗮ ⊓ K₂ᗮ = (K₁ ⊔ K₂)ᗮ | The inf of two orthogonal subspaces equals the subspace orthogonal
to the sup. | true |
Ordinal.nfp_monotone | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ {f : Ordinal.{u} → Ordinal.{u}}, Monotone f → Monotone (Ordinal.nfp f) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.not_continuousAt_deriv_qaryEntropy_zero._simp_1_2 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_1} [inst : LE α] [NoTopOrder α] (a : α), IsTop a = False | null | false |
CircleDeg1Lift.map_lt_of_translationNumber_lt_nat | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {n : ℕ}, f.translationNumber < ↑n → ∀ (x : ℝ), f x < x + ↑n | null | true |
Polynomial.support_ofFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), { toFinsupp := p }.support = p.coeff.support | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.isAtom_smul_finset._simp_1 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A S : Finset G} {a : G},
Finset.IsAtom✝ K S (a • A) = Finset.IsAtom✝ K S A | null | false |
BitVec.getElem_one | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ} (h : i < w), (1#w)[i] = decide (i = 0) | null | true |
_private.Mathlib.Tactic.Echelon.Reflection.0.Mathlib.Tactic.Echelon.getD_of_isPivotedList._proof_1_19 | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} {n : ℕ} [inst : Zero α] {k : Fin n} {row : List α} {rows : List (List α)} {d : α} {suffix : List α},
row = List.replicate (↑k) 0 ++ d :: suffix →
↑k + 1 ≤ ((row :: rows).getD 0 []).length →
¬↑k + 1 ≤ (List.replicate (↑k) 0).length → ↑k - (List.replicate (↑k) 0).length < (d :: suffix).length | null | false |
MonoidHom.fromOpposite._proof_1 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N), f 1 = 1 | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic.0.Tactic.ComputeAsymptotics.UnitMonomial.isLittleO_of_lt._simp_1_9 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.