name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Grind.CommRing.Poly.mulC_nc.go._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly |
CategoryTheory.Limits.MulticospanIndex.sections.property | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J (Type u)}
(self : I.sections) (r : J.R), I.fst r (self.val (J.fst r)) = I.snd r (self.val (J.snd r)) |
PrimeMultiset.coe_coePNatMonoidHom | Mathlib.Data.PNat.Factors | ⇑PrimeMultiset.coePNatMonoidHom = PrimeMultiset.toPNatMultiset |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.3036382584._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit |
Submodule.LinearDisjoint.rank_le_one_of_commute_of_flat_of_self | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {M : Submodule R S},
M.LinearDisjoint M → ∀ [Module.Flat R ↥M], (∀ (m n : ↥M), Commute ↑m ↑n) → Module.rank R ↥M ≤ 1 |
WithLp.fstₗ_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : WithLp p (α × β)),
(WithLp.fstₗ p 𝕜 α β) x = x.fst |
LindelofSpace | Mathlib.Topology.Compactness.Lindelof | (X : Type u_2) → [TopologicalSpace X] → Prop |
chudnovskySum._proof_1 | Mathlib.Analysis.Real.Pi.Chudnovsky | (11 + 1).AtLeastTwo |
Finset.prod_ite_index | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s t : Finset ι) (f : ι → M),
∏ x ∈ if p then s else t, f x = if p then ∏ x ∈ s, f x else ∏ x ∈ t, f x |
Nat.strongRec._unsafe_rec | Batteries.Data.Nat.Basic | {motive : ℕ → Sort u_1} → ((n : ℕ) → ((m : ℕ) → m < n → motive m) → motive n) → (t : ℕ) → motive t |
CategoryTheory.Cokleisli.Adjunction.adj._proof_6 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (U : CategoryTheory.Comonad C)
{X : CategoryTheory.Cokleisli U} {Y x : C} (f : (CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).obj X ⟶ Y)
(g : Y ⟶ x),
{ toFun := fun f => { of := f }, invFun := fun f => f.of, left_inv := ⋯, right_inv := ⋯ }
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp
({ toFun := fun f => { of := f }, invFun := fun f => f.of, left_inv := ⋯, right_inv := ⋯ } f)
((CategoryTheory.Cokleisli.Adjunction.toCokleisli U).map g) |
OrderedFinpartition.partSize_pos | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (self : OrderedFinpartition n) (m : Fin self.length), 0 < self.partSize m |
Lean.Firefox.ProfileMeta.interval._default | Lean.Util.Profiler | Lean.Firefox.Milliseconds |
univLE_iff_exists_embedding | Mathlib.SetTheory.Cardinal.UnivLE | UnivLE.{u, v} ↔ Nonempty (Ordinal.{u} ↪ Ordinal.{v}) |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.LinearMap.linearIndependent_iff._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a ⊥ = True |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition._simp_1_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ |
SSet.Truncated.Path₁.ext_iff | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet.Truncated 1} {n : ℕ} {x y : X.Path₁ n}, x = y ↔ x.vertex = y.vertex ∧ x.arrow = y.arrow |
LinearMap.norm_map_iff_inner_map_map | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{E' : Type u_7} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] {F : Type u_9}
[inst_5 : FunLike F E E'] [LinearMapClass F 𝕜 E E'] (f : F),
(∀ (x : E), ‖f x‖ = ‖x‖) ↔ ∀ (x y : E), inner 𝕜 (f x) (f y) = inner 𝕜 x y |
Finset.card_inter_smul | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
(A ∩ x • B).card = A.convolution B⁻¹ x |
Submodule.torsionBySet_isTorsionBySet | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R (↥(Submodule.torsionBySet R M s)) s |
SimplicialObject.Split.Hom.f | Mathlib.AlgebraicTopology.SimplicialObject.Split | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S₁ S₂ : SimplicialObject.Split C} → S₁.Hom S₂ → (n : ℕ) → S₁.s.N n ⟶ S₂.s.N n |
Filter.Eventually.and_frequently | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∃ᶠ (x : α) in f, q x) → ∃ᶠ (x : α) in f, p x ∧ q x |
LatticeHom.fst | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) α |
PseudoMetric._sizeOf_inst | Mathlib.Topology.MetricSpace.BundledFun | (X : Type u_1) →
(R : Type u_2) →
{inst : Zero R} → {inst_1 : Add R} → {inst_2 : LE R} → [SizeOf X] → [SizeOf R] → SizeOf (PseudoMetric X R) |
Lean.Meta.Grind.instBEqEMatchTheoremKind.beq | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheoremKind → Lean.Meta.Grind.EMatchTheoremKind → Bool |
PUnit.commGroup.eq_1 | Mathlib.Algebra.Group.PUnit | PUnit.commGroup =
{ mul := fun x x_1 => PUnit.unit, mul_assoc := PUnit.commGroup._proof_5, one := PUnit.unit,
one_mul := PUnit.commGroup._proof_6, mul_one := PUnit.commGroup._proof_7, npow_zero := PUnit.commGroup._proof_1,
npow_succ := PUnit.commGroup._proof_2, inv := fun x => PUnit.unit, div_eq_mul_inv := PUnit.commGroup._proof_3,
zpow_zero' := PUnit.commGroup._proof_1, zpow_succ' := PUnit.commGroup._proof_2,
zpow_neg' := PUnit.commGroup._proof_4, inv_mul_cancel := PUnit.commGroup._proof_8,
mul_comm := PUnit.commGroup._proof_9 } |
Vector.mapFinIdxM._proof_7 | Init.Data.Vector.Basic | ∀ {β : Type u_1}, #[].size = #[].size |
Nat.div2_bit1 | Mathlib.Data.Nat.Bits | ∀ (n : ℕ), (2 * n + 1).div2 = n |
TotalComplexShape.symm.match_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_2} →
{I₂ : Type u_1} → (motive : I₂ × I₁ → Sort u_3) → (x : I₂ × I₁) → ((i₂ : I₂) → (i₁ : I₁) → motive (i₂, i₁)) → motive x |
Batteries.PairingHeap.deleteMin | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → Batteries.PairingHeap α le → Option (α × Batteries.PairingHeap α le) |
PProd | Init.Prelude | Sort u → Sort v → Sort (max (max 1 u) v) |
TrivSqZeroExt.addGroup | Mathlib.Algebra.TrivSqZeroExt | {R : Type u} → {M : Type v} → [AddGroup R] → [AddGroup M] → AddGroup (TrivSqZeroExt R M) |
GroupAlgebra.mul_average_left | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : Invertible ↑(Fintype.card G)] (g : G), (fun₀ | g => 1) * GroupAlgebra.average k G = GroupAlgebra.average k G |
Lean.Widget.eraseWidgetSpec | Lean.Widget.Commands | Lean.ParserDescr |
Quaternion.instDivisionRing._proof_8 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] (n : ℕ) (a : Quaternion R),
GroupWithZero.zpow (Int.negSucc n) a = (GroupWithZero.zpow (↑n.succ) a)⁻¹ |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPolyC.go.match_4.eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var x))
(h_5 : (a b : Lean.Grind.CommRing.Expr) → motive (a.add b))
(h_6 : (a b : Lean.Grind.CommRing.Expr) → motive (a.mul b)) (h_7 : (a : Lean.Grind.CommRing.Expr) → motive a.neg)
(h_8 : (a b : Lean.Grind.CommRing.Expr) → motive (a.sub b))
(h_9 : (a : Lean.Grind.CommRing.Expr) → (k : ℕ) → motive (a.pow k)),
(match a.neg with
| Lean.Grind.CommRing.Expr.num k => h_1 k
| Lean.Grind.CommRing.Expr.natCast k => h_2 k
| Lean.Grind.CommRing.Expr.intCast k => h_3 k
| Lean.Grind.CommRing.Expr.var x => h_4 x
| a.add b => h_5 a b
| a.mul b => h_6 a b
| a.neg => h_7 a
| a.sub b => h_8 a b
| a.pow k => h_9 a k) =
h_7 a |
Semiring.toGrindSemiring._proof_12 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (n : ℕ), OfNat.ofNat (n + 2 + 1) = OfNat.ofNat (n + 2) + 1 |
HomologicalComplex.homologyπ_extendHomologyIso_inv_assoc | Mathlib.Algebra.Homology.Embedding.ExtendHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (K : HomologicalComplex C c) (e : c.Embedding c') {j : ι} {j' : ι'}
(hj' : e.f j = j') [inst_3 : K.HasHomology j] [inst_4 : (K.extend e).HasHomology j'] {Z : C}
(h : (K.extend e).homology j' ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.homologyπ j)
(CategoryTheory.CategoryStruct.comp (K.extendHomologyIso e hj').inv h) =
CategoryTheory.CategoryStruct.comp (K.extendCyclesIso e hj').inv
(CategoryTheory.CategoryStruct.comp ((K.extend e).homologyπ j') h) |
Bundle.TotalSpace.mk' | Mathlib.Data.Bundle | {B : Type u_1} → {E : B → Type u_3} → (F : Type u_4) → (x : B) → E x → Bundle.TotalSpace F E |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.iterate_toEnd_mem_lowerCentralSeries._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊤) = True |
IsBaseChange.equiv._proof_2 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
SMulCommClass R S S |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.exists_basis_of_pairing_eq_zero._simp_1_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M} {s : Set M},
(x ∈ Submodule.span R (insert y s)) = ∃ a, x + a • y ∈ Submodule.span R s |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro |
Unitization.instNeg | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Neg R] → [Neg A] → Neg (Unitization R A) |
List.SortedGE.isChain | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGE → List.IsChain (fun x1 x2 => x1 ≥ x2) l |
Mathlib.Tactic.BicategoryLike.MonadMor₁.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{P : Sort u} →
{id₁M : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{id₁M' : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M' :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{ id₁M := id₁M, comp₁M := comp₁M } = { id₁M := id₁M', comp₁M := comp₁M' } →
(id₁M ≍ id₁M' → comp₁M ≍ comp₁M' → P) → P |
HomologicalComplex.instHasColimitDiscreteWalkingPairCompPairEval | Mathlib.Algebra.Homology.HomologicalComplexBiprod | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K L : HomologicalComplex C c)
[∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (L.X i)] (i : ι),
CategoryTheory.Limits.HasColimit ((CategoryTheory.Limits.pair K L).comp (HomologicalComplex.eval C c i)) |
_private.Lean.Meta.InferType.0.Lean.Meta.inferConstType | Lean.Meta.InferType | Lean.Name → List Lean.Level → Lean.MetaM Lean.Expr |
CategoryTheory.Endofunctor.Coalgebra.ctorIdx | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C C} → CategoryTheory.Endofunctor.Coalgebra F → ℕ |
convexHull.eq_1 | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], convexHull 𝕜 = ClosureOperator.ofCompletePred (Convex 𝕜) ⋯ |
_private.Lean.Meta.TryThis.0.Lean.Meta.Tactic.TryThis.Suggestion.processEdit.match_1 | Lean.Meta.TryThis | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((indent column : ℕ) → motive (indent, column)) → motive x |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction_eq_iff._proof_1_6 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {k : ℕ} {pat : ByteArray} {stackPos : ℕ},
(∃ k',
k ≤ k' ∧
k' ≤ stackPos ∧ String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat pat k' (stackPos + 1)) →
∀ (k' : ℕ), k ≤ k' → ¬k < k' → ¬k = k' → False |
CategoryTheory.Over.fst_left | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X : C}
{R S : CategoryTheory.Over X},
(CategoryTheory.SemiCartesianMonoidalCategory.fst R S).left = CategoryTheory.Limits.pullback.fst R.hom S.hom |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.confirmRupHint_preserves_motive._simp_1_6 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' |
_private.Mathlib.MeasureTheory.Group.Arithmetic.0.Finset.aemeasurable_sum.match_1_1 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {ι : Type u_1} {α : Type u_3} {f : ι → α → M} (s : Finset ι) (_g : α → M)
(motive : (∃ a ∈ s.val, f a = _g) → Prop) (x : ∃ a ∈ s.val, f a = _g),
(∀ (_i : ι) (hi : _i ∈ s.val) (hg : f _i = _g), motive ⋯) → motive x |
CategoryTheory.Limits.inr_comp_pushoutComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : X ⟶ Y) (g : X ⟶ Z)
[inst_2 : CategoryTheory.Limits.HasPushout f g] [inst_3 : CategoryTheory.Limits.HasPushout (G.map f) (G.map g)]
{Z_1 : D} (h : G.obj (CategoryTheory.Limits.pushout f g) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr (G.map f) (G.map g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushoutComparison G f g) h) =
CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.Limits.pushout.inr f g)) h |
CommRingCat.Under.tensorProductFan' | Mathlib.Algebra.Category.Ring.Under.Limits | {R : CommRingCat} →
(S : CommRingCat) →
[inst : Algebra ↑R ↑S] →
{ι : Type u} →
(P : ι → CategoryTheory.Under R) →
CategoryTheory.Limits.Fan fun i => S.mkUnder (TensorProduct ↑R ↑S ↑(P i).right) |
Std.TreeMap.contains_iff_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {k : α}, t.contains k = true ↔ k ∈ t |
Pi.seminormedRing._proof_12 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : (i : ι) → SeminormedRing (R i)] (n : ℕ) (x : (i : ι) → R i),
Semiring.npow (n + 1) x = Semiring.npow n x * x |
Mathlib.Tactic.LinearCombination.expandLinearCombo._unsafe_rec | Mathlib.Tactic.LinearCombination | Option Lean.Expr → Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.LinearCombination.Expanded |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.A_c_eq_zero | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {m : ℤ} {A : FixedDetMatrix (Fin 2) ℤ m}, ↑A 1 0 = 0 → ↑A 0 0 * ↑A 1 1 = m |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift_self | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (h : D.IsTerminal e),
h.lift ⋯ = CategoryTheory.CategoryStruct.id e |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_34 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (acc : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n)
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n),
(Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ofArray_fold_fn acc (some c)).size = n →
∀ (l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n),
c.isUnit = some (l, false) →
↑i < (acc.modify (↑l) Std.Tactic.BVDecide.LRAT.Internal.Assignment.addNegAssignment).size |
Lean.ReducibilityHints.opaque.sizeOf_spec | Lean.Declaration | sizeOf Lean.ReducibilityHints.opaque = 1 |
Lean.Meta.Simp.Methods.mk.inj | Lean.Meta.Tactic.Simp.Types | ∀ {pre post : Lean.Meta.Simp.Simproc} {dpre dpost : Lean.Meta.Simp.DSimproc}
{discharge? : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge : Bool}
{pre_1 post_1 : Lean.Meta.Simp.Simproc} {dpre_1 dpost_1 : Lean.Meta.Simp.DSimproc}
{discharge?_1 : Lean.Expr → Lean.Meta.SimpM (Option Lean.Expr)} {wellBehavedDischarge_1 : Bool},
{ pre := pre, post := post, dpre := dpre, dpost := dpost, discharge? := discharge?,
wellBehavedDischarge := wellBehavedDischarge } =
{ pre := pre_1, post := post_1, dpre := dpre_1, dpost := dpost_1, discharge? := discharge?_1,
wellBehavedDischarge := wellBehavedDischarge_1 } →
pre = pre_1 ∧
post = post_1 ∧
dpre = dpre_1 ∧ dpost = dpost_1 ∧ discharge? = discharge?_1 ∧ wellBehavedDischarge = wellBehavedDischarge_1 |
Std.Time.Modifier.z.noConfusion | Std.Time.Format.Basic | {P : Sort u} →
{presentation presentation' : Std.Time.ZoneName} →
Std.Time.Modifier.z presentation = Std.Time.Modifier.z presentation' → (presentation = presentation' → P) → P |
CategoryTheory.equivSmallModel._proof_1 | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.EssentiallySmall.{u_1, u_3, u_2} C], Nonempty (C ≌ Classical.choose ⋯) |
IsSolvableByRad.rec | Mathlib.FieldTheory.AbelRuffini | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
{motive : (a : E) → IsSolvableByRad F a → Prop},
(∀ (α : F), motive ((algebraMap F E) α) ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRad F β), motive α a → motive β a_1 → motive (α + β) ⋯) →
(∀ (α : E) (a : IsSolvableByRad F α), motive α a → motive (-α) ⋯) →
(∀ (α β : E) (a : IsSolvableByRad F α) (a_1 : IsSolvableByRad F β),
motive α a → motive β a_1 → motive (α * β) ⋯) →
(∀ (α : E) (a : IsSolvableByRad F α), motive α a → motive α⁻¹ ⋯) →
(∀ (α : E) (n : ℕ) (hn : n ≠ 0) (a : IsSolvableByRad F (α ^ n)), motive (α ^ n) a → motive α ⋯) →
∀ {a : E} (t : IsSolvableByRad F a), motive a t |
Polynomial.revAt_le | Mathlib.Algebra.Polynomial.Reverse | ∀ {N i : ℕ}, i ≤ N → (Polynomial.revAt N) i = N - i |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termY₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr |
AddEquiv.strictMono_subsemigroupCongr | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : AddCommMonoid G] [inst_1 : Preorder G] {S T : AddSubsemigroup G} (h : S = T),
StrictMono ⇑(AddEquiv.subsemigroupCongr h) |
IsEmpty.oriented._proof_1 | Mathlib.LinearAlgebra.Orientation | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R], 1 ≠ 0 |
_private.Init.Data.BitVec.Lemmas.0.BitVec.uaddOverflow_assoc._simp_1_4 | Init.Data.BitVec.Lemmas | ∀ {p q : Prop} {x : Decidable p} {x_1 : Decidable q}, (decide p = decide q) = (p ↔ q) |
derivedSet | Mathlib.Topology.DerivedSet | {X : Type u_1} → [TopologicalSpace X] → Set X → Set X |
SupHom.rec | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_sup' }) →
(t : SupHom α β) → motive t |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_5 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n),
(AffineIndependent k fun a => if h : a = 0 then ⋯ ▸ s.centroid else s.points a) →
AffineIndependent k fun x => if x = 0 then s.centroid else s.points x |
BitVec.mk_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {h : 0 < 2 ^ w}, { toFin := ⟨0, h⟩ } = 0#w |
Tropical.le_zero._simp_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : LE R] [inst_1 : OrderTop R] (x : Tropical R), (x ≤ 0) = True |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.addAssignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Bool → Std.Tactic.BVDecide.LRAT.Internal.Assignment → Std.Tactic.BVDecide.LRAT.Internal.Assignment |
SSet.instIsStableUnderCoproductsMonomorphismsOfHasCoproductsType | Mathlib.AlgebraicTopology.SimplicialSet.Monomorphisms | ∀ [CategoryTheory.Limits.HasCoproducts (Type u)],
CategoryTheory.MorphismProperty.IsStableUnderCoproducts.{v', u, u + 1}
(CategoryTheory.MorphismProperty.monomorphisms SSet) |
_private.Mathlib.Analysis.Analytic.Binomial.0.Real.one_div_one_sub_rpow_hasFPowerSeriesOnBall_zero._simp_1_10 | Mathlib.Analysis.Analytic.Binomial | ∀ (r s : ℝ), ↑r - ↑s = ↑(r - s) |
Ideal.fiberIsoOfBijectiveResidueField._proof_7 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommRing R'] [inst_2 : Algebra R R'] {q : Ideal R'}
[inst_3 : q.IsPrime], SMulCommClass R q.ResidueField q.ResidueField |
_private.Mathlib.Analysis.Convex.Segment.0.mem_openSegment_translate._simp_1_2 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} {G : Type u_4} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : AddCommGroup G] [inst_5 : Module 𝕜 E] [inst_6 : AddTorsor G E]
[VAddCommClass G E E] (a : G) (b c : E), openSegment 𝕜 (a +ᵥ b) (a +ᵥ c) = a +ᵥ openSegment 𝕜 b c |
ContinuousLinearEquiv.comp_contDiffWithinAt_iff | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {f : E → F} {x : E} {n : WithTop ℕ∞}
(e : F ≃L[𝕜] G), ContDiffWithinAt 𝕜 n (⇑e ∘ f) s x ↔ ContDiffWithinAt 𝕜 n f s x |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_8 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True |
CategoryTheory.ObjectProperty.isThin_of_isSeparating_bot | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], ⊥.IsSeparating → Quiver.IsThin C |
Vector.append_assoc._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m k : ℕ}, n + (m + k) = n + m + k |
Aesop.RuleStatsTotals.empty | Aesop.Stats.Basic | Aesop.RuleStatsTotals |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.SavedState.termState | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.SavedState✝ → Lean.Elab.Term.SavedState |
Lean.IR.IRType.usize | Lean.Compiler.IR.Basic | Lean.IR.IRType |
KummerDedekind.quotMapEquivQuotQuotMap._proof_4 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R}
[inst_3 : IsDomain R] [inst_4 : IsIntegrallyClosed R] [inst_5 : IsDedekindDomain S]
[inst_6 : Module.IsTorsionFree R S] (hx' : IsIntegral R x),
(Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (minpoly R (Algebra.adjoin.powerBasis' hx').gen)}).IsTwoSided |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size) →
((hl : Std.DTreeMap.Internal.Impl.leaf.Balanced) →
(hlr : Std.DTreeMap.Internal.Impl.BalancedAtRoot Std.DTreeMap.Internal.Impl.leaf.size r.size) →
motive Std.DTreeMap.Internal.Impl.leaf hl hlr) →
((size : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hl : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalancedAtRoot
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').size r.size) →
motive (Std.DTreeMap.Internal.Impl.inner size k' v' l' r') hl hlr) →
motive l hl hlr |
CategoryTheory.Presieve.singleton_eq_iff_domain._simp_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : Y ⟶ X),
CategoryTheory.Presieve.singleton f g = (f = g) |
sInfHom.ext | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] {f g : sInfHom α β},
(∀ (a : α), f a = g a) → f = g |
Lean.IR.EmitLLVM.constIntSizeT | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} → ℕ → Lean.IR.EmitLLVM.M llvmctx (LLVM.Value llvmctx) |
_private.Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence.0.Mathlib.Tactic.BicategoryLike.normalize.match_3 | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | (motive : Mathlib.Tactic.BicategoryLike.Mor₁ → Sort u_1) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
((e : Lean.Expr) → (a : Mathlib.Tactic.BicategoryLike.Obj) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.id e a)) →
((e : Lean.Expr) →
(f g : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.comp e f g)) →
((f : Mathlib.Tactic.BicategoryLike.Atom₁) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.of f)) → motive f |
CategoryTheory.ShortComplex.SnakeInput.functorL₃._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).f₃ = CategoryTheory.CategoryStruct.comp f.f₃ g.f₃ |
Fin.val_mk | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (h : m < n), ↑⟨m, h⟩ = m |
MulOpposite.instAddCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [AddCommSemigroup α] → AddCommSemigroup αᵐᵒᵖ |
_private.Mathlib.Analysis.InnerProductSpace.l2Space.0.HilbertBasis.dense_span._simp_1_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.