name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
NormedAlgebra.toAlgebra | Mathlib.Analysis.Normed.Module.Basic | {𝕜 : Type u_6} →
{𝕜' : Type u_7} → {inst : NormedField 𝕜} → {inst_1 : SeminormedRing 𝕜'} → [self : NormedAlgebra 𝕜 𝕜'] → Algebra 𝕜 𝕜' | null | true |
Polynomial.X_pow_add_C_ne_zero | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [Nontrivial R] [inst : Semiring R] {n : ℕ}, 0 < n → ∀ (a : R), Polynomial.X ^ n + Polynomial.C a ≠ 0 | null | true |
_private.Mathlib.LinearAlgebra.Matrix.RowCol.0.Matrix.updateCol_submatrix_equiv._simp_1_1 | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} (A : Matrix m n α) (r : l → m) (c : o → n),
A.transpose.submatrix c r = (A.submatrix r c).transpose | null | false |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_succ._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, ¬xs = [] → 0 < xs.length | null | false |
Matrix.adjugate.congr_simp | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} {α : Type w} {inst : DecidableEq n} [inst_1 : DecidableEq n] [inst_2 : Fintype n] [inst_3 : CommRing α]
(A A_1 : Matrix n n α),
A = A_1 → ∀ (a a_1 : n), a = a_1 → ∀ (a_2 a_3 : n), a_2 = a_3 → A.adjugate a a_2 = A_1.adjugate a_1 a_3 | null | true |
AddMonoidHom.closure_preimage_le | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] (f : G →+ N) (s : Set N),
AddSubgroup.closure (⇑f ⁻¹' s) ≤ AddSubgroup.comap f (AddSubgroup.closure s) | null | true |
WithLp.prod_continuous_toLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β],
Continuous (WithLp.toLp p) | null | true |
ListSlice.toArray_mkSlice_roi_eq_toArray_mkSlice_rco | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α} {lo : ℕ},
Std.Slice.toArray (Std.Roi.Sliceable.mkSlice xs (lo<...*)) =
Std.Slice.toArray (Std.Rco.Sliceable.mkSlice xs (lo + 1...Std.Slice.size xs)) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.Gamma_add_one._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.Data.Fin.VecNotation.0.Matrix.cons_swap._proof_1_2 | Mathlib.Data.Fin.VecNotation | ∀ {n : ℕ} (i : Fin n) (k : Fin n.succ), ↑k - 1 < n | null | false |
Std.Internal.List.List.getValueD_filter_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((_ : α) × β)} {k : α} {fallback : β},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.getValueD k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) fallback =
if Std.Internal.List.containsKey k l₂ = true then Std.I... | null | true |
LinearMap.BilinForm.toMatrixAux._proof_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} [inst : CommSemiring R₁], SMulCommClass R₁ R₁ R₁ | null | false |
Bool.or_eq_true | Init.SimpLemmas | ∀ (a b : Bool), ((a || b) = true) = (a = true ∨ b = true) | null | true |
SkewPolynomial.C_inj | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] {a b : R}, SkewPolynomial.C a = SkewPolynomial.C b ↔ a = b | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int16.reduceNeg._regBuiltin.Int16.reduceNeg.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.1259268813._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
RatFunc.toFractionRingRingEquiv.eq_1 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u) [inst : CommRing K],
RatFunc.toFractionRingRingEquiv K =
{ toFun := RatFunc.toFractionRing, invFun := RatFunc.ofFractionRing, left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯,
map_add' := ⋯ } | null | true |
Std.Internal.ForIn.toList_rcc | Std.Internal.ForIn.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxc.IsAlwaysFinite α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLE α] (r : Std.Rcc α), ForIn.toList r = r.toList | null | true |
Encodable.decodeSubtype.eq_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {P : α → Prop} [encA : Encodable α] [decP : DecidablePred P] (v : ℕ),
Encodable.decodeSubtype v = (Encodable.decode v).bind fun a => if h : P a then some ⟨a, h⟩ else none | null | true |
List.take_eq_append_getElem_of_pos | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α} (h₁ : 0 < i) (h₂ : i < l.length),
List.take i l = List.take (i - 1) l ++ [l[i - 1]] | null | true |
Lean.Meta.ACLt.ReduceMode.reduce.elim | Lean.Meta.ACLt | {motive : Lean.Meta.ACLt.ReduceMode → Sort u} →
(t : Lean.Meta.ACLt.ReduceMode) → t.ctorIdx = 0 → motive Lean.Meta.ACLt.ReduceMode.reduce → motive t | null | false |
CategoryTheory.Mon.id | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → (M : CategoryTheory.Mon C) → M.Hom M | The identity morphism on a monoid object. | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.success.noConfusion | Mathlib.Tactic.TacticAnalysis.Declarations | {P : Sort u} →
{stx stx' : Lean.TSyntax `tactic} →
Mathlib.TacticAnalysis.TerminalReplacementOutcome.success✝ stx =
Mathlib.TacticAnalysis.TerminalReplacementOutcome.success✝ stx' →
(stx = stx' → P) → P | null | false |
Finsupp.instPosSMulReflectLE | Mathlib.Data.Finsupp.Order | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : Zero β]
[inst_3 : Preorder β] [inst_4 : SMulZeroClass α β] [PosSMulReflectLE α β], PosSMulReflectLE α (ι →₀ β) | null | true |
GaloisCoinsertion.u_biSup_of_lu_eq_self | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {u : α → β} {l : β → α} [inst : CompleteLattice α] [inst_1 : CompleteLattice β]
(gi : GaloisCoinsertion l u) {ι : Sort x} {p : ι → Prop} (f : (i : ι) → p i → α),
(∀ (i : ι) (hi : p i), l (u (f i hi)) = f i hi) → u (⨆ i, ⨆ (hi : p i), f i hi) = ⨆ i, ⨆ (hi : p i), u (f i hi) | **Alias** of `GaloisCoinsertion.u_biSup_of_l_u_eq_self`. | true |
Additive.addCommSemigroup | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [CommSemigroup α] → AddCommSemigroup (Additive α) | null | true |
Option._sizeOf_inst | Init.SizeOf | (α : Type u) → [SizeOf α] → SizeOf (Option α) | null | false |
OrderDual.sbtw | Mathlib.Order.Circular | (α : Type u_1) → [h : SBtw α] → SBtw αᵒᵈ | null | true |
SimpleGraph.Dart.symm_involutive._simp_1 | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} {G : SimpleGraph V}, Function.Involutive SimpleGraph.Dart.symm = True | null | false |
FinPartOrd.dual_map | Mathlib.Order.Category.FinPartOrd | ∀ {X Y : FinPartOrd} (f : X ⟶ Y), FinPartOrd.dual.map f = FinPartOrd.ofHom (OrderHom.dual (PartOrd.Hom.hom f.hom)) | null | true |
CommSemiRingCat.fullyFaithfulForget₂ToSemiRingCat._proof_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y : CommSemiRingCat}
(f :
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat).obj X ⟶
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat).obj Y),
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat).map (CommSemiRingCat.ofHom (SemiRingCat.Hom.hom f)) = f | null | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.State.casesOn | Lean.Compiler.LCNF.ExplicitRC | {motive : Lean.Compiler.LCNF.State✝ → Sort u} →
(t : Lean.Compiler.LCNF.State✝) →
((liveVars : Lean.Compiler.LCNF.LiveVars✝) → motive { liveVars := liveVars }) → motive t | null | false |
Std.IterM.toListRev_filterMapWithPostcondition | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] {f : β → Std.Iterators.PostconditionT m (Option γ)} (it : Std.IterM Id β),
(Std.IterM.filterMapWithPostcondition f it).toListRev =
List.reverse <$> List.filterMapM (fun x => (f x... | null | true |
Fin.exists_iff_castSucc | Mathlib.Data.Fin.Tuple.Basic | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∃ i, P i) ↔ P (Fin.last n) ∨ ∃ i, P i.castSucc | null | true |
isAddQuotientCoveringMap_quotientMk_of_properlyDiscontinuousVAdd | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_1} [inst : TopologicalSpace E] {G : Type u_3} [inst_1 : AddGroup G] [inst_2 : AddAction G E]
[ContinuousConstVAdd G E] [ProperlyDiscontinuousVAdd G E] [LocallyCompactSpace E] [T2Space E] [IsCancelVAdd G E],
IsAddQuotientCoveringMap (Quotient.mk (AddAction.orbitRel G E)) G | null | true |
CartanMatrix.A | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | (n : ℕ) → Matrix (Fin n) (Fin n) ℤ | The Cartan matrix of type Aₙ₋₁ (rank n-1, corresponding to sl(n)). | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.Path.rootOrdered_iff._simp_1_2 | Batteries.Recycling.RBTree.Lemmas | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Submodule.Quotient.equiv._proof_2 | Mathlib.LinearAlgebra.Quotient.Basic | ∀ {R : Type u_2} [inst : Ring R] {R₂ : Type u_4} [inst_1 : Ring R₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M : Type u_1} {N : Type u_3}
[inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N] [inst_7 : Module R₂ N] (P : Submodule R M)... | null | false |
Lean.Meta.GeneralizeArg.noConfusion | Lean.Meta.Tactic.Generalize | {P : Sort u} → {t t' : Lean.Meta.GeneralizeArg} → t = t' → Lean.Meta.GeneralizeArg.noConfusionType P t t' | null | false |
ModuleCat.restrictScalarsIsoOfEquiv_inv_apply | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R S : Type v} [inst : Ring R] [inst_1 : Ring S] (e : R ≃+* S) (x : R),
(CategoryTheory.ConcreteCategory.hom (ModuleCat.restrictScalarsIsoOfEquiv e).inv) x = e x | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Expr → Lean.Expr → Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | An equality `a = b` coming from the core.
`p₁` and `p₂` are the polynomials corresponding to `a` and `b`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.average_density_near_total_density | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} [Nonempty α],
P.parts.card * 16 ^ P.parts.card ≤ Fintype.card α →
100 ≤ 4 ^ P.parts.card * ε ^ 5 →
ε ≤ 1 →
... | null | true |
Nat.preimage_Ici | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R},
Nat.cast ⁻¹' Set.Ici a = Set.Ici ⌈a⌉₊ | null | true |
Mathlib.Command.MinImports.getId | Mathlib.Tactic.MinImports | Lean.Syntax → Lean.Elab.Command.CommandElabM Lean.Syntax | `getId stx` takes as input a `Syntax` `stx`.
If `stx` contains a `declId`, then it returns the `ident`-syntax for the `declId`.
If `stx` is a nameless instance, then it also tries to fetch the `ident` for the instance.
Otherwise it returns `.missing`. | true |
Dynamics.netMaxcard.eq_1 | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} (T : X → X) (F : Set X) (U : SetRel X X) (n : ℕ),
Dynamics.netMaxcard T F U n = ⨆ s, ⨆ (_ : Dynamics.IsDynNetIn T F U n ↑s), ↑s.card | null | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.Basic.0.Set.preimage_nsmul_subset.match_1_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt16.ofNat_add._simp_1_1 | Init.Data.UInt.Lemmas | ∀ (a : ℕ) (b : UInt16), (UInt16.ofNat a = b) = (a % 2 ^ 16 = b.toNat) | null | false |
MeasureTheory.Lp.instModule._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_2} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E] (x y : 𝕜)
(b : ↥(MeasureTheory.Lp E p μ)), (x * y) • b = x • y • b | null | false |
Lean.Export.alloc | Mathlib.Util.Export | {α : Type} → [inst : BEq α] → [inst_1 : Hashable α] → [Lean.Export.OfState α] → α → Lean.ExportM ℕ | null | true |
_private.Mathlib.MeasureTheory.Measure.Regular.0.Set.measure_eq_iInf_isOpen._simp_1_2 | Mathlib.MeasureTheory.Measure.Regular | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
CategoryTheory.IsCofiltered.of_hasInitial | Mathlib.CategoryTheory.Filtered.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasInitial C],
CategoryTheory.IsCofiltered C | null | true |
_private.Mathlib.NumberTheory.Divisors.0.Int.mem_divisors_iff_natAbs_mem_divisors_natAbs._proof_1_4 | Mathlib.NumberTheory.Divisors | ∀ {x : ℤ} (y : ℕ), ↑y = x ∨ -↑y = x ↔ y = x.natAbs | null | false |
CategoryTheory.Preadditive.ofFullyFaithful._proof_3 | Mathlib.CategoryTheory.Preadditive.Transfer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Preadditive D]
{F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
CategoryTheory.CategoryStruct.comp (f + f') g =
... | null | false |
AdicCompletion.mkₐ_apply_coe | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (a : AdicCompletion.AdicCauchySequence I R) (n : ℕ),
↑((AdicCompletion.mkₐ I) a) n = (Ideal.Quotient.mk (I ^ n • ⊤)) (↑a n) | null | true |
AdjoinRoot.adjoinRoot_eq_top | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R}, R[AdjoinRoot.root f] = ⊤ | null | true |
ProbabilityTheory.partitionFiltration | Mathlib.Probability.Process.PartitionFiltration | {α : Type u_1} →
[m : MeasurableSpace α] → {t : ℕ → Set α} → (∀ (n : ℕ), MeasurableSet (t n)) → MeasureTheory.Filtration ℕ m | A filtration built from the measurable spaces generated by the partitions `memPartition t n` for
all `n : ℕ`. | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.rightInvSeq_concat._simp_1_5 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {G : Type u_3} [inst : Group G] (a : G) (m n : ℤ), a ^ m * a ^ n = a ^ (m + n) | null | false |
_private.Mathlib.Topology.Order.IntermediateValue.0.setOfPred_isPreconnected_subset_of_ordered._simp_1_6 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} {f : α → β → γ} {a : α} {b : β}, (∃ x y, f x y = f a b) = True | null | false |
Pi.instNoMaxOrderLexForallOfWellFoundedLTOfNonempty | Mathlib.Order.PiLex | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : LinearOrder ι] [WellFoundedLT ι] [Nonempty ι]
[inst_3 : (i : ι) → PartialOrder (β i)] [∀ (i : ι), NoMaxOrder (β i)], NoMaxOrder (Lex ((i : ι) → β i)) | null | true |
jacobsonSpace_iff | Mathlib.Topology.JacobsonSpace | ∀ (X : Type u_1) [inst : TopologicalSpace X],
JacobsonSpace X ↔ ∀ {Z : Set X}, IsClosed Z → closure (Z ∩ closedPoints X) = Z | null | true |
instAddMonoidUniformFun._proof_2 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid β] (a : UniformFun α β), 0 + a = a | null | false |
Order.Ideal.mem_sup._simp_1 | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : SemilatticeSup P] [inst_1 : IsCodirectedOrder P] {x : P} {I J : Order.Ideal P},
(x ∈ I ⊔ J) = ∃ i ∈ I, ∃ j ∈ J, x ≤ i ⊔ j | null | false |
TopCat.toSSetObj₀Equiv_symm_apply | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | ∀ {X : TopCat} (a : ↑X),
TopCat.toSSetObj₀Equiv.symm a =
(X.toSSetObjEquiv (Opposite.op { len := 0 })).symm { toFun := fun x => a, continuous_toFun := ⋯ } | null | true |
_private.Lean.Compiler.LCNF.FloatLetIn.0.Lean.Compiler.LCNF.FloatLetIn.initialDecisions.visitArg | Lean.Compiler.LCNF.FloatLetIn | Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure →
Bool → StateRefT' IO.RealWorld (Std.HashSet Lean.FVarId) Lean.Compiler.LCNF.CompilerM Bool | null | true |
_private.Mathlib.RingTheory.Jacobson.Ring.0.MvPolynomial.quotient_mk_comp_C_isIntegral_of_isJacobsonRing' | Mathlib.RingTheory.Jacobson.Ring | ∀ {n : ℕ} {R : Type u_1} [inst : CommRing R] [IsJacobsonRing R] (P : Ideal (MvPolynomial (Fin n) R)),
P.IsMaximal → (algebraMap R (MvPolynomial (Fin n) R ⧸ P)).IsIntegral | null | true |
_private.Lean.Meta.Tactic.Split.0.Lean.Meta.Split.applyMatchSplitter.match_1 | Lean.Meta.Tactic.Split | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((uElimPos : ℕ) → motive (some uElimPos)) → ((x : Option ℕ) → motive x) → motive x | null | false |
ENat.lt_add_one_iff' | Mathlib.Order.SuccPred.ENat | ∀ {m n : ℕ∞}, m ≠ ⊤ → (m < n + 1 ↔ m ≤ n) | null | true |
Nat.pred_lt_self | Init.Data.Nat.Basic | ∀ {a : ℕ}, 0 < a → a.pred < a | null | true |
Mathlib.Tactic.BicategoryLike.instInhabitedHorizontalComp | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Inhabited Mathlib.Tactic.BicategoryLike.HorizontalComp | null | true |
_private.Init.Data.Int.Lemmas.0.Int.neg_ofNat_eq_negSucc_add_one_iff._simp_1_1 | Init.Data.Int.Lemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.mkImpCongr._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.Types | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.Set.Card.0.Set.encard_eq_four.match_1_1 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}
(motive : (∃ x y z w, x ≠ y ∧ x ≠ z ∧ x ≠ w ∧ y ≠ z ∧ y ≠ w ∧ z ≠ w ∧ s = {x, y, z, w}) → Prop)
(x : ∃ x y z w, x ≠ y ∧ x ≠ z ∧ x ≠ w ∧ y ≠ z ∧ y ≠ w ∧ z ≠ w ∧ s = {x, y, z, w}),
(∀ (x y z w : α) (hxy : x ≠ y) (hxz : x ≠ z) (hxw : x ≠ w) (hyz : y ≠ z) (hyw : y ≠ w) (hzw : z ≠ w)
... | null | false |
MonoidAlgebra.support_gen_of_gen' | Mathlib.RingTheory.FiniteType | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : Monoid M] {S : Set (MonoidAlgebra R M)},
Algebra.adjoin R S = ⊤ → Algebra.adjoin R (⇑(MonoidAlgebra.of R M) '' ⋃ f ∈ S, ↑f.coeff.support) = ⊤ | If a set `S` generates, as algebra, `R[M]`, then the image of the union of the
supports of elements of `S` generates `R[M]`. | true |
Nat.bit_cases_on_inj._simp_1 | Mathlib.Data.Nat.Bits | ∀ {motive : ℕ → Sort u} (H₁ H₂ : (b : Bool) → (n : ℕ) → motive (Nat.bit b n)),
((fun n => Nat.bitCasesOn n H₁) = fun n => Nat.bitCasesOn n H₂) = (H₁ = H₂) | null | false |
Lean.Lsp.LeanImportKind.recOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanImportKind → Sort u} →
(t : Lean.Lsp.LeanImportKind) →
((isPrivate isAll : Bool) →
(metaKind : Lean.Lsp.LeanImportMetaKind) →
motive { isPrivate := isPrivate, isAll := isAll, metaKind := metaKind }) →
motive t | null | false |
CategoryTheory.GrothendieckTopology.Covers.eq_1 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (J : CategoryTheory.GrothendieckTopology C)
(S : CategoryTheory.Sieve X) (f : Y ⟶ X), J.Covers S f = (CategoryTheory.Sieve.pullback f S ∈ J Y) | null | true |
norm_le_pi_norm' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_5} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (G i)] (f : (i : ι) → G i)
(i : ι), ‖f i‖ ≤ ‖f‖ | null | true |
ContinuousAddEquiv.mulLeft._proof_3 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [IsTopologicalSemiring R] (r : Rˣ),
Continuous fun x => ↑r⁻¹ * x | null | false |
Fin.appendIsometryOfEq_symm_apply | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {n m l : ℕ} (hmln : m + l = n) (a : Fin n → α),
(Fin.appendIsometryOfEq hmln).symm a =
(fun i => a (Fin.cast hmln (Fin.castAdd l i)), fun i => a (Fin.cast hmln (Fin.natAdd m i))) | null | true |
CochainComplex.mappingConeCompHomotopyEquiv_comm₂_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃)
{Z : HomologicalComplex C (ComplexShape.up ℤ)}
(h :
(CategoryTheory.shiftFunctor (CochainCompl... | null | true |
InnerProductSpace.toDualMap._proof_6 | Mathlib.Analysis.InnerProductSpace.Dual | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousAdd 𝕜 | null | false |
CategoryTheory.Cokleisli.Adjunction.toCokleisli._proof_2 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (U : CategoryTheory.Comonad C) (X : C),
{ of := CategoryTheory.CategoryStruct.comp (U.ε.app X) (CategoryTheory.CategoryStruct.id X) } =
CategoryTheory.CategoryStruct.id { of := X } | null | false |
Lean.Elab.Term.backward.proofsInPublic | Lean.Elab.SyntheticMVars | Lean.Option Bool | null | true |
variationOnFromTo.abs_le_eVariationOn | Mathlib.Topology.EMetricSpace.VariationOnFromTo | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : TopologicalSpace E] [inst_2 : WeakPseudoEMetricSpace E]
{f : α → E} {s : Set α}, BoundedVariationOn f s → ∀ {a b : α}, |variationOnFromTo f s a b| ≤ (eVariationOn f s).toReal | null | true |
Lean.JsonRpc.Message.response.sizeOf_spec | Lean.Data.JsonRpc | ∀ (id : Lean.JsonRpc.RequestID) (result : Lean.Json),
sizeOf (Lean.JsonRpc.Message.response id result) = 1 + sizeOf id + sizeOf result | null | true |
Order.Ideal.instMin._proof_3 | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : SemilatticeSup P] (I J : Order.Ideal P),
∀ x ∈ (I.toLowerSet ⊓ J.toLowerSet).carrier,
∀ y ∈ (I.toLowerSet ⊓ J.toLowerSet).carrier, ∃ z ∈ (I.toLowerSet ⊓ J.toLowerSet).carrier, x ≤ z ∧ y ≤ z | null | false |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandDbgTrace._regBuiltin.Lean.Elab.Term.expandDbgTrace_1 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
Lean.Compiler.LCNF.Simp.FunDeclInfo.casesOn | Lean.Compiler.LCNF.Simp.FunDeclInfo | {motive : Lean.Compiler.LCNF.Simp.FunDeclInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.FunDeclInfo) →
motive Lean.Compiler.LCNF.Simp.FunDeclInfo.once →
motive Lean.Compiler.LCNF.Simp.FunDeclInfo.many → motive Lean.Compiler.LCNF.Simp.FunDeclInfo.mustInline → motive t | null | false |
ContIntertwiningMap.noConfusionType | Mathlib.RepresentationTheory.Continuous.Basic | Sort u →
{R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
... | null | false |
CategoryTheory.Limits.WalkingPair.swap_apply_right | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | CategoryTheory.Limits.WalkingPair.swap CategoryTheory.Limits.WalkingPair.right = CategoryTheory.Limits.WalkingPair.left | null | true |
List.minimum | Mathlib.Data.List.MinMax | {α : Type u_1} → [inst : Preorder α] → [DecidableLT α] → List α → WithTop α | `minimum l` returns a `WithTop α`, the smallest element of `l` for nonempty lists, and `⊤` for
`[]` | true |
latToBddLatForgetAdjunction._proof_8 | Mathlib.Order.Category.BddLat | ∀ {X : Lat} {Y Y' : BddLat} (x : latToBddLat.obj X ⟶ Y) (x_1 : Y ⟶ Y'),
{
toFun := fun f =>
Lat.ofHom { toFun := ⇑(CategoryTheory.ConcreteCategory.hom f) ∘ some ∘ some, map_sup' := ⋯, map_inf' := ⋯ },
invFun := fun f => BddLat.ofHom (Lat.Hom.hom f).withTopWithBot', left_inv := ⋯, right_inv :... | null | false |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.isPlausibleIndirectOutput_iff._simp_1_2 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerable α] {it : Std.IterM Id α} {out : α},
it.IsPlausibleIndirectOutput out =
∃ n, (it.internalState.next.bind fun x => Std.PRange.succMany? n x) = s... | null | false |
RootPairing.GeckConstruction.ωConj._proof_1 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : DecidableEq ι] [inst_6 : Fintype ι] (x y : Matrix (↥b.support ⊕ ι) (↥b.support ⊕ ι) R),
... | null | false |
Lean.Meta.ExprConfigCacheKey.configKey | Lean.Meta.Basic | Lean.Meta.ExprConfigCacheKey → UInt64 | null | true |
Coalgebra.Repr.induced_right | Mathlib.RingTheory.Coalgebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} {ι : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : Coalgebra R A]
[inst_6 : Coalgebra R B] {a : A} (repr : Coalgebra.Repr R a ι) {F : Type u_2} [inst_7 : FunLike F A B]
[inst_8 ... | null | true |
CategoryTheory.skeleton_isSkeleton | Mathlib.CategoryTheory.Skeletal | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.IsSkeletonOf C (CategoryTheory.Skeleton C) (CategoryTheory.fromSkeleton C) | The `skeleton` of `C` given by choice is a skeleton of `C`. | true |
Lean.Elab.Term.Quotation.elabQuot._@.Lean.Elab.Quotation.3282600398._hygCtx._hyg.3 | Lean.Elab.Quotation | Lean.Elab.Term.TermElab | null | false |
CategoryTheory.Limits.binaryCofanZeroLeftIsColimit._proof_4 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] (X : C)
(s : CategoryTheory.Limits.BinaryCofan 0 X) (m : X ⟶ s.pt),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) m = s.inr → m = s.inr | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.fTypeIsForall._sparseCasesOn_1 | Lean.Elab.App | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
QuadraticAlgebra.mapRingHom_star | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_3} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (a b : R)
(x : QuadraticAlgebra R a b),
(QuadraticAlgebra.mapRingHom f a b) (star x) = star ((QuadraticAlgebra.mapRingHom f a b) x) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.