name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.DTreeMap.Const.compare_minKey?_modify_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : β → β} {km kmm : α} (hkm : t.minKey? = some km),
(Std.DTreeMap.Const.modify t k f).minKey?.get ⋯ = kmm → cmp kmm km = Ordering.eq |
EST.Out.noConfusion | Init.System.ST | {P : Sort u} →
{ε σ α : Type} →
{t : EST.Out ε σ α} →
{ε' σ' α' : Type} → {t' : EST.Out ε' σ' α'} → ε = ε' → σ = σ' → α = α' → t ≍ t' → EST.Out.noConfusionType P t t' |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanMap.match_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u_4} →
{C : Type u_5} →
[inst : CategoryTheory.Category.{u_2, u_4} C₀] →
[inst_1 : CategoryTheory.Category.{u_3, u_5} C] →
{F : CategoryTheory.Functor C₀ C} →
{X : C} →
(data : F.PreOneHypercoverDenseData X) →
(motive : CategoryTheory.Limits.WalkingMulticospan data.multicospanShape → Sort u_6) →
(x : CategoryTheory.Limits.WalkingMulticospan data.multicospanShape) →
((i : data.multicospanShape.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((j : data.multicospanShape.R) → motive (CategoryTheory.Limits.WalkingMulticospan.right j)) →
motive x |
_private.Lean.Compiler.LCNF.Passes.0.Lean.Compiler.LCNF.addPass._sparseCasesOn_3 | Lean.Compiler.LCNF.Passes | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
Topology.IsClosedEmbedding.comp | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {f : X → Y} {g : Y → Z} [inst : TopologicalSpace X]
[inst_1 : TopologicalSpace Y] [inst_2 : TopologicalSpace Z],
Topology.IsClosedEmbedding g → Topology.IsClosedEmbedding f → Topology.IsClosedEmbedding (g ∘ f) |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstanceImp | Lean.Meta.Basic | {α : Type} → Lean.Name → Lean.Expr → Lean.MetaM α → Lean.MetaM α |
Simps.ProjectionData.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {name : Lean.Name} {expr : Lean.Expr} {projNrs : List ℕ} {isDefault isPrefix : Bool} {name_1 : Lean.Name}
{expr_1 : Lean.Expr} {projNrs_1 : List ℕ} {isDefault_1 isPrefix_1 : Bool},
{ name := name, expr := expr, projNrs := projNrs, isDefault := isDefault, isPrefix := isPrefix } =
{ name := name_1, expr := expr_1, projNrs := projNrs_1, isDefault := isDefault_1, isPrefix := isPrefix_1 } →
name = name_1 ∧ expr = expr_1 ∧ projNrs = projNrs_1 ∧ isDefault = isDefault_1 ∧ isPrefix = isPrefix_1 |
instContinuousNegElemBallOfNat | Mathlib.Analysis.Normed.Group.BallSphere | ∀ {E : Type u_1} [i : SeminormedAddCommGroup E] {r : ℝ}, ContinuousNeg ↑(Metric.ball 0 r) |
Std.Time.TimeZone.GMT | Std.Time.Zoned.TimeZone | Std.Time.TimeZone |
Coalgebra.Repr.mk.sizeOf_spec | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] {a : A} [inst_4 : SizeOf R] [inst_5 : SizeOf A] {ι : Type u_1} (index : Finset ι)
(left right : ι → A) (eq : ∑ i ∈ index, left i ⊗ₜ[R] right i = CoalgebraStruct.comul a),
sizeOf { ι := ι, index := index, left := left, right := right, eq := eq } = 1 + sizeOf ι + sizeOf index + sizeOf eq |
Action.res._proof_2 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_4} {H : Type u_3} [inst_1 : Monoid G]
[inst_2 : Monoid H] (f : G →* H) {X Y Z : Action V H} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
{ hom := (CategoryTheory.CategoryStruct.comp f_1 g).hom, comm := ⋯ } =
CategoryTheory.CategoryStruct.comp { hom := f_1.hom, comm := ⋯ } { hom := g.hom, comm := ⋯ } |
CategoryTheory.ComonObj._aux_Mathlib_CategoryTheory_Monoidal_Comon____unexpand_CategoryTheory_ComonObj_comul_1 | Mathlib.CategoryTheory.Monoidal.Comon_ | Lean.PrettyPrinter.Unexpander |
_private.Mathlib.Data.Finset.Sups.0.Finset.filter_sups_le._simp_1_2 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ s) = (a ∈ ↑s) |
IsUnit.unit_map | Mathlib.Algebra.Group.Units.Hom | ∀ {F : Type u_1} {M : Type u_3} {N : Type u_4} [inst : FunLike F M N] [inst_1 : Monoid M] [inst_2 : Monoid N]
[inst_3 : MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x), ↑⋯.unit = f ↑h.unit |
Char.succ?_eq | Init.Data.Char.Ordinal | ∀ {c : Char}, c.succ? = Option.map Char.ofOrdinal (c.ordinal.addNat? 1) |
PartialEquiv.transEquiv_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : PartialEquiv α β) (f' : β ≃ γ),
(e.transEquiv f').target = ⇑f'.symm ⁻¹' e.target |
PerfectClosure.lift._proof_3 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] (L : Type u_2)
[inst_3 : CommSemiring L] [inst_4 : CharP L p] [inst_5 : PerfectRing L p],
Function.LeftInverse (fun f => f.comp (PerfectClosure.of K p)) fun f =>
{ toFun := fun e => e.liftOn (fun x => (⇑(frobeniusEquiv L p).symm)^[x.1] (f x.2)) ⋯, map_one' := ⋯, map_mul' := ⋯,
map_zero' := ⋯, map_add' := ⋯ } |
mul_neg_mem | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Mul R] [inst_1 : HasDistribNeg R] [inst_2 : SetLike S R] [MulMemClass S R]
{s : S} {x y : R}, x ∈ s → -y ∈ s → -(x * y) ∈ s |
Set.Iic_union_Ici | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a : α}, Set.Iic a ∪ Set.Ici a = Set.univ |
LLVM.moduleToString | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Module ctx → BaseIO String |
Real.exp_neg_one_lt_d9 | Mathlib.Analysis.Complex.ExponentialBounds | Real.exp (-1) < 0.3678794412 |
subset_supClosure | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeSup α] {s : Set α}, s ⊆ supClosure s |
Function.support_mul' | Mathlib.Algebra.GroupWithZero.Indicator | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] (f g : ι → M₀),
Function.support (f * g) = Function.support f ∩ Function.support g |
Homeomorph.contractibleSpace_iff | Mathlib.Topology.Homotopy.Contractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ₜ Y),
ContractibleSpace X ↔ ContractibleSpace Y |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_1.eq_2 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3) (it : Std.IterM m α)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.skip it with
| Std.IterStep.yield it' out => h_1 it' out
| Std.IterStep.skip it => h_2 it
| Std.IterStep.done => h_3 ()) =
h_2 it |
List.IsChain.nil._simp_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} {R : α → α → Prop}, List.IsChain R [] = True |
Matrix.GeneralLinearGroup.upperRightHom._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {R : Type u_1} [inst : Ring R] (x : R), !![1, x; 0, 1] * !![1, -x; 0, 1] = 1 |
AddSubmonoid.map_comap_map | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (S : AddSubmonoid M) {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
AddSubmonoid.map f (AddSubmonoid.comap f (AddSubmonoid.map f S)) = AddSubmonoid.map f S |
Lean.Compiler.LCNF.PullLetDecls.State.noConfusion | Lean.Compiler.LCNF.PullLetDecls | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.PullLetDecls.State} → t = t' → Lean.Compiler.LCNF.PullLetDecls.State.noConfusionType P t t' |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Rat.padicValuation_le_one_iff._simp_1_4 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {α : Type u_1} [inst : LinearOrderedCommMonoidWithZero α] {a : α}, (0 < a) = (a ≠ 0) |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.not_isStronglyTranscendental_of_weaklyQuasiFiniteAt._simp_1_3 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A}
{S : Subalgebra R A}, (Algebra.adjoin R s ≤ S) = (s ⊆ ↑S) |
MeasureTheory.Measure.measure_inv | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : InvolutiveInv G] [MeasurableInv G] (μ : MeasureTheory.Measure G)
[μ.IsInvInvariant] (A : Set G), μ A⁻¹ = μ A |
Filter.EventuallyLE.isMinFilter | Mathlib.Order.Filter.Extr | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] {f g : α → β} {a : α} {l : Filter α},
f ≤ᶠ[l] g → f a = g a → IsMinFilter f l a → IsMinFilter g l a |
NormedAddGroupHom.equalizer | Mathlib.Analysis.Normed.Group.Hom | {V : Type u_1} →
{W : Type u_2} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : SeminormedAddCommGroup W] → NormedAddGroupHom V W → NormedAddGroupHom V W → AddSubgroup V |
Std.Tactic.BVDecide.BVBinOp._sizeOf_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp → ℕ |
_private.Mathlib.Algebra.Homology.ShortComplex.Ab.0.CategoryTheory.ShortComplex.ab_exact_iff._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
_private.Lean.Elab.Deriving.ToExpr.0.Lean.Elab.Deriving.ToExpr.mkToTypeExpr | Lean.Elab.Deriving.ToExpr | Lean.InductiveVal → Array Lean.Name → Lean.Elab.TermElabM Lean.Term |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.«term_→ₛ_» | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | Lean.TrailingParserDescr |
Batteries.RBNode.DelProp.match_1 | Batteries.Data.RBMap.WF | (motive : Batteries.RBColor → Sort u_1) →
(p : Batteries.RBColor) → (Unit → motive Batteries.RBColor.black) → (Unit → motive Batteries.RBColor.red) → motive p |
Numbering.dens_prefixed | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] [inst_1 : DecidableEq X] (s : Finset X),
(Numbering.prefixed s).dens = (↑((Fintype.card X).choose s.card))⁻¹ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.keys_filter._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
_private.Init.Data.List.Nat.TakeDrop.0.List.getElem_drop'._simp_1_1 | Init.Data.List.Nat.TakeDrop | ∀ (n k : ℕ), (n ≤ n + k) = True |
Lex.instMulAction | Mathlib.Algebra.Order.Group.Action.Synonym | {M : Type u_1} → {α : Type u_3} → [inst : Monoid M] → [MulAction M α] → MulAction (Lex M) α |
_private.Lean.Elab.Deriving.FromToJson.0.Lean.Elab.Deriving.FromToJson.mkToJsonBodyForInduct.match_1 | Lean.Elab.Deriving.FromToJson | (motive : Lean.Ident × Lean.Expr → Sort u_1) →
(x : Lean.Ident × Lean.Expr) → ((x : Lean.Ident) → (t : Lean.Expr) → motive (x, t)) → motive x |
CategoryTheory.Comma.equivProd_unitIso_inv_app_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
(L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1}))
(R : CategoryTheory.Functor B (CategoryTheory.Discrete PUnit.{u_1 + 1})) (X : CategoryTheory.Comma L R),
((CategoryTheory.Comma.equivProd L R).unitIso.inv.app X).left = CategoryTheory.CategoryStruct.id X.left |
OpenNormalSubgroup.instSemilatticeSupOpenNormalSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} →
[inst : Group G] → [inst_1 : TopologicalSpace G] → [SeparatelyContinuousMul G] → SemilatticeSup (OpenNormalSubgroup G) |
CochainComplex.HomComplex.Cochain.leftShift_rightShift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cochain K L n) (a n' : ℤ) (hn' : n' + a = n),
(γ.rightShift a n' hn').leftShift a n hn' = (a * n + a * (a - 1) / 2).negOnePow • γ.shift a |
CliffordAlgebra.ofBaseChange._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.BaseChange | ∀ {R : Type u_3} (A : Type u_1) {V : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : AddCommGroup V]
[inst_3 : Algebra R A] [inst_4 : Module R V], IsScalarTower A A (TensorProduct R A V) |
Aesop.Slot.recOn | Aesop.Forward.RuleInfo | {motive : Aesop.Slot → Sort u} →
(t : Aesop.Slot) →
((typeDiscrTreeKeys? : Option (Array Lean.Meta.DiscrTree.Key)) →
(index : Aesop.SlotIndex) →
(premiseIndex : Aesop.PremiseIndex) →
(deps common : Std.HashSet Aesop.PremiseIndex) →
(forwardDeps : Array Aesop.PremiseIndex) →
motive
{ typeDiscrTreeKeys? := typeDiscrTreeKeys?, index := index, premiseIndex := premiseIndex,
deps := deps, common := common, forwardDeps := forwardDeps }) →
motive t |
HilbertBasis.instFunLike._proof_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_2} {𝕜 : Type u_1} [inst : RCLike 𝕜] (i : ι), IsBoundedSMul 𝕜 𝕜 |
ENNReal.one_lt_two | Mathlib.Data.ENNReal.Basic | 1 < 2 |
_private.Batteries.Data.String.Legacy.0.String.Legacy.anyAux._proof_4 | Batteries.Data.String.Legacy | ∀ (s : String) (stopPos i : String.Pos.Raw),
i < stopPos → stopPos.byteIdx - (String.Pos.Raw.next s i).byteIdx < stopPos.byteIdx - i.byteIdx |
FractionalIdeal.mapEquiv._proof_5 | 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]
{P' : Type u_3} [inst_3 : CommRing P'] [inst_4 : Algebra R P'] (g : P ≃ₐ[R] P') (I J : FractionalIdeal S P),
FractionalIdeal.map (↑g) (I * J) = FractionalIdeal.map (↑g) I * FractionalIdeal.map (↑g) J |
groupCohomology.mapShortComplex₂_exact | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep k G)},
X.ShortExact → ∀ (i : ℕ), (groupCohomology.mapShortComplex₂ X i).Exact |
Std.ExtHashMap.size_insertIfNew_le | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {v : β}, (m.insertIfNew k v).size ≤ m.size + 1 |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort_of_pairwise._proof_1_4 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (a b : α) (xs : List α),
(↑(List.MergeSort.Internal.splitInTwo ⟨a :: b :: xs, ⋯⟩).1).length < xs.length + 1 + 1 →
¬xs.length + 1 + 1 - (xs.length + 1 + 1 + 1) / 2 < xs.length + 1 + 1 → False |
AdicCompletion.AdicCauchySequence.instSMulNat | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
(M : Type u_4) →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → SMul ℕ (AdicCompletion.AdicCauchySequence I M) |
_private.Init.Data.SInt.Lemmas.0.Int32.ofNat_add._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int32.ofNat n = Int32.ofInt ↑n |
Pi.constNonUnitalRingHom._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ (α : Type u_1) (β : Type u_2) [inst : NonUnitalNonAssocSemiring β] (x y : β),
(Pi.nonUnitalRingHom fun x => NonUnitalRingHom.id β).toFun (x * y) =
(Pi.nonUnitalRingHom fun x => NonUnitalRingHom.id β).toFun x *
(Pi.nonUnitalRingHom fun x => NonUnitalRingHom.id β).toFun y |
Lean.Compiler.LCNF.LetDecl.updateValue | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetDecl pu →
Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.LetDecl pu) |
Monotone.measure_iInter | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : Preorder ι]
[IsCodirectedOrder ι] [Filter.atBot.IsCountablyGenerated] {s : ι → Set α},
Monotone s → (∀ (i : ι), MeasureTheory.NullMeasurableSet (s i) μ) → (∃ i, μ (s i) ≠ ⊤) → μ (⋂ i, s i) = ⨅ i, μ (s i) |
List.firstM._unsafe_rec | Init.Data.List.Control | {m : Type u → Type v} → [Alternative m] → {α : Type w} → {β : Type u} → (α → m β) → List α → m β |
AddChar.instDecidableEq | Mathlib.Algebra.Group.AddChar | {A : Type u_1} → {M : Type u_3} → [inst : AddMonoid A] → [inst_1 : Monoid M] → DecidableEq (AddChar A M) |
CategoryTheory.Limits.WidePushoutShape.Hom.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | Sort u →
{J : Type w} →
{a a_1 : CategoryTheory.Limits.WidePushoutShape J} →
a.Hom a_1 → {J' : Type w} → {a' a'_1 : CategoryTheory.Limits.WidePushoutShape J'} → a'.Hom a'_1 → Sort u |
_private.Mathlib.Data.Set.Card.0.Set.ncard_congr._simp_1_2 | Mathlib.Data.Set.Card | ∀ {α : Type u_1} (s : Set α), s.ncard = Nat.card ↑s |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM.0.Lean.Meta.Grind.Arith.CommRing.setTermNonCommSemiringId.match_1 | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | (motive : Option ℕ → Sort u_1) →
(__do_lift : Option ℕ) →
((semiringId' : ℕ) → motive (some semiringId')) → ((x : Option ℕ) → motive x) → motive __do_lift |
UniformContinuous₂.bicompl | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} {γ : Type uc} {δ : Type ud} {δ' : Type u_2} [inst : UniformSpace α]
[inst_1 : UniformSpace β] [inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] [inst_4 : UniformSpace δ']
{f : α → β → γ} {ga : δ → α} {gb : δ' → β},
UniformContinuous₂ f → UniformContinuous ga → UniformContinuous gb → UniformContinuous₂ (Function.bicompl f ga gb) |
_private.Mathlib.Topology.Partial.0.pcontinuous_iff'._simp_1_2 | Mathlib.Topology.Partial | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (s ∈ nhds x) = ∃ t ⊆ s, IsOpen t ∧ x ∈ t |
CategoryTheory.pullbackShiftIso.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] (a : A) (b : B) (h : b = φ a),
CategoryTheory.pullbackShiftIso C φ a b h = CategoryTheory.eqToIso ⋯ |
Coalgebra.TensorProduct.lid._proof_5 | Mathlib.RingTheory.Coalgebra.TensorProduct | ∀ (R : Type u_2) (P : Type u_1) [inst : CommSemiring R] [inst_1 : AddCommMonoid P] [inst_2 : Module R P],
Function.RightInverse (TensorProduct.lid R P).invFun (↑(TensorProduct.lid R P)).toFun |
NNReal.sqrt_inv | Mathlib.Data.Real.Sqrt | ∀ (x : NNReal), NNReal.sqrt x⁻¹ = (NNReal.sqrt x)⁻¹ |
_private.Mathlib.Algebra.Lie.Sl2.0.IsSl2Triple.HasPrimitiveVectorWith.pow_toEnd_f_eq_zero_of_eq_nat._proof_1_4 | Mathlib.Algebra.Lie.Sl2 | (1 + 1).AtLeastTwo |
Std.DHashMap.Const.ofList_cons | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
Std.DHashMap.Const.ofList ((k, v) :: tl) = Std.DHashMap.Const.insertMany (∅.insert k v) tl |
_private.Mathlib.Algebra.Order.Module.Defs.0.smul_eq_smul_iff_eq_and_eq_of_pos._simp_1_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ ¬a < b) |
NormalizationMonoid.casesOn | Mathlib.Algebra.GCDMonoid.Basic | {α : Type u_2} →
[inst : CommMonoidWithZero α] →
{motive : NormalizationMonoid α → Sort u} →
(t : NormalizationMonoid α) →
((normUnit : α → αˣ) →
(normUnit_zero : normUnit 0 = 1) →
(normUnit_mul : ∀ {a b : α}, a ≠ 0 → b ≠ 0 → normUnit (a * b) = normUnit a * normUnit b) →
(normUnit_coe_units : ∀ (u : αˣ), normUnit ↑u = u⁻¹) →
motive
{ normUnit := normUnit, normUnit_zero := normUnit_zero, normUnit_mul := normUnit_mul,
normUnit_coe_units := normUnit_coe_units }) →
motive t |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.instDecidableEqStructFieldKind.decEq._proof_13 | Lean.Elab.Structure | ∀ (structName : Lean.Name),
Lean.Elab.Command.Structure.StructFieldKind.subobject structName =
Lean.Elab.Command.Structure.StructFieldKind.newField →
False |
FiniteField.frobeniusAlgEquivOfAlgebraic._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) [inst : Field K], IsDomain K |
_private.Mathlib.Algebra.Free.0.FreeAddMagma.liftAux.match_1.eq_2 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeAddMagma α → Sort u_2) (x y : FreeAddMagma α)
(h_1 : (x : α) → motive (FreeAddMagma.of x)) (h_2 : (x y : FreeAddMagma α) → motive (x.add y)),
(match x.add y with
| FreeAddMagma.of x => h_1 x
| x.add y => h_2 x y) =
h_2 x y |
MulChar.exists_apply_ne_one_of_hasEnoughRootsOfUnity | Mathlib.NumberTheory.MulChar.Duality | ∀ (M : Type u_1) (R : Type u_2) [inst : CommMonoid M] [inst_1 : CommRing R] [Finite M]
[HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] [Nontrivial R] {a : M}, a ≠ 1 → ∃ χ, χ a ≠ 1 |
Filter.addCommMonoid | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [AddCommMonoid α] → AddCommMonoid (Filter α) |
Lean.Parser.ParserCacheEntry.mk.inj | Lean.Parser.Types | ∀ {stx : Lean.Syntax} {lhsPrec : ℕ} {newPos : String.Pos.Raw} {errorMsg : Option Lean.Parser.Error}
{stx_1 : Lean.Syntax} {lhsPrec_1 : ℕ} {newPos_1 : String.Pos.Raw} {errorMsg_1 : Option Lean.Parser.Error},
{ stx := stx, lhsPrec := lhsPrec, newPos := newPos, errorMsg := errorMsg } =
{ stx := stx_1, lhsPrec := lhsPrec_1, newPos := newPos_1, errorMsg := errorMsg_1 } →
stx = stx_1 ∧ lhsPrec = lhsPrec_1 ∧ newPos = newPos_1 ∧ errorMsg = errorMsg_1 |
Lean.Elab.Tactic.linter.tactic.unusedName | Lean.Elab.Tactic.Lets | Lean.Option Bool |
Lean.Server.Test.Runner.Client.instToJsonHighlightedMsgEmbed | Lean.Server.Test.Runner | Lean.ToJson Lean.Server.Test.Runner.Client.HighlightedMsgEmbed |
Finmap.toFinmap_nil | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α], [].toFinmap = ∅ |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_7 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Nat.reduceSub._regBuiltin.Nat.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.2812229159._hygCtx._hyg.21 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit |
AlgebraicGeometry.Scheme.empty._proof_1 | Mathlib.AlgebraicGeometry.Scheme | CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology ↑(TopCat.of PEmpty.{u_1 + 1}))
((CategoryTheory.Functor.const (TopologicalSpace.Opens ↑(TopCat.of PEmpty.{u_1 + 1}))ᵒᵖ).obj
(CommRingCat.of PUnit.{u_1 + 1})) |
Lean.instValueLeanOptionValue | Lean.Util.LeanOptions | Lean.KVMap.Value Lean.LeanOptionValue |
Set.iUnion_Icc_left | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] (b : α), ⋃ a, Set.Icc a b = Set.Iic b |
IsChain.image_relEmbedding_iff | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α} {φ : r ↪r r'},
IsChain r' (⇑φ '' s) ↔ IsChain r s |
CategoryTheory.MorphismProperty.shiftLocalizerMorphism | Mathlib.CategoryTheory.Shift.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(W : CategoryTheory.MorphismProperty C) →
{A : Type w} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
[W.IsCompatibleWithShift A] → A → CategoryTheory.LocalizerMorphism W W |
groupCohomologyIsoExt | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep k G) → (n : ℕ) → groupCohomology A n ≅ ((Ext k (Rep k G) n).obj (Opposite.op (Rep.trivial k G k))).obj A |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {n : ℕ}, (n = 1) = (n ∣ 1) |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.Mk₁.map_id.match_1_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (motive : Fin 2 → Prop) (i : Fin 2), (∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i |
Aesop.Frontend.Parser.featIdent | Aesop.Frontend.RuleExpr | Lean.ParserDescr |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.isUniformInducing_pi_restrict._simp_1_2 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} {uγ : UniformSpace γ} {f : α → β} {g : β → γ},
UniformSpace.comap f (UniformSpace.comap g uγ) = UniformSpace.comap (g ∘ f) uγ |
Filter.Frequently.mp | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∃ᶠ (x : α) in f, p x) → (∀ᶠ (x : α) in f, p x → q x) → ∃ᶠ (x : α) in f, q x |
CategoryTheory.CatEnrichedOrdinary.Hom.ext | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{f g : X ⟶ Y} (α β : f ⟶ g),
CategoryTheory.CatEnrichedOrdinary.Hom.base α = CategoryTheory.CatEnrichedOrdinary.Hom.base β → α = β |
CoeT.rec | Init.Coe | {α : Sort u} →
{x : α} →
{β : Sort v} → {motive : CoeT α x β → Sort u_1} → ((coe : β) → motive { coe := coe }) → (t : CoeT α x β) → motive t |
_private.Mathlib.Order.UpperLower.Basic.0.IsUpperSet.top_mem.match_1_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} {s : Set α} (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (_a : α) (ha : _a ∈ s), motive ⋯) → motive x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.