name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.ExtDHashMap.Const.contains_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k k' : α} {f : β → β}, (Std.ExtDHashMap.Const.modify m k f).contains k' = m.contains k' | null | true |
deriv_fun_finset_prod | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι] {𝔸' : Type u_3}
[inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'},
(∀ i ∈ u, DifferentiableAt 𝕜 (f i) x) →
deriv (fun x => ∏ i ∈ u, f i x) x = ∑ i ∈ u, (∏ j ∈ u.er... | **Alias** of `deriv_fun_finsetProd`. | true |
Wbtw.neg | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] {x y z : V}, Wbtw R x y z → Wbtw R (-x) (-y) (-z) | **Alias** of the reverse direction of `wbtw_neg_iff`. | true |
Polynomial.map_modByMonic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} {S : Type v} [inst : Ring R] {p q : Polynomial R} [inst_1 : Ring S] (f : R →+* S),
q.Monic → Polynomial.map f (p %ₘ q) = Polynomial.map f p %ₘ Polynomial.map f q | null | true |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.getDeprecatedInfo.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Option Lean.Name → Sort u_1) →
(__do_lift : Option Lean.Name) →
((mod : Lean.Name) → motive (some mod)) → ((x : Option Lean.Name) → motive x) → motive __do_lift | null | false |
RingCon.quotientKerEquivOfSurjective | Mathlib.RingTheory.Congruence.Hom | {M : Type u_1} →
{P : Type u_3} →
[inst : NonAssocSemiring M] →
[inst_1 : NonAssocSemiring P] → (f : M →+* P) → Function.Surjective ⇑f → (RingCon.ker f).Quotient ≃+* P | The first isomorphism theorem for rings in the case of a surjective homomorphism.
For a `computable` version, see `RingCon.quotientKerEquivOfRightInverse`.
| true |
InvariantBasisNumber.casesOn | Mathlib.LinearAlgebra.InvariantBasisNumber | {R : Type u} →
[inst : Semiring R] →
{motive : InvariantBasisNumber R → Sort u_1} →
(t : InvariantBasisNumber R) →
((eq_of_fin_equiv : ∀ {n m : ℕ} (a : (Fin n → R) ≃ₗ[R] Fin m → R), n = m) → motive ⋯) → motive t | null | false |
Pi.single_op₂ | Mathlib.Algebra.Notation.Pi.Basic | ∀ {ι : Type u_1} {M : ι → Type u_4} {N : ι → Type u_5} {O : ι → Type u_6} [inst : (i : ι) → Zero (M i)]
[inst_1 : (i : ι) → Zero (N i)] [inst_2 : (i : ι) → Zero (O i)] [inst_3 : DecidableEq ι]
(op : (i : ι) → M i → N i → O i),
(∀ (i : ι), op i 0 0 = 0) →
∀ (i : ι) (x : M i) (y : N i), Pi.single i (op i x y) =... | null | true |
Std.DTreeMap.Internal.Impl.isEmpty_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(Std.DTreeMap.Internal.Impl.alter! k f t).isEmpty =
((t.isEmpty || t.size == 1 && Std.DTreeMap.Internal.Impl.conta... | null | true |
Lean.Parser.Term.doLoopInvariant.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | null | true |
ENNReal.inv_three_add_inv_three | Mathlib.Basic.ENNReal.Inv | 3⁻¹ + 3⁻¹ + 3⁻¹ = 1 | null | true |
ULift.nonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : NonAssocSemiring R] (a : ULift.{u_1, u_2} R), a * 1 = a | null | false |
Aesop.Options'.generateScript | Aesop.Options.Internal | Aesop.Options' → Bool | null | true |
CategoryTheory.Preadditive.comp_sub_assoc | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {P Q R : C} (f : P ⟶ Q)
(g g' : Q ⟶ R) {Z : C} (h : R ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (g - g') h) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStr... | null | true |
birkhoffSum_succ_apply' | Mathlib.Dynamics.BirkhoffSum.Basic | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] (f : α → α) (g : α → M) (n : ℕ) (x : α),
birkhoffSum f g (n + 1) x = g x + birkhoffSum f g n (f x) | null | true |
RingQuot.instSub | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Ring R] → (r : R → R → Prop) → Sub (RingQuot r) | null | true |
_private.Mathlib.Algebra.Homology.Augment.0.ChainComplex.augment.match_3.eq_3 | Mathlib.Algebra.Homology.Augment | ∀ (motive : ℕ → ℕ → Sort u_1) (x x_1 : ℕ) (h_1 : Unit → motive 1 0) (h_2 : (i j : ℕ) → motive i.succ j.succ)
(h_3 : (x x_2 : ℕ) → motive x x_2),
(x = 1 → x_1 = 0 → False) →
(∀ (i j : ℕ), x = i.succ → x_1 = j.succ → False) →
(match x, x_1 with
| 1, 0 => h_1 ()
| i.succ, j.succ => h_2 i j
... | null | true |
Lean.Order.instPartialOrderStateRefT' | Init.Internal.Order.Basic | {m : Type → Type} →
{ω σ α : Type} → [inst : Lean.Order.PartialOrder (m α)] → Lean.Order.PartialOrder (StateRefT' ω σ m α) | null | true |
getElem_congr_coll | Init.GetElem | ∀ {coll : Type u_1} {idx : Type u_2} {elem : Type u_3} {valid : coll → idx → Prop} [inst : GetElem coll idx elem valid]
{c d : coll} {i : idx} {w : valid c i} (h : c = d), c[i] = d[i] | null | true |
AlgebraicGeometry.RingedSpace.mem_top_basicOpen._simp_1 | Mathlib.Geometry.RingedSpace.Basic | ∀ (X : AlgebraicGeometry.RingedSpace) (f : ↑(X.presheaf.obj (Opposite.op ⊤))) (x : ↑↑X.toPresheafedSpace),
(x ∈ X.basicOpen f) = IsUnit ((CategoryTheory.ConcreteCategory.hom (X.presheaf.Γgerm x)) f) | null | false |
QuadraticMap.IsOrtho.symm | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M}, Q.IsOrtho x y → Q.IsOrtho y x | **Alias** of the forward direction of `QuadraticMap.isOrtho_comm`. | true |
QuadraticMap.IsometryEquiv.map_negDef_iff | Mathlib.LinearAlgebra.QuadraticForm.Signature | ∀ {R : Type u_1} {M : Type u_2} {M' : Type u_3} [inst : AddCommGroup M] [inst_1 : AddCommGroup M'] [inst_2 : CommRing R]
[inst_3 : LinearOrder R] [inst_4 : Module R M] {Q : QuadraticForm R M} [inst_5 : Module R M']
{Q' : QuadraticForm R M'} {V : Submodule R M} (e : QuadraticMap.IsometryEquiv Q Q'),
(QuadraticMap.... | null | true |
Lean.Elab.Term.Quotation.HeadCheck._sizeOf_1 | Lean.Elab.Quotation | Lean.Elab.Term.Quotation.HeadCheck → ℕ | null | false |
Mathlib.Meta.FunProp.LambdaTheorems.mk.noConfusion | Mathlib.Tactic.FunProp.Theorems | {P : Sort u} →
{theorems theorems' :
Std.HashMap (Lean.Name × Mathlib.Meta.FunProp.LambdaTheoremType) (Array Mathlib.Meta.FunProp.LambdaTheorem)} →
{ theorems := theorems } = { theorems := theorems' } → (theorems = theorems' → P) → P | null | false |
Ideal.map_includeRight_eq | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} {B : Type u_3} [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B),
Submodule.restrictScalars R (Ideal.map Algebra.TensorProduct.includeRight I) =
(LinearMap.lTensor A (Submodule.restrictScalars R I).subt... | The ideal of `A ⊗[R] B` generated by `I` is the image of `A ⊗[R] I` | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.FriendlyOperation | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
(Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) →
Prop | An operation on multiseries called a "friend" if any `n`-prefix of its output depends only on
the `n`-prefix of the input. Such operations can be used in the tail of (non-primitive) corecursive
definitions. | true |
Hyperreal.termε | Mathlib.Analysis.Real.Hyperreal | Lean.ParserDescr | A sample infinitesimal hyperreal ε = ⟦(0, 1, 1/2, 1/3, ⋯)⟧.
Conventions for notations in identifiers:
* The recommended spelling of `ε` in identifiers is `epsilon`. | true |
Filter.map_mul | Mathlib.Order.Filter.Pointwise | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Mul β] {f₁ f₂ : Filter α}
[inst_2 : FunLike F α β] [MulHomClass F α β] (m : F),
Filter.map (⇑m) (f₁ * f₂) = Filter.map (⇑m) f₁ * Filter.map (⇑m) f₂ | null | true |
SimpleGraph.Walk.not_isCycle_nil._simp_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V}, SimpleGraph.Walk.nil.IsCycle = False | null | false |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.Recv.rec | Std.Http.Server.Connection | {β : Type} →
{motive : Std.Http.Server.Connection.Recv✝ β → Sort u} →
((x : Option ByteArray) → motive (Std.Http.Server.Connection.Recv.bytes✝ x)) →
((x : Option Std.Http.Chunk) → motive (Std.Http.Server.Connection.Recv.responseBody✝ x)) →
((x : Bool) → motive (Std.Http.Server.Connection.Recv.bodyIn... | null | false |
Pi.smulZeroClass._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Pi | ∀ {I : Type u_1} {f : I → Type u_2} (α : Type u_3) {n : (i : I) → Zero (f i)} [inst : (i : I) → SMulZeroClass α (f i)]
(x : α), x • 0 = 0 | null | false |
Int.fdiv_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → 0 ≤ b → 0 ≤ a.fdiv b | null | true |
Affine.Simplex.incenter_mem_interior | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n), s.incenter ∈ s.interior | null | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame | Lean.DocString.Extension | Type | null | true |
ContDiffOn.absolutelyContinuousOnInterval | Mathlib.MeasureTheory.Function.AbsolutelyContinuous | ∀ {a b : ℝ} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : ℝ → E},
ContDiffOn ℝ 1 f (Set.uIcc a b) → AbsolutelyContinuousOnInterval f a b | If `f` is `C^1` on `uIcc a b`, then `f` is absolutely continuous on `uIcc a b`. | true |
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.TendstoLocallyUniformlyOn.deriv._simp_1_2 | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
tprod_apply | Mathlib.Topology.Algebra.InfiniteSum.ContinuousEval | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {F : Type u_4} [inst : TopologicalSpace β] [inst_1 : CommMonoid β]
[inst_2 : FunLike F α β] [inst_3 : TopologicalSpace F] [inst_4 : CommMonoid F] [ContinuousEvalConst F α β]
[IsMulApply F α β] [IsOneApply F α β] {f : γ → F} {L : SummationFilter γ} [T2Space β] [L.NeBot]... | See also `Pi.tprod_apply` for bare pi type. | true |
CategoryTheory.Comonad.ForgetCreatesColimits'.liftedCoconeIsColimit._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {T : CategoryTheory.Comonad C}
(D : CategoryTheory.Functor J T.Coalgebra) (c : CategoryTheory.Limits.Cocone (D.comp T.forget))
(t : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.L... | null | false |
HahnSeries.coeff_zero | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {a : Γ}, HahnSeries.coeff 0 a = 0 | null | true |
Rep.binaryBiconeIsBilimit._proof_1 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Ring k] [inst_1 : Monoid G] (A B : Rep.{u_1, u_2, u_3} k G),
CategoryTheory.CategoryStruct.comp (A.binaryBicone B).fst (A.binaryBicone B).inl +
CategoryTheory.CategoryStruct.comp (A.binaryBicone B).snd (A.binaryBicone B).inr =
CategoryTheory.CategoryStruct.id (A.binar... | null | false |
Combinatorics.Line.casesOn | Mathlib.Combinatorics.HalesJewett | {α : Type u_5} →
{ι : Type u_6} →
{motive : Combinatorics.Line α ι → Sort u} →
(t : Combinatorics.Line α ι) →
((idxFun : ι → Option α) → (proper : ∃ i, idxFun i = none) → motive { idxFun := idxFun, proper := proper }) →
motive t | null | false |
Descriptive.Tree.mem_pullSub_append._simp_1 | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {x y : List A}, (x ++ y ∈ Descriptive.Tree.pullSub T x) = (y ∈ T) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.isEmpty_filter_key_eq_false_iff._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
LinearMap.BilinForm.separatingLeft_toMatrix'_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {ι : Type u_6} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
{B : LinearMap.BilinForm R₂ (ι → R₂)}, (LinearMap.BilinForm.toMatrix' B).SeparatingLeft = LinearMap.SeparatingLeft B | null | false |
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan_functor_obj | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
(c : CategoryTheory.Limits.PushoutCocone f g),
CategoryTheory.Limits.pushoutCoconeEquivBinaryCofan.functor.obj c =
CategoryTheory.Limits.BinaryCofan.mk (CategoryTheory.Under.homMk c.inl ⋯) (CategoryTheory.Under.homMk c.... | null | true |
GenLoop.apply_inl_apply_inr_eq_of_mem_boundary_sum | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {M : Type u_3} (x : X)
(p : ↑(GenLoop M (↑(GenLoop N X x)) GenLoop.const)) {y : M ⊕ N → ↑unitInterval},
y ∈ Cube.boundary (M ⊕ N) → (p (y ∘ Sum.inl)) (y ∘ Sum.inr) = x | null | true |
Turing.ToPartrec.Cfg.ret.elim | Mathlib.Computability.TuringMachine.Config | {motive : Turing.ToPartrec.Cfg → Sort u} →
(t : Turing.ToPartrec.Cfg) →
t.ctorIdx = 1 → ((a : Turing.ToPartrec.Cont) → (a_1 : List ℕ) → motive (Turing.ToPartrec.Cfg.ret a a_1)) → motive t | null | false |
OrderType.ToType | Mathlib.Order.Types.Defs | OrderType.{u} → Type u | A "canonical" type order-isomorphic to the order type `o`, living in the same universe.
This is defined through the axiom of choice. | true |
R0Space.casesOn | Mathlib.Topology.Separation.Basic | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : R0Space X → Sort u_1} →
(t : R0Space X) → ((specializes_symm : Std.Symm Specializes) → motive ⋯) → motive t | null | false |
SimpleGraph.dist_eq_one_iff_adj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V}, (G.dist u v = 1) = G.Adj u v | null | false |
Std.Async.System.CPUInfo.recOn | Std.Async.System | {motive : Std.Async.System.CPUInfo → Sort u} →
(t : Std.Async.System.CPUInfo) →
((model : String) →
(speed : ℕ) → (times : Std.Async.System.CPUTimes) → motive { model := model, speed := speed, times := times }) →
motive t | null | false |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_18 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] (_m : ℤ),
autoParam (∀ (a b : WittVector.StandardOneDimIsocrystal p k _m), a - b = a + -b)
SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
Lean.Compiler.LCNF.FloatLetIn.dontFloat | Lean.Compiler.LCNF.FloatLetIn | Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.FloatLetIn.FloatM Unit | Will:
- put `decl` into the `dont` arm
- decide that any free variable that occurs in `decl` and is a declaration
of interest as not getting moved either.
```
let x := ...
let y := ...
let z := x + y
cases z with
| n => z * x
| m => z * y
```
Here `x` and `y` are originally marked as getting floated into `n` and `m`
... | true |
Std.Http.URI.EncodedString.noConfusionType | Std.Http.Data.URI.Encoding | Sort u →
{r : UInt8 → Bool} → Std.Http.URI.EncodedString r → {r' : UInt8 → Bool} → Std.Http.URI.EncodedString r' → Sort u | null | false |
WithTop.instUniqueOfIsEmpty.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : IsEmpty α], WithTop.instUniqueOfIsEmpty = { toInhabited := WithTop.inhabited, uniq := ⋯ } | null | true |
LinearMap.coe_compAlternatingMap | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {N₂ : Type u_11} [inst_5 : AddCommMonoid N₂]
[inst_6 : Module R N₂] (g : N →ₗ[R] N₂) (f : M [⋀^ι]→ₗ[R] N), ⇑(g.compAlternatingMap f) = ⇑... | null | true |
Lean.MonadLog.logMessage | Lean.Log | {m : Type → Type} → [self : Lean.MonadLog m] → Lean.Message → m Unit | Log a new message. | true |
Topology.RelCWComplex.isClosed_inter_cellFrontier_succ_of_le_isClosed_inter_closedCell | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] [T2Space X] {A : Set X}
{n : ℕ},
(∀ m ≤ n, ∀ (j : Topology.RelCWComplex.cell C m), IsClosed (A ∩ Topology.RelCWComplex.closedCell m j)) →
∀ (j : Topology.RelCWComplex.cell C (n + 1)),
IsClosed (A ∩ D) → IsClosed (A ... | If for all `m ≤ n` and every `i : cell C m` the intersection `A ∩ closedCell m j` is closed
and `A ∩ D` is closed then `A ∩ cellFrontier (n + 1) j` is closed for every
`j : cell C (n + 1)`. | true |
CategoryTheory.Functor.CommShift₂.commShiftFlipObj | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
... | null | true |
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_pos_iff._simp_1_1 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (∀ (b : α), ¬a < b) = IsMax a | null | false |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.cond.match_1.eq_2 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toLCNF.etaIfUnderApplied | Lean.Compiler.LCNF.ToLCNF | Lean.Expr →
ℕ →
Lean.Compiler.LCNF.ToLCNF.M✝ (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
Lean.Compiler.LCNF.ToLCNF.M✝ (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) | Eta expand if under applied, otherwise apply k | true |
DFinsupp.Lex.addLeftStrictMono | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → AddMonoid (α i)]
[inst_2 : (i : ι) → LinearOrder (α i)] [∀ (i : ι), AddLeftStrictMono (α i)], AddLeftStrictMono (Lex (Π₀ (i : ι), α i)) | null | true |
CategoryTheory.WithInitial.incl.eq_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C],
CategoryTheory.WithInitial.incl =
{ obj := CategoryTheory.WithInitial.of, map := fun {X Y} f => f, map_id := ⋯, map_comp := ⋯ } | null | true |
OrderIso.lowerBounds_image | Mathlib.Order.Bounds.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set α},
lowerBounds (⇑f '' s) = ⇑f '' lowerBounds s | null | true |
Convexity.ConvexSpace.AffineMap.const | Mathlib.Geometry.Convex.ConvexSpace.AffineMap | {R : Type u_1} →
[inst : PartialOrder R] →
[inst_1 : Semiring R] →
[inst_2 : IsStrictOrderedRing R] →
{X : Type u_2} →
{Y : Type u_3} →
[inst_3 : Convexity.ConvexSpace R X] →
[inst_4 : Convexity.ConvexSpace R Y] → Y → Convexity.ConvexSpace.AffineMap R X Y | A constant map between convex spaces, as a bundled affine map. | true |
Set.image_op_add | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Add α] {s t : Set α}, AddOpposite.op '' (s + t) = AddOpposite.op '' t + AddOpposite.op '' s | null | true |
Bool.instCommutativeAnd | Init.Data.Bool | Std.Commutative fun x1 x2 => x1 && x2 | null | true |
Std.Tactic.BVDecide.BVUnOp.rotateLeft.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {n n_1 : ℕ}, Std.Tactic.BVDecide.BVUnOp.rotateLeft n = Std.Tactic.BVDecide.BVUnOp.rotateLeft n_1 → n = n_1 | null | true |
instFullPreordCatPreordToCat | Mathlib.Order.Category.Preord | preordToCat.Full | null | true |
Set.powersetCard.coe_addActionHom_of_embedding | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : AddGroup G] (α : Type u_2) [inst_1 : AddAction G α] {n : ℕ} [inst_2 : DecidableEq α]
(f : Fin n ↪ α), ↑((Set.powersetCard.addActionHom_of_embedding G α n).toFun f) = Finset.map f Finset.univ | null | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.map_dual._simp_1_2 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (t ⊆ f '' s) = ∃ u ⊆ s, f '' u = t | null | false |
_private.Mathlib.Data.Matrix.Basis.0.Matrix.single_mem_matrix._simp_1_1 | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {S : Set α} {M : Matrix m n α},
(M ∈ S.matrix) = ∀ (i : m) (j : n), M i j ∈ S | null | false |
_private.Mathlib.Data.ZMod.Basic.0.ZMod.coprime_mod_iff_coprime._proof_1_1 | Mathlib.Data.ZMod.Basic | ∀ (m n : ℕ), (m % n).gcd n = m.gcd n → ((m % n).gcd n = 1 ↔ m.gcd n = 1) | null | false |
Lean.Compiler.LCNF.SpecState | Lean.Compiler.LCNF.SpecInfo | Type | null | true |
AlgebraicGeometry.Opens.isDominant_homOfLE | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | ∀ {X : AlgebraicGeometry.Scheme} {U V : X.Opens},
Dense ↑U → ∀ (hU' : U ≤ V), AlgebraicGeometry.IsDominant (X.homOfLE hU') | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt64.toUInt16_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
KaehlerDifferential.submodule_span_range_eq_ideal | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Submodule.span S (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) =
Submodule.restrictScalars S (KaehlerDifferential.ideal R S) | The kernel of `S ⊗[R] S →ₐ[R] S` is generated by `1 ⊗ s - s ⊗ 1` as an `S`-module. | true |
CategoryTheory.Functor.mapAddMonFunctor._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(D : Type u_2) [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.LaxMonoidalFunctor C D} (x : X ⟶ Y) (x_1 : Y ⟶ Z) (A : CategoryTheory.AddMon... | null | false |
TensorAlgebra.equivFreeAlgebra._proof_4 | Mathlib.LinearAlgebra.TensorAlgebra.Basis | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Nat.nth_le_of_strictMonoOn_of_mapsTo | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (f : ℕ → ℕ),
Set.MapsTo f {n | ∀ (hf : (Set.ofPred p).Finite), n < hf.toFinset.card} (Set.ofPred p) →
StrictMonoOn f {n | ∀ (hf : (Set.ofPred p).Finite), n < hf.toFinset.card} → ∀ {n : ℕ}, Nat.nth p n ≤ f n | `Nat.nth p` is the least strictly monotone function whose image is contained in
`Set.ofPred p` | true |
FreeAlgebra.Rel.add_assoc | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] {a b c : FreeAlgebra.Pre R X},
FreeAlgebra.Rel R X (a + b + c) (a + (b + c)) | null | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry!._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → [Inhabited (α × β)] → (Std.DTreeMap.Internal.Impl α fun x => β) → α × β | null | false |
Lean.Grind.AC.Seq.concat_k.eq_1 | Init.Grind.AC | ∀ (s₁ : Lean.Grind.AC.Seq),
s₁.concat_k =
Lean.Grind.AC.Seq.rec (motive := fun x => Lean.Grind.AC.Seq → Lean.Grind.AC.Seq)
(fun x s₂ => Lean.Grind.AC.Seq.cons x s₂) (fun x x_1 ih s₂ => Lean.Grind.AC.Seq.cons x (ih s₂)) s₁ | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_80 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (state : Std.Sat.AIG.toCNF.State✝ aig)
(lhs rhs : Std.Sat.AIG.Fanin) (this : lhs.gate < upper ∧ rhs.gate < upper) (rstate : Std.Sat.AIG.toCNF.State✝ aig),
Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state rstate lhs.gate ⋯ →
(Std.Sat.AIG.toCNF.Cache.ma... | null | false |
AddSubmonoid.mem_map_of_mem | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] (f : F) {S : AddSubmonoid M} {x : M},
x ∈ S → f x ∈ AddSubmonoid.map f S | null | true |
AddMagmaCat.neg_hom_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {M N : AddMagmaCat} (e : M ≅ N) (x : ↑M),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | null | true |
Aesop.SafeRulesResult.succeeded.inj | Aesop.Search.Expansion | ∀ {newRapps newRapps_1 : Array Aesop.RappRef},
Aesop.SafeRulesResult.succeeded newRapps = Aesop.SafeRulesResult.succeeded newRapps_1 → newRapps = newRapps_1 | null | true |
one_leftCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Monoid α] (s : Set α), 1 • s = s | null | true |
Lean.IR.ToIR.BuilderState.joinPoints._default | Lean.Compiler.IR.ToIR | Std.HashMap Lean.FVarId Lean.IR.JoinPointId | null | false |
_private.Init.Data.List.Nat.Erase.0.List.eraseIdx_set_lt._proof_1_2 | Init.Data.List.Nat.Erase | ∀ {α : Type u_1} {l : List α} {i j : ℕ} {a : α}, j < i → ∀ n < j, i - 1 = n → False | null | false |
ENat.sub_iInf | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_2} {f : ι → ℕ∞} {a : ℕ∞}, a - ⨅ i, f i = ⨆ i, a - f i | null | true |
PowerBasis.map | Mathlib.RingTheory.PowerBasis | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
{S' : Type u_6} →
[inst_3 : CommRing S'] → [inst_4 : Algebra R S'] → PowerBasis R S → (S ≃ₐ[R] S') → PowerBasis R S' | `PowerBasis.map pb (e : S ≃ₐ[R] S')` is the power basis for `S'` generated by `e pb.gen`. | true |
_private.Batteries.Data.List.Basic.0.List.forall₂_cons.match_1_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : α} {b : β} {l₁ : List α} {l₂ : List β}
(motive : List.Forall₂ R (a :: l₁) (b :: l₂) → Prop) (x : List.Forall₂ R (a :: l₁) (b :: l₂)),
(∀ (h : R a b) (tail : List.Forall₂ R l₁ l₂), motive ⋯) → motive x | null | false |
Lean.Server.RequestError.rec | Lean.Server.Requests | {motive : Lean.Server.RequestError → Sort u} →
((code : Lean.JsonRpc.ErrorCode) → (message : String) → motive { code := code, message := message }) →
(t : Lean.Server.RequestError) → motive t | null | false |
NonemptyInterval.toDualProd_injective | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α], Function.Injective NonemptyInterval.toDualProd | null | true |
_private.Batteries.Data.List.Lemmas.0.List.mem_findIdxs_iff_getElem_sub_pos._proof_1_7 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} (head : α) (tail : List α) {s : ℕ},
-1 * ↑i + ↑s ≤ 0 → i - s + 1 ≤ (head :: tail).length → -1 * ↑i + ↑s + 1 ≤ 0 → i - (s + 1) < tail.length | null | false |
CategoryTheory.Equivalence.symmEquivInverse_obj_functor | Mathlib.CategoryTheory.Equivalence.Symmetry | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] (D : Type u_2)
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (X : (D ≌ C)ᵒᵖ),
((CategoryTheory.Equivalence.symmEquivInverse C D).obj X).functor = (Opposite.unop X).inverse | null | true |
Std.Http.Internal.ChunkedBuffer.instCoeArrayByteArray | Std.Http.Internal.ChunkedBuffer | Coe (Array ByteArray) Std.Http.Internal.ChunkedBuffer | null | true |
_private.Mathlib.Data.Finset.SymmDiff.0.Finset.mem_symmDiff._simp_1_1 | Mathlib.Data.Finset.SymmDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.