name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Widget.TaggedText.tag.elim | Lean.Widget.TaggedText | {α : Type u} →
{motive_1 : Lean.Widget.TaggedText α → Sort u_1} →
(t : Lean.Widget.TaggedText α) →
t.ctorIdx = 2 →
((a : α) → (a_1 : Lean.Widget.TaggedText α) → motive_1 (Lean.Widget.TaggedText.tag a a_1)) → motive_1 t | null | false |
CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) →
[Ca... | Given a functor `F : J ⥤ K ⥤ C`, with all needed limits,
we can construct a diagram consisting of the limit cone over each functor `F.obj j`,
and the universal cone morphisms between these.
| true |
CategoryTheory.sheafToPresheafCompCoyonedaCompWhiskeringLeftSheafToPresheaf_hom_app_app_hom_apply_hom | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] (X : (CategoryTheory.Sheaf J A)ᵒᵖ) (X_1 : CategoryTheory.Sheaf J A)
(a :
(((CategoryTheory.sheafToPresheaf J A).op.comp
(CategoryTheor... | null | true |
Associates.count_mul | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α]
[inst_2 : DecidableEq (Associates α)] [inst_3 : (p : Associates α) → Decidable (Irreducible p)] {a : Associates α},
a ≠ 0 →
∀ {b : Associates α},
b ≠ 0 → ∀ {p : Associates α}, Irreducible p → p.count (a * b).factors = p.... | null | true |
Submodule.finrank_le | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M] (s : Submodule R M), Module.finrank R ↥s ≤ Module.finrank R M | The dimension of a submodule is bounded by the dimension of the ambient space. | true |
ArchimedeanClass.instCommRingFiniteElement._aux_20 | Mathlib.Algebra.Order.Ring.StandardPart | (K : Type u_1) →
[inst : LinearOrder K] →
[inst_1 : Field K] →
[inst_2 : IsOrderedRing K] → ℕ → ArchimedeanClass.FiniteElement K → ArchimedeanClass.FiniteElement K | null | false |
Module.quotientAnnihilator._proof_2 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.IsTorsionBySet R M ↑(Module.annihilator R M) | null | false |
Std.Sat.AIG.ExtendTarget.mk.sizeOf_spec | Std.Sat.AIG.Basic | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {newWidth : ℕ} [inst_2 : SizeOf α]
(w : ℕ) (vec : aig.RefVec w), sizeOf { w := w, vec := vec } = 1 + sizeOf w + sizeOf vec | null | true |
HahnSeries.SummableFamily.instZero._proof_2 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_3} {R : Type u_2} {α : Type u_1} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R] (g : Γ),
{a | (0 a).coeff g ≠ 0}.Finite | null | false |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.LinearMap.instIsSimpleModuleEndOfNontrivial.match_1 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {M : Type u_1} [inst : AddCommGroup M] (R : Type u_2) [inst_1 : DivisionRing R] [inst_2 : Module R M] (v w : M)
(motive : (∃ h, h ∘ₗ LinearMap.toSpanSingleton R M v = LinearMap.toSpanSingleton R M w) → Prop)
(x : ∃ h, h ∘ₗ LinearMap.toSpanSingleton R M v = LinearMap.toSpanSingleton R M w),
(∀ (f : M →ₗ[R] M) (e... | null | false |
CommRingCat.mkUnder_ext | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ {R : CommRingCat} {A : Type u} [inst : CommRing A] [inst_1 : Algebra (↑R) A] {B : CategoryTheory.Under R}
{f g : R.mkUnder A ⟶ B},
(∀ (a : A),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Under.Hom.right f)) a =
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Under.Hom.right g)) a) →
... | null | true |
Lean.Meta.Sym.Arith.CommSemiring | Lean.Meta.Sym.Arith.Types | Type | Classification state for a type with a `CommSemiring` instance.
Recall that `CommSemiring` types are normalized using the `OfSemiring.Q` envelope.
| true |
CategoryTheory.Limits.pullbackProdSndIsoProd_inv_fst_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (Z : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProduct Z Y] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Z X]
[inst_3 : CategoryTheory.Limits.HasPullback CategoryTheory.Limits.prod.snd f],
CategoryTheory.CategoryStruct.comp (Cate... | null | true |
Turing.TM0to1.Λ'.normal | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → Λ → Turing.TM0to1.Λ' Γ Λ | null | true |
Std.DTreeMap.Raw.getKey?_of_isEmpty | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, t.isEmpty = true → t.getKey? a = none | null | true |
SSet.RelativeMorphism.botEquiv._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.Homotopy | ∀ {X Y : SSet}, Function.LeftInverse (fun f => { map := f, comm := ⋯ }) fun f => f.map | null | false |
Bundle.Trivialization.coordChange.eq_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e₁ e₂ : Bundle.Trivialization F proj) (b : B) (x : F),
e₁.coordChange e₂ b x = (↑e₂ (↑e₁.symm (b, x))).2 | null | true |
Finset.smul_finset_inter_subset | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] {s₁ s₂ : Finset β} {a : α},
a • (s₁ ∩ s₂) ⊆ a • s₁ ∩ a • s₂ | null | true |
Std.ExtDTreeMap.maxKey?_insert | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insert k v).maxKey? = some (t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k') | null | true |
OrderIso.setIsotypicComponents.eq_1 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsSemisimpleModule R M],
OrderIso.setIsotypicComponents =
{ toFun := fun s => ⨆ c ∈ s, ⟨↑c, ⋯⟩, invFun := fun m => {c | ↑c ≤ ↑m}, left_inv := ⋯, right_inv := ⋯,
map_rel_iff' := ⋯ } | null | true |
circleMap_sub_center | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | ∀ (c : ℂ) (R θ : ℝ), circleMap c R θ - c = circleMap 0 R θ | null | true |
Std.DHashMap.Raw.getKey?_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k k' : α} {f : Option (β k) → Option (β k)},
m.WF →
(m.alter k f).getKey? k' =
if (k == k') = true then if (f (m.get? k)).isSome = true then some k else none else m.getKey? k' | null | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.d | Mathlib.NumberTheory.PellMatiyasevic | {a : ℕ} → 1 < a → ℕ | null | true |
String.Pos.ofSlice_ne_endPos | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos},
p ≠ (s.slice p₀ p₁ h).endPos → String.Pos.ofSlice p ≠ s.endPos | null | true |
Module.Basis.groupSMul.congr_simp | Mathlib.LinearAlgebra.ExteriorPower.WedgePairing | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{G : Type u_5} [inst_3 : Group G] [inst_4 : DistribMulAction G R] [inst_5 : DistribMulAction G M]
[inst_6 : IsScalarTower G R M] [inst_7 : SMulCommClass G R M] (v v_1 : Module.Basis ι R M),
v = v_1 ... | null | true |
ContinuousMap.toLp_comp_toContinuousMap | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : CompactSpace α] [inst_5 : MeasureTheory.IsFiniteMeasure μ]
{𝕜 : Type u_3}... | null | true |
Lean.Lsp.LeanLocationLink | Lean.Data.Lsp.Internal | Type | `LocationLink` with additional meta-data that allows the watchdog to resolve the range of this
`LocationLink`. This is necessary because the position information from the .olean may be stale
(e.g. if the user has edited the file that the definition is from, but neither saved or built it),
while file workers sync their ... | true |
pow_le_pow_iff_right₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 1 < a → (a ^ n ≤ a ^ m ↔ n ≤ m) | null | true |
MeasureTheory.Measure.haar.is_left_invariant_addCHaar | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
{K₀ : TopologicalSpace.PositiveCompacts G} (g : G) (K : TopologicalSpace.Compacts G),
MeasureTheory.Measure.haar.addCHaar K₀ (TopologicalSpace.Compacts.map (fun x => g + x) ⋯ K) =
MeasureTheory.Measure.haar.add... | null | true |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.Monic.not_irreducible_iff_exists_add_mul_eq_coeff._simp_1_1 | Mathlib.Algebra.Polynomial.Monic | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
AddSubmonoid.fromLeftNeg.eq_1 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) (x : ↥S.leftNeg), S.fromLeftNeg x = Exists.choose ⋯ | null | true |
Lean.versionStringCore | Init.Meta.Defs | String | null | true |
Lean.Elab.WF.floatRecApp | Lean.Elab.PreDefinition.WF.FloatRecApp | Lean.Expr → Lean.CoreM Lean.Expr | Preprocesses the expressions to improve the effectiveness of `wfRecursion`.
* Floats out the RecApp markers.
Example:
```
def f : Nat → Nat
| 0 => 1
| i+1 => (f x) i
```
Unlike `Lean.Elab.Structural.preprocess`, do _not_ beta-reduce, as it could
remove `let_fun`-lambdas that contain explicit terminati... | true |
Filter.isBoundedUnder_le_sup._simp_2 | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeSup α] {f : Filter β} {u v : β → α},
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f fun a => u a ⊔ v a) =
(Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u ∧ Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f v) | null | false |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.val_sub_castLT_of_lt._proof_1_3 | Mathlib.Data.Fin.SuccPred | ∀ {n m : ℕ} {a b : Fin m}, ↑b < n → ¬n - ↑b + ↑a = m - ↑b + ↑a + n - m → False | null | false |
Finset.seqLeft_def | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} [inst : (P : Prop) → Decidable P] (s : Finset α) (t : Finset β), s <* t = if t = ∅ then ∅ else s | null | true |
Congruent.comp_left_iff | Mathlib.Topology.MetricSpace.Congruence | ∀ {ι : Type u_1} {P₁ : Type u_3} {P₂ : Type u_4} {P₃ : Type u_5} {v₁ : ι → P₁} {v₂ : ι → P₂}
[inst : PseudoEMetricSpace P₁] [inst_1 : PseudoEMetricSpace P₂] [inst_2 : PseudoEMetricSpace P₃] {f : P₁ → P₃},
Isometry f → (Congruent (f ∘ v₁) v₂ ↔ Congruent v₁ v₂) | null | true |
_private.Std.Time.DateTime.PlainDateTime.0.Std.Time.PlainDateTime.ofWallTime._proof_12 | Std.Time.DateTime.PlainDateTime | 0 < 60 | null | false |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix._proof_1_5 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (m k : ℕ) (i : Fin m) (i_1 : Fin k),
(if m + ↑i_1 < ↑i then 0
else
if h : m + ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨m + ↑i_1 - ↑i, ⋯⟩)
else if m + ↑i_1 - ↑i = k then 1 else 0) =
if ↑i ≤ m + ↑i_1 ∧ m + ↑i_1 ≤ ↑i + k then
if h : m + ↑i_1 - ↑i < k then... | null | false |
CategoryTheory.Limits.Fork.IsLimit.mk._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : X ⟶ Y}
(t : CategoryTheory.Limits.Fork f g) (lift : (s : CategoryTheory.Limits.Fork f g) → s.pt ⟶ t.pt),
(∀ (s : CategoryTheory.Limits.Fork f g) (m : s.pt ⟶ t.pt),
CategoryTheory.CategoryStruct.comp m t.ι = s.ι → m = lift s) →
... | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.fromMiddleHom | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} → {S : J.Cover X} → {T : (I : S.Arrow) → J.Cover I.Y} → (I : (S.bind T).Arrow) → I.middle ⟶ X | An arrow in bind has the form `A ⟶ B ⟶ X` where `A ⟶ B` is an arrow in `T I` for some `I`.
and `B ⟶ X` is an arrow of `S`. This is the hom `B ⟶ X`. | true |
String.markLinear | Init.Data.String.Defs | String → String | Marks a string as linear, which is a no-op logically.
At runtime the string is first made unique, copying it if the reference is not already unique, and
then marked. If the environment variable `LEAN_ABORT_ON_NONLINEAR` is set, every non-linear use
from that point on causes a panic instead of a silent copy.
To debug ... | true |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.getMsbD_ofFnLE._proof_1_2 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ), i + 1 ≤ n → n - (i + 1) < n | null | false |
_private.Mathlib.Tactic.IrreducibleDef.0.Lean.Elab.Command._aux_Mathlib_Tactic_IrreducibleDef___elabRules__private_Mathlib_Tactic_IrreducibleDef_0_Lean_Elab_Command_commandStop_at_first_error___1.match_1 | Mathlib.Tactic.IrreducibleDef | (motive : Option (Array (Lean.TSyntax `command)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `command))) →
((cmds : Array (Lean.TSyntax `command)) → motive (some cmds)) → (Unit → motive none) → motive x | null | false |
NumberField.Units.instFiniteIntAdditiveQuotientUnitsRingOfIntegersSubgroupTorsion | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [NumberField K],
Module.Finite ℤ (Additive ((NumberField.RingOfIntegers K)ˣ ⧸ NumberField.Units.torsion K)) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.USize.reduceToNat._regBuiltin.USize.reduceToNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4160102673._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
MonomialOrder.degree_neg | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] {f : MvPolynomial σ R},
m.degree (-f) = m.degree f | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.Extension.getEMatchTheoremsForNamespace.match_4 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Option (Lean.PArray Lean.Meta.Grind.Entry) → Sort u_1) →
(x : Option (Lean.PArray Lean.Meta.Grind.Entry)) →
(Unit → motive none) → ((entries : Lean.PArray Lean.Meta.Grind.Entry) → motive (some entries)) → motive x | null | false |
lift_rank_range_of_injective | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Function.Injective ⇑f → Cardinal.lift.{v, v'} (Module.rank R ↥f.range) = Cardinal.lift.{v', v} (Module.rank R M) | null | true |
Lean.Meta.TacticResultCNM.modified.elim | Lean.Meta.Tactic.Util | {motive : Lean.Meta.TacticResultCNM → Sort u} →
(t : Lean.Meta.TacticResultCNM) →
t.ctorIdx = 2 → ((mvarId : Lean.MVarId) → motive (Lean.Meta.TacticResultCNM.modified mvarId)) → motive t | null | false |
Std.Do.ExceptT.instWPMonad._proof_1 | Std.Do.WP.Monad | ∀ {m : Type u_1 → Type u_2} {ps : Std.Do.PostShape} {ε : Type u_1} [inst : Monad m] [Std.Do.WPMonad m ps],
LawfulMonad (ExceptT ε m) | null | false |
Lean.Lsp.FileSystemWatcher.mk.inj | Lean.Data.Lsp.Workspace | ∀ {globPattern : String} {kind? : Option ℕ} {globPattern_1 : String} {kind?_1 : Option ℕ},
{ globPattern := globPattern, kind? := kind? } = { globPattern := globPattern_1, kind? := kind?_1 } →
globPattern = globPattern_1 ∧ kind? = kind?_1 | null | true |
Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.extended.injEq | Std.Tactic.BVDecide.LRAT.Internal.Rup | ∀ (assign assign_1 : Std.Tactic.BVDecide.LRAT.Internal.Assignment),
(Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.extended assign =
Std.Tactic.BVDecide.LRAT.Internal.PropagateResult.extended assign_1) =
(assign = assign_1) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.foldrM_eq_foldrM_toList._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Lean.Lsp.ShowMessageRequestParams.type | Lean.Data.Lsp.Window | Lean.Lsp.ShowMessageRequestParams → Lean.Lsp.MessageType | null | true |
not_isMulTorsion_iff._simp_2 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : Monoid G], (¬IsMulTorsion G) = ∃ g, ¬IsOfFinOrder g | null | false |
List.cons_eq_cons | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a b : α} {l l' : List α}, a :: l = b :: l' ↔ a = b ∧ l = l' | null | true |
OrderIso.eq_symm_apply | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {x : α} {y : β}, x = e.symm y ↔ e x = y | null | true |
Set.Definable.compl._simp_1 | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ = True | null | false |
ONote.repr.eq_def | Mathlib.SetTheory.Ordinal.Notation | ∀ (x : ONote),
x.repr =
match x with
| ONote.zero => 0
| e.oadd n a => Ordinal.omega0 ^ e.repr * ↑↑n + a.repr | null | true |
CategoryTheory.Limits.WidePushoutShape.mkCocone_ι_app | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) C} {X : C} (f : F.obj none ⟶ X)
(π : (j : J) → F.obj (some j) ⟶ X)
(w :
∀ (j : J), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WidePushoutShape.Hom.... | null | true |
String.Slice.Pos.byte_copy | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos} (h : pos.copy ≠ s.copy.endPos), pos.copy.byte h = pos.byte ⋯ | null | true |
DFA.reindex | Mathlib.Computability.DFA | {α : Type u} → {σ : Type v} → {σ' : Type u_2} → σ ≃ σ' → DFA α σ ≃ DFA α σ' | Lifts an equivalence on states to an equivalence on DFAs. | true |
LieRinehartRing.recOn | Mathlib.Algebra.LieRinehartAlgebra.Defs | {A : Type u_1} →
{L : Type u_2} →
[inst : CommRing A] →
[inst_1 : LieRing L] →
[inst_2 : Module A L] →
[inst_3 : LieRingModule L A] →
{motive : LieRinehartRing A L → Sort u} →
(t : LieRinehartRing A L) →
((lie_smul_eq_mul' : ∀ (a b : A) (x : L), ⁅a... | null | false |
nndist_pi_def | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {β : Type u_2} {X : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (X b)]
(f g : (b : β) → X b), nndist f g = Finset.univ.sup fun b => nndist (f b) (g b) | null | true |
Std.CloseableChannel.Error._sizeOf_inst | Std.Sync.Channel | SizeOf Std.CloseableChannel.Error | null | false |
FractionalIdeal.isPrincipal_iff | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (I : FractionalIdeal S P),
(↑I).IsPrincipal ↔ ∃ x, I = (FractionalIdeal.spanSingleton S) x | null | true |
_private.Batteries.Data.List.Interleave.0.List.interleave_ofFn_ofFn_even.match_1_1 | Batteries.Data.List.Interleave | ∀ {α : Type u_1} (motive : (x : ℕ) → (Fin x → α) → (Fin x → α) → Prop) (x : ℕ) (x_1 x_2 : Fin x → α),
(∀ (x x_3 : Fin 0 → α), motive 0 x x_3) →
(∀ (n : ℕ) (x x_3 : Fin (n + 1) → α), motive n.succ x x_3) → motive x x_1 x_2 | null | false |
Std.TreeSet.Raw.Equiv.forM_eq | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet.Raw α cmp} {m : Type w → Type w'} [Std.TransCmp cmp]
[inst : Monad m] [LawfulMonad m] {f : α → m PUnit.{w + 1}}, t₁.WF → t₂.WF → t₁.Equiv t₂ → forM t₁ f = forM t₂ f | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._proof_29 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (lhs rhs : Std.Sat.AIG.Fanin),
lhs.gate < upper ∧ rhs.gate < upper →
∀ (rstate : Std.Sat.AIG.toCNF.State✝ aig),
rhs.gate < (Std.Sat.AIG.toCNF.Cache.marks✝ (Std.Sat.AIG.toCNF.State.cache✝ rstate)).size | null | false |
Dynamics.coverEntropyEntourage_univ | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {X : Type u_1} {F : Set X} (T : X → X), F.Nonempty → Dynamics.coverEntropyEntourage T F Set.univ = 0 | null | true |
AlgebraicGeometry.instIsMultiplicativeSchemeIsSchemeTheoreticallyDominant | Mathlib.AlgebraicGeometry.Morphisms.SchemeTheoreticallyDominant | CategoryTheory.MorphismProperty.IsMultiplicative @AlgebraicGeometry.IsSchemeTheoreticallyDominant | null | true |
Int.isSquare_natCast_iff._simp_1 | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℕ}, IsSquare ↑n = IsSquare n | null | false |
String.utf8GetAux?_of_valid._f | Batteries.Data.String.Lemmas | ∀ {p : ℕ} (cs : List Char)
(f :
List.below (motive := fun cs =>
∀ (cs' : List Char) {i : ℕ},
i + String.utf8Len cs = p →
String.Pos.Raw.utf8GetAux? (cs ++ cs') { byteIdx := i } { byteIdx := p } = cs'.head?)
cs)
(cs' : List Char) {i : ℕ},
i + String.utf8Len cs = p → String.Pos.Raw... | null | false |
AddCommGrpCat.forget_commGrp_preserves_mono | Mathlib.Algebra.Category.Grp.EpiMono | (CategoryTheory.forget AddCommGrpCat).PreservesMonomorphisms | null | true |
Array.getElem_modify._proof_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {f : α → α} {xs : Array α} {j i : ℕ}, i < (xs.modify j f).size → i < xs.size | null | false |
Function.Surjective.distribMulActionLeft._proof_3 | Mathlib.Algebra.GroupWithZero.Action.End | ∀ {R : Type u_3} {S : Type u_2} {M : Type u_1} [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M]
[inst_3 : Monoid S] [inst_4 : SMul S M] (f : R →* S) (hf : Function.Surjective ⇑f)
(hsmul : ∀ (c : R) (x : M), f c • x = c • x) (a : S) (x y : M), a • (x + y) = a • x + a • y | null | false |
Lean.Elab.Tactic.Omega.MetaProblem.processedFacts._default | Lean.Elab.Tactic.Omega.Frontend | Std.HashSet Lean.Expr | null | false |
Part.map_Dom | Mathlib.Data.Part | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (o : Part α), (Part.map f o).Dom = o.Dom | null | true |
_private.Std.Time.Date.PlainDate.0.Std.Time.PlainDate.weekOfMonth._proof_1 | Std.Time.Date.PlainDate | 1 ≤ 6 | null | false |
Mathlib.Meta.FunProp.FunctionTheorems.recOn | Mathlib.Tactic.FunProp.Theorems | {motive : Mathlib.Meta.FunProp.FunctionTheorems → Sort u} →
(t : Mathlib.Meta.FunProp.FunctionTheorems) →
((theorems :
Std.TreeMap Lean.Name (Std.TreeMap Lean.Name (Array Mathlib.Meta.FunProp.FunctionTheorem) Lean.Name.quickCmp)
Lean.Name.quickCmp) →
motive { theorems := theorems }) ... | null | false |
UniformFun.instPseudoEMetricSpace._proof_2 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace β] (x y : UniformFun α β), edist x y = edist y x | null | false |
MeasurableDiv.measurable_const_div | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G₀ : Type u_2} {inst : MeasurableSpace G₀} {inst_1 : Div G₀} [self : MeasurableDiv G₀] (c : G₀),
Measurable fun x => c / x | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.pi_le_log4_mul_div._proof_1_2 | Mathlib.NumberTheory.Chebyshev | ∀ {x : ℝ}, 1 < x → ↑⌊x⌋₊.primeCounting * Real.log √x ≤ Real.log 4 * x + Real.log √x * √x | null | false |
Aesop.ForwardState.eraseHyp | Aesop.Forward.State | Lean.FVarId → Aesop.ForwardState → Aesop.ForwardState | Remove a hypothesis from the forward state. If `fs` represents a local
context `lctx`, then `fs.eraseHyp h` represents `lctx` with `h` removed. | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.integral_1_div_log_sq_le._simp_1_5 | Mathlib.NumberTheory.Chebyshev | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
CategoryTheory.MorphismProperty.IsWeakFactorizationSystem.hasFactorization | Mathlib.CategoryTheory.MorphismProperty.WeakFactorizationSystem | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {W₁ W₂ : CategoryTheory.MorphismProperty C}
[self : W₁.IsWeakFactorizationSystem W₂], W₁.HasFactorization W₂ | null | true |
NumberField.Units.fundSystem.eq_1 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (i : Fin (NumberField.Units.rank K)),
NumberField.Units.fundSystem K i = Quotient.out (Additive.toMul ((NumberField.Units.basisModTorsion K) i)) | null | true |
CategoryTheory.ObjectProperty.instIsMultiplicativeIsColocal | Mathlib.CategoryTheory.Localization.Bousfield | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C),
P.isColocal.IsMultiplicative | null | true |
CategoryTheory.MorphismProperty.RightFraction₂ | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → CategoryTheory.MorphismProperty C → C → C → Type (max u_1 v_1) | This structure contains the data of two right fractions for
`W : MorphismProperty C` that have the same "denominator". | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofHasKernel.eq_1 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : CategoryTheory.Limits.HasKernel S.g] (hf : S.f = 0),
CategoryTheory.ShortComplex.LeftHomologyData.ofHasKernel S hf =
CategoryTheory.ShortComplex.LeftHo... | null | true |
List.replace_append_right | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {a b : α} [LawfulBEq α] {l₁ l₂ : List α},
a ∉ l₁ → (l₁ ++ l₂).replace a b = l₁ ++ l₂.replace a b | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ImproperIntegrals.0.integrableOn_inv_div_log_sq_Ioi._simp_1_4 | Mathlib.Analysis.SpecialFunctions.ImproperIntegrals | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.δ_σ₀Iter._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ {n : ℕ} (j : ℕ) {m : ℕ}, m + (j + 1) = n + 1 → m + (j + 1) = n + 1 | null | false |
CategoryTheory.Limits.coneLeftOpOfCoconeEquiv_functor_map_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J Cᵒᵖ} {Y X : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X),
(CategoryTheory.Limits.coneLeftOpOfCoconeEquiv.functor.map f).hom = f.unop.hom.unop | null | true |
BoolRing.instCategory._proof_1 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y : BoolRing} (f : X.Hom Y), { hom' := f.hom'.comp { hom' := RingHom.id ↑X }.hom' } = f | null | false |
CategoryTheory.Subobject.mk | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X A : C} → (f : A ⟶ X) → [CategoryTheory.Mono f] → CategoryTheory.Subobject X | Convenience constructor for a subobject. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_modify_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
IsAddFreimanIso.bijOn | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : AddCommMonoid β] {n : ℕ} {A : Set α} {B : Set β}
{f : α → β}, IsAddFreimanIso n A B f → Set.BijOn f A B | null | true |
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_5 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], SMulCommClass 𝕜 𝕜 F | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.