name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Pseudofunctor.DescentData'.ofDescentData._proof_13 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(D : F.DescentData f) (i : ι),
... | null | false |
ByteArray.Iterator.hasNext.eq_1 | Init.Data.ByteArray.Basic | ∀ (arr : ByteArray) (i : ℕ), { array := arr, idx := i }.hasNext = decide (i < arr.size) | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_rio_add_add_eq_append._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m : ℕ}, ¬0 ≤ m → False | null | false |
Subgroup.fintypeBot | Mathlib.Algebra.Group.Subgroup.Finite | {G : Type u_1} → [inst : Group G] → Fintype ↥⊥ | null | true |
Composition.reverse_eq_ones | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {c : Composition n}, c.reverse = Composition.ones n ↔ c = Composition.ones n | null | true |
Lean.Syntax.instForInTopDownOfMonad.match_1 | Lean.Syntax | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((info : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node info k args)) →
((x : Lean.Syntax) → motive x) → motive stx | null | false |
Array.forIn'_eq_forIn' | Init.Data.Array.Basic | ∀ {α : Type u} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m], Array.forIn' = forIn' | null | true |
LE.le.isOpenPosMeasure | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} [inst : TopologicalSpace X] {m : MeasurableSpace X} {μ ν : MeasureTheory.Measure X}
[μ.IsOpenPosMeasure], μ ≤ ν → ν.IsOpenPosMeasure | null | true |
Lean.Grind.GrobnerConfig.locals._inherited_default | Init.Grind.Config | Bool | null | false |
HahnSeries.embDomainRingHom._proof_4 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] {Γ' : Type u_3}
[inst_2 : AddCommMonoid Γ'] [inst_3 : PartialOrder Γ'] [inst_4 : NonAssocSemiring R] (f : Γ →+ Γ')
(hfi : Function.Injective ⇑f) (hf : ∀ (g g' : Γ), f g ≤ f g' ↔ g ≤ g') (x y : HahnSeries Γ R),
HahnSeries.embDomain ... | null | false |
NNNorm | Mathlib.Analysis.Normed.Group.Defs | Type u_8 → Type u_8 | Auxiliary class, endowing a type `α` with a function `nnnorm : α → ℝ≥0` with notation `‖x‖₊`. | true |
FirstOrder.Language.Hom.casesOn | Mathlib.ModelTheory.Basic | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] →
[inst_1 : L.Structure N] →
{motive : L.Hom M N → Sort u_1} →
(t : L.Hom M N) →
((toFun : M → N) →
(map_fun' :
∀ {n : ℕ} (f : L.Functions n) ... | null | false |
Array.step_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).step =
pure
(Std.Shrink.deflate
(if h : pos < array.size then Std.PlausibleIterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos] ⋯
else Std.PlausibleIterStep.done ⋯)) | null | true |
WithTop.eq_of_forall_le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : PartialOrder α] {x y : WithTop α} [NoTopOrder α], (∀ (a : α), x ≤ ↑a ↔ y ≤ ↑a) → x = y | null | true |
FirstOrder.Language.BoundedFormula.realize_bdEqual._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
(t₁ t₂ : L.Term (α ⊕ Fin l)),
(t₁.bdEqual t₂).Realize v xs =
(FirstOrder.Language.Term.realize (Sum.elim v xs) t₁ = FirstOrder.Language.Term.realize (Sum.elim v xs) t₂) | null | false |
CategoryTheory.rightAdjointMate_comp | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y Z : C}
[inst_2 : CategoryTheory.HasRightDual X] [inst_3 : CategoryTheory.HasRightDual Y] {f : X ⟶ Y} {g : Xᘁ ⟶ Z},
CategoryTheory.CategoryStruct.comp (fᘁ) g =
CategoryTheory.CategoryStruct.comp (Categor... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α],
i < (List.idxsOf x xs s).length → 0 < (List.findIdxs (fun x_1 => x_1 == x) xs).length | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.opEquiv.match_15.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) (motive : CategoryTheory.WithInitial Cᵒᵖ → Sort u_2)
(h_1 : (x : Cᵒᵖ) → motive (CategoryTheory.WithInitial.of x)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of x => h_1 x
| CategoryTheory.WithInitial.star =... | null | true |
Module.Dual.extendRCLikeₗ._proof_8 | Mathlib.Analysis.RCLike.Extend | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {F : Type u_1} [inst_1 : AddCommGroup F] [inst_2 : Module ℝ F] [inst_3 : Module 𝕜 F]
[IsScalarTower ℝ 𝕜 F], LinearMap.CompatibleSMul F 𝕜 ℝ 𝕜 | null | false |
Std.DTreeMap.Raw.Const.equiv_iff_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap.Raw α (fun x => β) cmp},
t₁.Equiv t₂ ↔ (Std.DTreeMap.Raw.Const.toList t₁).Perm (Std.DTreeMap.Raw.Const.toList t₂) | null | true |
Std.Do.SPred.Tactic.HasFrame.mk._flat_ctor | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs} {P' : outParam (Std.Do.SPred σs)} {φ : outParam Prop},
(P ⊣⊢ₛ P' ∧ ⌜φ⌝) → Std.Do.SPred.Tactic.HasFrame P P' φ | null | false |
Std.ExtDTreeMap.getKey?_filterMap | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] [inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.ExtDTreeMap.filterMap f t).getKey? k = (t.getKey? k).pfilter fun x h' => (f x (t.get x ⋯)).isSome | null | true |
withTheReader.eq_1 | Std.Do.Triple.SpecLemmas | ∀ (ρ : Type u) {m : Type u → Type v} [inst : MonadWithReaderOf ρ m] {α : Type u} (f : ρ → ρ) (x : m α),
withTheReader ρ f x = MonadWithReaderOf.withReader f x | null | true |
countableInfClosure_eq_self._simp_1 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} [inst : Preorder α], (countableInfClosure s = s) = CountableInfClosed s | null | false |
CategoryTheory.Functor.RightExtension.isUniversalEquivOfIso₂._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} H] [inst_2 : CategoryTheory.Category.{u_6, u_5} D]
{L : CategoryTheory.Functor C D} {F₁ F₂ : CategoryTheory.Functor C H} (α₁ : L.RightExtension F₁)
(α₂ : L.RightExtension F₂) (... | null | false |
Matroid.IsLoop.dep | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e → M.Dep {e} | **Alias** of the reverse direction of `Matroid.singleton_dep`. | true |
_private.Mathlib.Order.Directed.0.Directed.mono.match_1_1 | Mathlib.Order.Directed | ∀ {α : Type u_2} {r : α → α → Prop} {ι : Sort u_1} {f : ι → α} (a b : ι)
(motive : (∃ z, r (f a) (f z) ∧ r (f b) (f z)) → Prop) (x : ∃ z, r (f a) (f z) ∧ r (f b) (f z)),
(∀ (c : ι) (h₁ : r (f a) (f c)) (h₂ : r (f b) (f c)), motive ⋯) → motive x | null | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.resolveDelayedMVarAssignments | Lean.Meta.Tactic.Grind.Main | Lean.Expr → Lean.MetaM Lean.Expr | Resolves delayed metavariable assignments created inside the current `withNewMCtxDepth` block.
`instantiateMVars` only resolves a delayed assignment `?m #[xs] := ?pending` when `?pending`'s
assignment is ground (no unassigned expression metavariables). This ground restriction exists
because `val` may contain metavariab... | true |
Ordnode.nth | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → ℕ → Option α | O(log n). Get the `i`th element of the set, by its index from left to right.
```
nth {a, b, c, d} 2 = some c
nth {a, b, c, d} 5 = none
``` | true |
Function.bUnion_ptsOfPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} (f : α → α), ⋃ n, ⋃ (_ : n > 0), Function.ptsOfPeriod f n = Function.periodicPts f | null | true |
GroupFilterBasis.mul' | Mathlib.Topology.Algebra.FilterBasis | ∀ {G : Type u} {inst : Group G} [self : GroupFilterBasis G] {U : Set G}, U ∈ self.sets → ∃ V ∈ self.sets, V * V ⊆ U | null | true |
AddOpposite.op_sub | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : SubNegMonoid α] (x y : α), AddOpposite.op (x - y) = -AddOpposite.op y + AddOpposite.op x | null | true |
Lean.Meta.ExtractLetsConfig._sizeOf_inst | Init.MetaTypes | SizeOf Lean.Meta.ExtractLetsConfig | null | false |
ProbabilityTheory.cgf_undef | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {t : ℝ},
¬MeasureTheory.Integrable (fun ω => Real.exp (t * X ω)) μ → ProbabilityTheory.cgf X μ t = 0 | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.SummationFilter.0.SummationFilter.conditional_filter_eq_map_range._simp_1_3 | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {m : α → β} {t : Set β}, (t ∈ Filter.map m f) = (m ⁻¹' t ∈ f) | null | false |
SimpleGraph.IsEdgeReachable.of_subsingleton | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ} {u v : V} [Subsingleton V], G.IsEdgeReachable k u v | null | true |
SemidirectProduct.equivProd_symm_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (x : N × G),
(SemidirectProduct.equivProd.symm x).left = x.1 | null | true |
Turing.TM2to1.trNormal.eq_3 | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} (k : K) (a : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ),
Turing.TM2to1.trNormal (Turing.TM2.Stmt.pop k a q) =
Turing.TM1.Stmt.goto fun x x_1 => Turing.TM2to1.Λ'.go k (Turing.TM2to1.StAct.pop a) q | null | true |
MeasureTheory.projectiveFamilyContent_mono | Mathlib.MeasureTheory.Constructions.ProjectiveFamilyContent | ∀ {ι : Type u_1} {α : ι → Type u_2} {mα : (i : ι) → MeasurableSpace (α i)}
{P : (J : Finset ι) → MeasureTheory.Measure ((j : ↥J) → α ↑j)} {s t : Set ((i : ι) → α i)}
(hP : MeasureTheory.IsProjectiveMeasureFamily P),
s ∈ MeasureTheory.measurableCylinders α →
t ∈ MeasureTheory.measurableCylinders α →
s ⊆ ... | null | true |
Aesop.Check.mk | Aesop.Check | Lean.Option Bool → Aesop.Check | null | true |
CategoryTheory.Subobject.underlying_arrow | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Y Z : CategoryTheory.Subobject X} (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Subobject.underlying.map f) Z.arrow = Y.arrow | null | true |
_private.Mathlib.CategoryTheory.FintypeCat.0.FintypeCat.uSwitchEquivalence._simp_5 | Mathlib.CategoryTheory.FintypeCat | ∀ {X Y : FintypeCat} (f : X ⟶ Y) (x : (FintypeCat.uSwitch.obj X).obj),
Y.uSwitchEquiv ((CategoryTheory.ConcreteCategory.hom (FintypeCat.uSwitch.map f)) x) =
(CategoryTheory.ConcreteCategory.hom f) (X.uSwitchEquiv x) | null | false |
Filter.EventuallyEq.fderivWithin_eq_of_nhds | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {x : E} {s : Set E},
f₁ =ᶠ[nhds x] f → fderivWithin 𝕜 f₁... | null | true |
herglotzRieszKernel_def | Mathlib.Analysis.Complex.Poisson | ∀ (c w z : ℂ), herglotzRieszKernel c w z = (z - c + (w - c)) / (z - c - (w - c)) | null | true |
_private.Init.Data.SInt.Bitwise.0.Int32.xor_not._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
CategoryTheory.ChosenPullbacksAlong.pullbackCone_snd | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Y Z X : C} (f : Y ⟶ X) (g : Z ⟶ X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong g],
(CategoryTheory.ChosenPullbacksAlong.pullbackCone f g).snd = CategoryTheory.ChosenPullbacksAlong.snd f g | null | true |
_private.Lean.Server.InfoUtils.0.Lean.Elab.InfoTree.deepestNodesM.match_1 | Lean.Server.InfoUtils | {α : Type} →
(motive : Option α → Sort u_1) →
(__do_lift : Option α) → ((r : α) → motive (some r)) → (Unit → motive none) → motive __do_lift | null | false |
FunLike.divisionMonoid._proof_2 | Mathlib.Data.FunLike.Group | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Mul F] [inst_2 : DivisionMonoid β]
[IsMulApply F α β] (f g : F), ⇑(f * g) = ⇑f * ⇑g | null | false |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffWithinAt_insert_self._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
UInt32.toUSize_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt32}, a.toUSize < b.toUSize ↔ a < b | null | true |
AddSubgroup.even._proof_1 | Mathlib.Algebra.Group.Subgroup.Even | ∀ (G : Type u_1) [inst : AddCommGroup G] {x : G}, Even x → Even (-x) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.NNReal.rpow_pos._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | null | false |
PowerSeries.coeff_one_substInv | Mathlib.RingTheory.PowerSeries.Substitution | ∀ {R : Type u_2} [inst : CommRing R] (P : PowerSeries R) [inst_1 : Invertible ((PowerSeries.coeff 1) P)],
(PowerSeries.coeff 1) P.substInv = ⅟((PowerSeries.coeff 1) P) | null | true |
IntermediateField.restrictScalars_toSubfield | Mathlib.FieldTheory.IntermediateField.Basic | ∀ (K : Type u_1) {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] [inst_5 : Algebra L' L] [inst_6 : IsScalarTower K L' L]
{E : IntermediateField L' L}, (IntermediateField.restrictScalars K E).toSubfield = E.toSubfield | null | true |
normal_iff | Mathlib.FieldTheory.Normal.Defs | ∀ {F : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K],
Normal F K ↔ ∀ (x : K), IsIntegral F x ∧ (Polynomial.map (algebraMap F K) (minpoly F x)).Splits | null | true |
Fin.finsetImage_natAdd_Ioc | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i j : Fin n),
Finset.image (Fin.natAdd m) (Finset.Ioc i j) = Finset.Ioc (Fin.natAdd m i) (Fin.natAdd m j) | null | true |
_private.Aesop.Frontend.Command.0.Aesop.Frontend.Parser.initFn._@.Aesop.Frontend.Command.470559899._hygCtx._hyg.2 | Aesop.Frontend.Command | IO Unit | null | false |
_private.Lean.Server.References.0.Lean.Server.combineIdents.match_1 | Lean.Server.References | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((ai : Lean.Elab.FVarAliasInfo) → motive (Lean.Elab.Info.ofFVarAliasInfo ai)) →
((x : Lean.Elab.Info) → motive x) → motive info | null | false |
CommHopfAlgCat._sizeOf_1 | Mathlib.Algebra.Category.CommHopfAlgCat | {R : Type u} → {inst : CommRing R} → [SizeOf R] → CommHopfAlgCat R → ℕ | null | false |
BoundedLatticeHom.subtypeVal._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {β : Type u_1} [inst : Lattice β] [inst_1 : BoundedOrder β] {P : β → Prop} (Pbot : P ⊥) (Ptop : P ⊤)
(Psup : ∀ ⦃x y : β⦄, P x → P y → P (x ⊔ y)) (Pinf : ∀ ⦃x y : β⦄, P x → P y → P (x ⊓ y)),
(LatticeHom.subtypeVal Psup Pinf).toFun ⊤ = ⊤ | null | false |
_private.Batteries.Linter.UnnecessarySeqFocus.0.Batteries.Linter.UnnecessarySeqFocus.markUsedTactics._sparseCasesOn_3 | Batteries.Linter.UnnecessarySeqFocus | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.TacticInfo) → motive (Lean.Elab.Info.ofTacticInfo i)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
MeasureTheory.VectorMeasure.integral_finsetSum | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {ι : Type u_1} {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G] {μ : MeasureTheory.VectorMeasure X F}
... | null | true |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.evalDiv.match_1 | Mathlib.Tactic.NormNum.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(a b : Q(«$α»)) →
(dsα : Q(DivisionSemiring «$α»)) →
(dα : Q(DivisionRing «$α»)) →
(motive : ℚ × (n : Q(ℤ)) × (d : Q(ℕ)) × Q(Mathlib.Meta.NormNum.IsRat («$a» * «$b»⁻¹) «$n» «$d») → Sort u_1) →
(__discr : ℚ × (n : Q(ℤ)) × (d : Q(ℕ)) × Q(Mathl... | null | false |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_closure_eq._simp_1_8 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : IsDomain A] {s t : Set A},
(AlgebraicIndependent.matroid R A).IsBasis s t =
(AlgebraicIndepOn R id s ∧ s ⊆ t ∧ ∀ a ∈ t, IsAlgebraic (↥(Algebra.adjoin R s)) a) | null | false |
Perfection.teichmullerAux.congr_simp | Mathlib.RingTheory.Teichmuller | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] {I : Ideal R} [inst_2 : CharP (R ⧸ I) p]
(x x_1 : Perfection (R ⧸ I) p), x = x_1 → ∀ (a a_1 : ℕ), a = a_1 → x.teichmullerAux a = x_1.teichmullerAux a_1 | null | true |
Lean.Meta.coerceCollectingNames? | Lean.Meta.Coe | Lean.Expr → Lean.Expr → Lean.MetaM (Lean.LOption (Lean.Expr × List Lean.Name)) | Coerces `expr` to the type `expectedType`.
Returns `.some (coerced, appliedCoeDecls)` on successful coercion,
`.none` if the expression cannot by coerced to that type,
or `.undef` if we need more metavariable assignments.
`appliedCoeDecls` is a list of names representing the names of the `Coe` instances that were
appl... | true |
RelSeries.fromListIsChain | Mathlib.Order.RelSeries | {α : Type u_1} → {r : SetRel α α} → (x : List α) → x ≠ [] → List.IsChain (fun x1 x2 => (x1, x2) ∈ r) x → RelSeries r | Every nonempty list satisfying the chain condition gives a relation series | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toArray_rco_add_succ_right_eq_push._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {α : Type u_1} {as : List α} {bs : Array α}, (as.toArray = bs) = (as = bs.toList) | null | false |
Lean.Widget.WidgetInstance.noConfusion | Lean.Widget.Types | {P : Sort u} → {t t' : Lean.Widget.WidgetInstance} → t = t' → Lean.Widget.WidgetInstance.noConfusionType P t t' | null | false |
AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
(hx : AlgebraicIndependent R x),
hx.mvPolynomialOptionEquivPolynomialAdjoin = hx.mvPolynomialOptionEquivPolynomialAdjoin | null | true |
AddOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α], AddOpposite.unop 1 = 1 | null | false |
Algebra.Presentation.tensorModelOfHasCoeffsInv._proof_1 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_4} {S : Type u_5} {ι : Type u_2} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.Presentation R S ι σ) (R₀ : Type u_1) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs R₀],
(Ideal... | null | false |
CategoryTheory.Limits.LimitBicone.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {P : Sort u} →
{J : Type w} →
{C : Type uC} →
{inst : CategoryTheory.Category.{uC', uC} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{F : J → C} →
{t : CategoryTheory.Limits.LimitBicone F} →
{J' : Type w} →
{C' : Type uC} →
... | null | false |
SSet.prodStdSimplex.pairingCore.IsType₂.strictMono_φ | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N},
SSet.prodStdSimplex.pairingCore.IsType₂ x →
∀ {d : ℕ} (hd : x.dim = d), StrictMono (SSet.prodStdSimplex.pairingCore.IsType₂.φ x hd) | null | true |
linearMapOfMemClosureRangeCoe_apply | Mathlib.Topology.Algebra.Module.Basic | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {R : Type u_4} {S : Type u_5} [inst : TopologicalSpace M₂] [inst_1 : T2Space M₂]
[inst_2 : Semiring R] [inst_3 : Semiring S] [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₁] [inst_7 : Module S M₂] [inst_8 : ContinuousConstSMul S M₂] [inst_9 : Continuou... | null | true |
BoundedContinuousFunction.instNSMul._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : AddMonoid R]
[ContinuousAdd R] (f : BoundedContinuousFunction α R) (n : ℕ), Continuous fun b => n • f b | null | false |
_private.Mathlib.GroupTheory.FiniteAbelian.Duality.0.CommGroup.mem_subgroupOrderIsoSubgroupMonoidHom_symm_iff._simp_1_3 | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {f : G ≃* N} {K : Subgroup G} {x : N},
(x ∈ Subgroup.map f.toMonoidHom K) = (f.symm x ∈ K) | null | false |
MeasureTheory.OuterMeasure.exists_measurable_superset_forall_eq_trim | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α] {ι : Sort u_2} [Countable ι] (μ : ι → MeasureTheory.OuterMeasure α)
(s : Set α), ∃ t, s ⊆ t ∧ MeasurableSet t ∧ ∀ (i : ι), (μ i) t = (μ i).trim s | If `μ i` is a countable family of outer measures, then for every set `s` there exists
a measurable set `t ⊇ s` such that `μ i t = (μ i).trim s` for all `i`. | true |
UpperSet.commSemigroup.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.commSemigroup = Function.Injective.commSemigroup SetLike.coe ⋯ ⋯ | null | true |
AddMonoid.End.instAddCommGroup._proof_9 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} [inst : AddCommGroup M],
autoParam
(∀ (n : ℕ) (a : AddMonoid.End M),
AddMonoid.End.instAddCommGroup._aux_6 (↑n.succ) a = AddMonoid.End.instAddCommGroup._aux_6 (↑n) a + a)
SubNegMonoid.zsmul_succ'._autoParam | null | false |
Set.pow_mem_pow | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Monoid α] {s : Set α} {a : α} {n : ℕ}, a ∈ s → a ^ n ∈ s ^ n | null | true |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.cellFrontier_subset_finite_openCell._simp_1_3 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Sat.Literal.pos.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} → {a a' : ℕ} → Sat.Literal.pos a = Sat.Literal.pos a' → (a = a' → P) → P | null | false |
Module.Basis.instFunLike._proof_1 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.Basis ι R M),
(fun b i => b.repr.symm fun₀ | i => 1) f = (fun b i => b.repr.symm fun₀ | i => 1) g → ↑f.repr.symm = ↑g.repr.symm | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst._proof_7 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → ¬curr = w → False | null | false |
MeasureTheory.VectorMeasure.Integrable.finsetSum_vectorMeasure | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] {f : X → E} {B : E →L[ℝ] F →L[ℝ] G} {ι : Type u_7}
{... | null | true |
Units.toAut_inv | Mathlib.CategoryTheory.SingleObj | ∀ (M : Type u) [inst : Monoid M] (x : Mˣ), ((Units.toAut M) x).inv = (CategoryTheory.SingleObj.toEnd M) ↑x⁻¹ | null | true |
LieAlgebra.SemiDirectSum.mk._flat_ctor | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → {x : L →ₗ⁅R⁆ LieDerivation R K K} → K → L → K ⋊⁅x⁆ L | null | false |
String.Internal.next | Init.Data.String.Bootstrap | String → String.Pos.Raw → String.Pos.Raw | null | true |
CategoryTheory.TwoSquare.guitartExact_id' | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] (F : CategoryTheory.Functor C₁ C₂),
(CategoryTheory.TwoSquare.mk F (CategoryTheory.Functor.id C₁) (CategoryTheory.Functor.id C₂) F
(CategoryTheory.CategoryStruct.id F)).GuitartExact | null | true |
CategoryTheory.regularTopology.equalizerCondition_iff_of_equivalence | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(P : CategoryTheory.Functor Cᵒᵖ D) (e : C ≌ E),
CategoryTheory.regularTopology.EqualizerCondition P ↔
CategoryTheory.regu... | `P` satisfies the equalizer condition iff its precomposition by an equivalence does. | true |
_private.Mathlib.Algebra.Lie.Cochain.0.LieModule.Cohomology.d₂₃Aux._proof_22 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_3) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_1)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(a : ↥(LieModule.Cohomology.twoCochain R L M)) (x : R) (x_1 x_2 x_3 : L),
{
toFun := fun z... | null | false |
IsNoetherian.finsetBasisIndex | Mathlib.FieldTheory.Finiteness | (K : Type u) →
(V : Type v) →
[inst : DivisionRing K] → [inst_1 : AddCommGroup V] → [inst_2 : Module K V] → [IsNoetherian K V] → Finset V | In a Noetherian module over a division ring,
there exists a finite basis. This is the indexing `Finset`. | true |
AddSemiconjBy.neg_symm_left_iff._simp_1 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {a x y : G}, AddSemiconjBy (-a) y x = AddSemiconjBy a x y | null | false |
CategoryTheory.SplitMono.map.eq_1 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X Y : C} {f : Y ⟶ X} (se : CategoryTheory.SplitMono f) (F : CategoryTheory.Functor C D),
se.map F = { retraction := F.map se.retraction, id := ⋯ } | null | true |
CategoryTheory.Coyoneda.colimitCoconeIsColimit._proof_2 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Cᵒᵖ)
(s : CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X))
(m : (CategoryTheory.Coyoneda.colimitCocone X).pt ⟶ s.pt),
(∀ (j : C), CategoryTheory.CategoryStruct.comp ((CategoryTheory.Coyoneda.colimitCocone X).ι.app j) m = s.ι.app j) →... | null | false |
Sum.update_inr_apply_inl | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} [inst : DecidableEq (α ⊕ β)] {f : α ⊕ β → γ} {i : α} {j : β} {x : γ},
Function.update f (Sum.inr j) x (Sum.inl i) = f (Sum.inl i) | null | true |
Set.image_const_sub_Ici | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (a b : α),
(fun x => a - x) '' Set.Ici b = Set.Iic (a - b) | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData.diseqs.inj | Lean.Meta.Tactic.Grind.Types | ∀ {solverId : ℕ} {ps : Lean.Meta.Grind.ParentSet} {rest : Lean.Meta.Grind.PendingSolverPropagationsData✝}
{solverId_1 : ℕ} {ps_1 : Lean.Meta.Grind.ParentSet} {rest_1 : Lean.Meta.Grind.PendingSolverPropagationsData✝},
Lean.Meta.Grind.PendingSolverPropagationsData.diseqs✝ solverId ps rest =
Lean.Meta.Grind.Pend... | null | true |
AdjoinRoot.algEquivOfEq_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : f = g), (AdjoinRoot.algEquivOfEq R f g hfg).symm = AdjoinRoot.algEquivOfEq R g f ⋯ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.