name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CommMonCat.forget₂CreatesLimit._proof_11 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommMonCat)).sections]
(x : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget₂ CommMonCat MonCat).map
{
hom' :=
{
... | null | false |
MonCat.Colimits.descFunLift.eq_3 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{u, v} J] (F : CategoryTheory.Functor J MonCat)
(s : CategoryTheory.Limits.Cocone F) (x_1 y : MonCat.Colimits.Prequotient F),
MonCat.Colimits.descFunLift F s (x_1.mul y) = MonCat.Colimits.descFunLift F s x_1 * MonCat.Colimits.descFunLift F s y | null | true |
_private.Mathlib.Algebra.Group.Finsupp.0.Finsupp.addCommute_of_disjoint._simp_1_2 | Mathlib.Algebra.Group.Finsupp | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, Disjoint s t = (s ∩ t = ∅) | null | false |
String.Slice.apply_skipPrefixWhile_bool_eq_false | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String.Slice} {h : s.skipPrefixWhile p ≠ s.endPos}, p ((s.skipPrefixWhile p).get h) = false | null | true |
_private.Mathlib.Algebra.Category.CommAlgCat.Basic.0.CommAlgCat.mk._flat_ctor | Mathlib.Algebra.Category.CommAlgCat.Basic | {R : Type u} →
[inst : CommRing R] →
(carrier : Type v) → [commRing : CommRing carrier] → [algebra : Algebra R carrier] → CommAlgCat R | null | false |
CategoryTheory.Sieve.essSurjFullFunctorGaloisInsertion | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.EssSurj] →
[F.Full] →
(X : C) →
GaloisInsertion (CategoryTheory.Sieve.functorPushfor... | When `F` is essentially surjective and full, the Galois connection is a Galois insertion. | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.getParamType | Lean.Elab.App | Lean.Elab.Term.ElabAppArgs.M Lean.Expr | Returns the current parameter's type.
Only valid if `fTypeIsForall` has returned `true`.
| true |
extChartAt_target_eventuallyEq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x)... | Around a point in the target, `(extChartAt I x).target` and `range I` coincide locally. | true |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.List.filter.match_1.eq_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | null | true |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.expand.go.induct | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α]
(motive : ℕ → Array (Std.DHashMap.Internal.AssocList α β) → { d // 0 < d.size } → Prop),
(∀ (i : ℕ) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size })
(h : i < source.size),
have es := source[i];
have source_1 :... | null | true |
ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl.congr_simp | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : CompleteSpace E] [inst_8 : ... | null | true |
Std.Sat.AIG.RelabelNat.State.noConfusionType | Std.Sat.AIG.RelabelNat | Sort u →
{α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{decls : Array (Std.Sat.AIG.Decl α)} →
{idx : ℕ} →
Std.Sat.AIG.RelabelNat.State α decls idx →
{α' : Type} →
[inst' : DecidableEq α'] →
[inst'_1 : Hashable α'] ... | null | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.AssocList.foldrM.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldrM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← Std.DHashMap.Internal.Ass... | null | true |
Mathlib.Notation3.mkFoldlMatcher | Mathlib.Util.Notation3 | Lean.Name →
Lean.Name →
Lean.Name →
Lean.Term →
Lean.Term → Array Lean.Name → OptionT Lean.Elab.TermElabM (List Mathlib.Notation3.DelabKey × Lean.Term) | Create a `Term` that represents a matcher for `foldl` notation.
Reminder: `( lit ","* => foldl (x y => scopedTerm) init)` | true |
_private.Lean.Compiler.CSimpAttr.0.Lean.Compiler.CSimp.isConstantReplacement?._sparseCasesOn_1 | Lean.Compiler.CSimpAttr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
algebraMap_comp_natCast | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_2) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⇑(algebraMap R A) ∘ Nat.cast = Nat.cast | null | true |
ArchimedeanClass.stdPart_eq_sSup | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] (f : ℝ →+*o K) (x : K),
ArchimedeanClass.stdPart x = sSup {r | f r < x} | null | true |
WellFounded.Nat.fix.go.congr_simp | Init.WF | ∀ {α : Sort u} {motive : α → Sort v} (h : α → ℕ)
(F F_1 : (x : α) → ((y : α) → InvImage (fun x1 x2 => x1 < x2) h y x → motive y) → motive x),
F = F_1 →
∀ (fuel fuel_1 : ℕ) (e_fuel : fuel = fuel_1) (x : α) (a : h x < fuel),
WellFounded.Nat.fix.go h F fuel x a = WellFounded.Nat.fix.go h F_1 fuel_1 x ⋯ | null | true |
hasSum_nat_jacobiTheta | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {τ : ℂ}, 0 < τ.im → HasSum (fun n => Complex.exp (↑Real.pi * Complex.I * (↑n + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2) | null | true |
Std.Sat.AIG.denote_idx_gate | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {assign : α → Bool} {invert : Bool}
{lhs rhs : Std.Sat.AIG.Fanin} {aig : Std.Sat.AIG α} {hstart : start < aig.decls.size}
(h : aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs),
⟦assign, { aig := aig, ref := { gate := start, invert := invert, h... | If an index contains a `Decl.gate` we know how to denote it.
| true |
Fintype.prod_empty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : Fintype ι] [inst_1 : CommMonoid M] [IsEmpty ι] (f : ι → M), ∏ x, f x = 1 | null | true |
instAddCommMonoidFormalMultilinearSeries._proof_6 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : AddCommMonoid F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : ContinuousAdd F] (a b : (i : ℕ) → E [×i]→L[𝕜] F), a + b = b + a | null | false |
CategoryTheory.Limits.WidePushout.head | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{B : C} →
{objs : J → C} →
(arrows : (j : J) → B ⟶ objs j) →
[inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] →
B ⟶ CategoryTheory.Limits.widePushout B objs arrows | The unique map from the head to the pushout. | true |
BooleanSubalgebra.mem_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {f : BoundedLatticeHom α β}
{a : α} {L : BooleanSubalgebra β}, a ∈ BooleanSubalgebra.comap f L ↔ f a ∈ L | null | true |
TopologicalSpace.DiscreteTopology.metrizableSpace | Mathlib.Topology.Metrizable.Basic | ∀ {X : Type u_2} [inst : TopologicalSpace X] [DiscreteTopology X], TopologicalSpace.MetrizableSpace X | null | true |
CategoryTheory.Limits.isLimitOfHasBinaryProductOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] →
[CategoryTheory.Limits.PreservesLim... | If `G` preserves binary products and `C` has them, then the binary fan constructed of the mapped
morphisms of the binary product cone is a limit.
| true |
Real.fourierIntegralInv_comp_linearIsometry | Mathlib.Analysis.Fourier.FourierTransform | ∀ {V : Type u_1} {W : Type u_2} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E]
[inst_2 : NormedAddCommGroup V] [inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V]
[inst_6 : NormedAddCommGroup W] [inst_7 : InnerProductSpace ℝ W] [inst_8 : MeasurableSpace W] ... | **Alias** of `Real.fourierInv_comp_linearIsometry`. | true |
Std.TreeSet.get!_insertMany_list_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α}
{k : α}, k ∈ t → (t.insertMany l).get! k = t.get! k | null | true |
Int.gcd_sub_right_right_of_dvd | Init.Data.Int.Gcd | ∀ {n k : ℤ} (m : ℤ), n ∣ k → n.gcd (m - k) = n.gcd m | null | true |
CategoryTheory.ShortComplex.Splitting.mk._flat_ctor | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S : CategoryTheory.ShortComplex C} →
(r : S.X₂ ⟶ S.X₁) →
(s : S.X₃ ⟶ S.X₂) →
autoParam (CategoryTheory.CategoryStruct.comp S.f r = CategoryTheory.CategoryStruct.id S.X₁)
... | null | false |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'._simp_1_6 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {α : Type u} [inst : Monoid α] (b : αˣ) {a c : α}, (↑b * a = c) = (a = ↑b⁻¹ * c) | null | false |
Representation.coinvariantsToFinsupp._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_3} {G : Type u_4} {V : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (α : Type u_2) (x : G),
Finsupp.mapRange.linearMap (Representation.Coinvariants.mk ρ) ∘ₗ (ρ.finsupp α) x =
Finsupp.mapRange.linearMap (Representation.C... | null | false |
_private.Mathlib.MeasureTheory.Function.ConditionalLExpectation.0.MeasureTheory.measurable_condLExp'._simp_1_1 | Mathlib.MeasureTheory.Function.ConditionalLExpectation | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [inst_2 : Zero α],
Measurable 0 = True | null | false |
TypeCat.Hom.hom | Mathlib.CategoryTheory.Types.Basic | {X Y : Type u} → TypeCat.Hom X Y → TypeCat.Fun X Y | Turn a morphism in `Type` back into a function. | true |
Mathlib.Tactic.ITauto.Proof.orImpL.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orImpL = 1 + sizeOf p | null | true |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.exists_mem_of_isBasis._simp_1_8 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Subalgebra.algebraicClosure | Mathlib.RingTheory.Algebraic.Integral | (R : Type u_1) →
(S : Type u_2) → [inst : CommRing R] → [inst_1 : CommRing S] → [inst_2 : Algebra R S] → [IsDomain R] → Subalgebra R S | If `R` is a domain and `S` is an arbitrary `R`-algebra, then the elements of `S`
that are algebraic over `R` form a subalgebra. | true |
Dense.eq_of_inner_right | Mathlib.Analysis.InnerProductSpace.Continuous | ∀ {E : Type u_4} (𝕜 : Type u_7) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E} {S : Set E}, Dense S → (∀ v ∈ S, inner 𝕜 v x = inner 𝕜 v y) → x = y | null | true |
iteratedDerivWithin_add | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜} {s : Set 𝕜},
x ∈ s →
UniqueDiffOn 𝕜 s →
∀ {f g : 𝕜 → F},
ContDiffWithinAt 𝕜 (↑n) f s x →
ContDiffWithinAt 𝕜 (↑n) g s x →
iter... | null | true |
Submodule.orthogonal_disjoint | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E), Disjoint K Kᗮ | `K` and `Kᗮ` have trivial intersection. | true |
MeasureTheory.lintegral_def | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
MeasureTheory.lintegral μ f = ⨆ g, ⨆ (_ : ⇑g ≤ f), g.lintegral μ | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMultispan.functorExt.match_1.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (motive : CategoryTheory.Limits.WalkingMultispan J → Sort u_3) (i : J.L)
(h_1 : (i : J.L) → motive (CategoryTheory.Limits.WalkingMultispan.left i))
(h_2 : (i : J.R) → motive (CategoryTheory.Limits.WalkingMultispan.right i)),
(match CategoryTheory.Limits.WalkingMultispa... | null | true |
Polynomial.Splits.X_pow | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (Polynomial.X ^ n).Splits | null | true |
ENNReal.continuousAt_const_mul | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {a b : ENNReal}, a ≠ ⊤ ∨ b ≠ 0 → ContinuousAt (fun x => a * x) b | null | true |
CategoryTheory.ComposableArrows.homMk₅_app_three | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_450✝ ⟶ g.obj' 0 _proof_450✝) (app₁ : f.obj' 1 _proof_451✝ ⟶ g.obj' 1 _proof_451✝)
(app₂ : f.obj' 2 _proof_452✝ ⟶ g.obj' 2 _proof_452✝) (app₃ : f.obj' 3 _proof_453✝ ⟶ g.obj' 3 _proof_453... | null | true |
BitVec.reverse.eq_1 | Init.Data.BitVec.Lemmas | ∀ (x_2 : BitVec 0), x_2.reverse = x_2 | null | true |
WithTop.coe_sInf._simp_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α},
s.Nonempty → BddBelow s → ⨅ a ∈ s, ↑a = ↑(sInf s) | null | false |
DirectSum.Decomposition.mk.noConfusion | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
{inst : DecidableEq ι} →
{inst_1 : AddCommMonoid M} →
{inst_2 : SetLike σ M} →
{inst_3 : AddSubmonoidClass σ M} →
{ℳ : ι → σ} →
{P : Sort u} →
{decompose' : M → DirectSum ι fun i ... | null | false |
SemistandardYoungTableau.casesOn | Mathlib.Combinatorics.Young.SemistandardTableau | {μ : YoungDiagram} →
{motive : SemistandardYoungTableau μ → Sort u} →
(t : SemistandardYoungTableau μ) →
((entry : ℕ → ℕ → ℕ) →
(row_weak' : ∀ {i j1 j2 : ℕ}, j1 < j2 → (i, j2) ∈ μ → entry i j1 ≤ entry i j2) →
(col_strict' : ∀ {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → entry i1 j < entry i2... | null | false |
Real.sinh_eq_tsum | Mathlib.Analysis.SpecialFunctions.Trigonometric.Series | ∀ (r : ℝ), Real.sinh r = ∑' (n : ℕ), r ^ (2 * n + 1) / ↑(2 * n + 1).factorial | null | true |
CategoryTheory.InducedWideCategory.Hom.mk.congr_simp | Mathlib.CategoryTheory.Widesubcategory | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} D] {F : C → D}
{P : CategoryTheory.MorphismProperty D} [inst_1 : P.IsMultiplicative] {X Y : CategoryTheory.InducedWideCategory D F P}
(hom hom_1 : F X ⟶ F Y) (e_hom : hom = hom_1) (property : P hom),
{ hom := hom, property := property } = { ho... | null | true |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_1 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
{x : ↥S}, (x = 0) = (↑x = 0) | null | false |
intervalIntegral.FTCFilter.le_nhds | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {a : outParam ℝ} (outer : Filter ℝ) {inner : outParam (Filter ℝ)} [self : intervalIntegral.FTCFilter a outer inner],
inner ≤ nhds a | null | true |
CategoryTheory.MonoidalCategory.«term𝟙__» | Mathlib.CategoryTheory.Monoidal.Category | Lean.ParserDescr | Notation for `tensorUnit`, the two-sided identity of `⊗` | true |
Mathlib.Meta.Positivity.evalNNRealSqrt | Mathlib.Analysis.Real.Sqrt | Mathlib.Meta.Positivity.PositivityExt | Extension for the `positivity` tactic: a square root of a strictly positive nonnegative real is
positive. | true |
Submonoid.units._proof_2 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ},
x ∈ (Submonoid.comap (Units.coeHom M) S ⊓ (Submonoid.comap (Units.coeHom M) S)⁻¹).carrier →
x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S) ∧ x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S)⁻¹ | null | false |
Turing.ListBlank.tail_cons | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (a : Γ) (l : Turing.ListBlank Γ), (Turing.ListBlank.cons a l).tail = l | null | true |
Order.isPredLimitRecOn_pred_of_not_isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : LinearOrder α] [inst_1 : PredOrder α]
(isMax : (a : α) → IsMax a → motive a) (pred : (a : α) → ¬IsMin a → motive (Order.pred a))
(isPredLimit : (a : α) → Order.IsPredLimit a → motive a) (hb : ¬IsMin b),
Order.isPredLimitRecOn (Order.pred b) isMax pred isPre... | null | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.initFn._@.Mathlib.Tactic.Translate.Core.1162112896._hygCtx._hyg.2 | Mathlib.Tactic.Translate.Core | IO Unit | null | false |
CategoryTheory.ObjectProperty.isSeparating_unop_iff | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
P.unop.IsSeparating ↔ P.IsCoseparating | null | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Gaps.0.Finset.sum_eq_sum_range_intervalGapsWithin._proof_1_5 | Mathlib.Algebra.BigOperators.Group.Finset.Gaps | ∀ {k : ℕ}, ∀ i ∈ Set.Iio k, i ∈ Finset.range k | null | false |
Std.DTreeMap.Internal.Impl.get?ₘ_eq_getValueCast? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : Std.LawfulEqOrd α] [inst_3 : BEq α]
[inst_4 : Std.LawfulBEqOrd α] {k : α} {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get?ₘ k = Std.Internal.List.getValueCast? k t.toListModel | null | true |
CategoryTheory.MorphismProperty.IsLocalAtTarget.mk_of_small | Mathlib.CategoryTheory.MorphismProperty.Local | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
{K : CategoryTheory.Precoverage C} [inst_1 : K.HasPullbacks] [P.RespectsIso] [K.Small],
(∀ {X Y : C} {f : X ⟶ Y} (𝒰 : K.ZeroHypercover Y),
P f → ∀ (i : 𝒰.I₀), P (CategoryTheory.Limits.pullback.snd f (𝒰.f i))) →... | null | true |
MeasureTheory.SignedMeasure.null_of_totalVariation_zero | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α) {i : Set α},
s.totalVariation i = 0 → ↑s i = 0 | null | true |
ContinuousLinearMap.completion._proof_4 | Mathlib.Topology.Algebra.LinearMapCompletion | ∀ {α : Type u_1} {β : Type u_2} {R₁ : Type u_3} {R₂ : Type u_4} [inst : UniformSpace α] [inst_1 : AddCommGroup α]
[inst_2 : IsUniformAddGroup α] [inst_3 : Semiring R₁] [inst_4 : Module R₁ α] [inst_5 : Semiring R₂]
[inst_6 : UniformSpace β] [inst_7 : AddCommGroup β] [inst_8 : IsUniformAddGroup β] [inst_9 : Module R₂... | null | false |
LinearGrowth.le_linearGrowthSup_iff | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {u : ℕ → EReal} {a : EReal}, a ≤ LinearGrowth.linearGrowthSup u ↔ ∀ b < a, ∃ᶠ (n : ℕ) in Filter.atTop, b * ↑n ≤ u n | null | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_right_ι | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObjec... | null | true |
Lean.Meta.Tactic.Backtrack.BacktrackConfig.discharge._default | Lean.Meta.Tactic.Backtrack | Lean.MVarId → Lean.MetaM (Option (List Lean.MVarId)) | null | false |
Module.Free.chooseBasis._proof_1 | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M], Nonempty (Module.Basis (↑⋯.choose) R M) | null | false |
_private.Std.Data.ExtTreeMap.Lemmas.0.Std.ExtTreeMap.alter_eq_empty_iff._simp_1_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t t' : Std.ExtTreeMap α β cmp}, (t = t') = (t.inner = t'.inner) | null | false |
_private.Mathlib.Control.Basic.0.map_seq._simp_1_1 | Mathlib.Control.Basic | ∀ {f : Type u → Type v} {inst : Applicative f} [self : LawfulApplicative f] {α β : Type u} (g : α → β) (x : f α),
g <$> x = pure g <*> x | null | false |
_private.Mathlib.Tactic.ToFun.0.Mathlib.Tactic.toFunImpl.match_3 | Mathlib.Tactic.ToFun | (motive : Option (Lean.TSyntax `ident) → Sort u_1) →
(id : Option (Lean.TSyntax `ident)) →
((id : Lean.TSyntax `ident) → motive (some id)) → ((x : Option (Lean.TSyntax `ident)) → motive x) → motive id | null | false |
Numbering.prefixedEquiv._proof_14 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X), ∀ x ∉ s, x ∈ sᶜ | null | false |
Order.IsSuccLimit.sSup_Iio | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrderBot α] {x : α}, Order.IsSuccLimit x → sSup (Set.Iio x) = x | null | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.isUnit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} →
{β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → β → Option (Std.Sat.Literal α) | null | true |
IsLocalizedModule.commonDenom | Mathlib.Algebra.Module.LocalizedModule.Int | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{M' : Type u_3} →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M'] →
(f : M →ₗ[R] M') → [IsLo... | A choice of a common multiple of the denominators of a `Finset`-indexed family of fractions. | true |
Affine.Simplex.excenterWeights_compl | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.excenterWeights signsᶜ = s.excenterWeights signs | null | true |
TensorPower.gMul._proof_4 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {i j : ℕ},
IsScalarTower R R (PiTensorProduct R fun i => M) | null | false |
Set.instFintypeIio.eq_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Set.instFintypeIio a = Fintype.ofFinset (Finset.Iio a) ⋯ | null | true |
AntivaryOn.empty | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {f : ι → α} {g : ι → β},
AntivaryOn f g ∅ | null | true |
_private.Mathlib.NumberTheory.SumFourSquares.0.Int.sq_add_sq_of_two_mul_sq_add_sq._simp_1_1 | Mathlib.NumberTheory.SumFourSquares | ∀ {α : Type u_2} [inst : Semiring α] {a : α}, (2 ∣ a) = Even a | null | false |
Representation.Coinvariants.hom_ext_iff | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommRing k] [inst_1 : Monoid G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
{ρ : Representation k G V} {f g : ρ.Coinvariants →ₗ[k] W},
f = g ↔ f ∘ₗ Representation.Coinvariants.mk ρ = g ∘ₗ Repr... | null | true |
ValuativeRel.IsRankLeOne.mk | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R],
Nonempty (ValuativeRel.RankLeOneStruct R) → ValuativeRel.IsRankLeOne R | null | true |
CategoryTheory.Limits.initialMonoClass_of_coproductsDisjoint | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.BinaryCoproductsDisjoint C],
CategoryTheory.Limits.InitialMonoClass C | If `C` has disjoint coproducts, any morphism out of initial is mono. Note it isn't true in
general that `C` has strict initial objects, for instance consider the category of types and
partial functions. | true |
DifferentiableOn.sub_iff_left._simp_2 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{s : Set E}, DifferentiableOn 𝕜 g s → DifferentiableOn 𝕜 (f - g) s = DifferentiableOn 𝕜 f s | null | false |
BitVec.noConfusionType | Init.Prelude | Sort u → {w : ℕ} → BitVec w → {w' : ℕ} → BitVec w' → Sort u | null | false |
Function.Antiperiodic.funext' | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Add α] [inst_1 : InvolutiveNeg β],
Function.Antiperiodic f c → (fun x => -f (x + c)) = f | null | true |
SimpleGraph.IsCompleteBetween.disjoint | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {s t : Set V}, G.IsCompleteBetween s t → Disjoint s t | null | true |
BialgCat.category | Mathlib.Algebra.Category.BialgCat.Basic | {R : Type u} → [inst : CommRing R] → CategoryTheory.Category.{v, max (v + 1) u} (BialgCat R) | null | true |
Array.getElem?_zip_eq_some | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β} {z : α × β} {i : ℕ},
(as.zip bs)[i]? = some z ↔ as[i]? = some z.1 ∧ bs[i]? = some z.2 | null | true |
Std.TreeMap.Raw.maxKey!_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).maxKey! = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | null | true |
_private.Mathlib.Algebra.Ring.NonZeroDivisors.0.le_nonZeroDivisorsLeft_iff_isLeftRegular._simp_1_1 | Mathlib.Algebra.Ring.NonZeroDivisors | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
Fin.castLT_sub_nezero._proof_2 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i j : Fin n}, i < j → n - ↑i ≠ 0 | null | false |
FirstOrder.Language.PartialEquiv.mk.injEq | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(dom : L.Substructure M) (cod : L.Substructure N) (toEquiv : L.Equiv ↥dom ↥cod) (dom_1 : L.Substructure M)
(cod_1 : L.Substructure N) (toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1),
({ dom := dom, cod := cod, toEquiv := to... | null | true |
norm_pow | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [NormOneClass α] [NormMulClass α] (a : α) (n : ℕ), ‖a ^ n‖ = ‖a‖ ^ n | null | true |
Std.TreeMap.keys.eq_1 | Std.Data.TreeSet.Iterator | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp), t.keys = t.inner.keys | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.minKey?_eq_some_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | null | false |
Lean.instHashableLevelMVarId.hash | Lean.Level | Lean.LevelMVarId → UInt64 | null | true |
List.unattach_append | Init.Data.List.Attach | ∀ {α : Type u_1} {p : α → Prop} {l₁ l₂ : List { x // p x }}, (l₁ ++ l₂).unattach = l₁.unattach ++ l₂.unattach | null | true |
TopologicalSpace.Opens.coe_eq_univ._simp_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {U : TopologicalSpace.Opens α}, (↑U = Set.univ) = (U = ⊤) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.