name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Subfield.sInf_toSubring | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (s : Set (Subfield K)), (sInf s).toSubring = ⨅ t ∈ s, t.toSubring |
WeierstrassCurve.Projective.negDblY_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P : Fin 3 → R},
W'.Equation P →
W'.negDblY P * P 2 ^ 2 =
-(MvPolynomial.eval P) W'.polynomialX *
((MvPolynomial.eval P) W'.polynomialX ^ 2 -
W'.a₁ * (MvPolynomial.eval P) W'.polynomialX * P 2 * (P 1 - W'.negY P) -
W'.a₂ * P 2 ^ 2 * (P 1 - W'.negY P) ^ 2 -
2 * P 0 * P 2 * (P 1 - W'.negY P) ^ 2 -
P 0 * P 2 * (P 1 - W'.negY P) ^ 2) +
P 1 * P 2 ^ 2 * (P 1 - W'.negY P) ^ 3 |
himp_iff_imp._simp_1 | Mathlib.Order.Heyting.Basic | ∀ (p q : Prop), p ⇨ q = (p → q) |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_ae_subset._simp_1_2 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = ∃ x ∈ s, x ∉ t |
HasFiniteFPowerSeriesOnBall.rec | Mathlib.Analysis.Analytic.CPolynomialDef | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{f : E → F} →
{p : FormalMultilinearSeries 𝕜 E F} →
{x : E} →
{n : ℕ} →
{r : ENNReal} →
{motive : HasFiniteFPowerSeriesOnBall f p x n r → Sort u} →
((toHasFPowerSeriesOnBall : HasFPowerSeriesOnBall f p x r) →
(finite : ∀ (m : ℕ), n ≤ m → p m = 0) → motive ⋯) →
(t : HasFiniteFPowerSeriesOnBall f p x n r) → motive t |
Set.biUnion_diff_biUnion_eq | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s t : Set ι} {f : ι → Set α},
(s ∪ t).PairwiseDisjoint f → (⋃ i ∈ s, f i) \ ⋃ i ∈ t, f i = ⋃ i ∈ s \ t, f i |
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.image.map_id._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True |
_private.Mathlib.Data.Finset.NAry.0.Finset.mem_image₂._simp_1_2 | Mathlib.Data.Finset.NAry | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) |
Mathlib.Tactic.WLOGResult.reductionGoal | Mathlib.Tactic.WLOG | Mathlib.Tactic.WLOGResult → Lean.MVarId |
NumberField.RingOfIntegers.mapAlgEquiv._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ {k : Type u_2} {K : Type u_3} {L : Type u_4} {E : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra k K] [inst_4 : Algebra k L] [inst_5 : EquivLike E K L] [AlgEquivClass E k K L], AlgHomClass E k K L |
Std.HashMap.getD_eq_fallback_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {a : α}
{fallback : β}, m.contains a = false → m.getD a fallback = fallback |
_private.Mathlib.Analysis.InnerProductSpace.Dual.0.InnerProductSpace.toDual._simp_5 | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False |
CategoryTheory.Functor.isoWhiskerRight_twice | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {H K : CategoryTheory.Functor B C} (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) (α : H ≅ K),
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.Functor.isoWhiskerRight α F) G =
H.associator F G ≪≫ CategoryTheory.Functor.isoWhiskerRight α (F.comp G) ≪≫ (K.associator F G).symm |
ContinuousMap.concat | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] →
[OrderTopology α] →
{a b c : α} →
[Fact (a ≤ b)] →
[Fact (b ≤ c)] →
{E : Type u_2} →
[inst_5 : TopologicalSpace E] → C(↑(Set.Icc a b), E) → C(↑(Set.Icc b c), E) → C(↑(Set.Icc a c), E) |
Tactic.mkComp._sunfold | Mathlib.Tactic.HigherOrder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr |
GaussianInt.abs_natCast_norm | Mathlib.NumberTheory.Zsqrtd.GaussianInt | ∀ (x : GaussianInt), ↑(Zsqrtd.norm x).natAbs = Zsqrtd.norm x |
StarAlgEquiv.trans_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} {C : Type u_5} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (x : A),
(e₁.trans e₂) x = e₂ (e₁ x) |
NNRat.instIsScalarTowerRight | Mathlib.Algebra.Ring.Action.Rat | ∀ {R : Type u_1} [inst : DivisionSemiring R], IsScalarTower ℚ≥0 R R |
Id.instLawfulMonadLiftTOfLawfulMonad | Init.Control.Lawful.MonadLift.Instances | ∀ {m : Type u → Type v} [inst : Monad m] [LawfulMonad m], LawfulMonadLiftT Id m |
DistribLattice.ctorIdx | Mathlib.Order.Lattice | {α : Type u_1} → DistribLattice α → ℕ |
RelIso.instGroup._proof_2 | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (n : ℕ) (x : r ≃r r), npowRecAuto (n + 1) x = npowRecAuto n x * x |
Std.Tactic.BVDecide.BVExpr.replicate.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w w' : ℕ} (n : ℕ) (expr : Std.Tactic.BVDecide.BVExpr w) (h : w' = w * n) (w_1 n_1 : ℕ)
(expr_1 : Std.Tactic.BVDecide.BVExpr w_1) (h_1 : w' = w_1 * n_1),
(Std.Tactic.BVDecide.BVExpr.replicate n expr h = Std.Tactic.BVDecide.BVExpr.replicate n_1 expr_1 h_1) =
(w = w_1 ∧ n = n_1 ∧ expr ≍ expr_1) |
Prod.map_iterate | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (n : ℕ), (Prod.map f g)^[n] = Prod.map f^[n] g^[n] |
WeierstrassCurve.Projective.addXYZ_Z | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P Q : Fin 3 → R), W'.addXYZ P Q 2 = W'.addZ P Q |
String.Legacy.Iterator.s | Init.Data.String.Iterator | String.Legacy.Iterator → String |
PseudoMetric.coe_le_coe | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : Add R] [inst_2 : LE R] {d d' : PseudoMetric X R},
⇑d ≤ ⇑d' ↔ d ≤ d' |
AlgebraicGeometry.morphismRestrictStalkMap._proof_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) (x : ↥↑((TopologicalSpace.Opens.map f.base).obj U)),
Inseparable (↑((f ∣_ U) x)) (f ↑x) |
CategoryTheory.NatTrans.naturality | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (self : CategoryTheory.NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.app X) (G.map f) |
_private.Mathlib.Data.Finset.Union.0.Finset.bind_toFinset._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a |
FreeSimplexQuiver.homRel.recOn | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop}
⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ {a a_1 : X ⟶ Y} (t : FreeSimplexQuiver.homRel a a_1),
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ j.castSucc),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ)))
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 1)},
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Paths.of FreeSimplexQuiver).obj (FreeSimplexQuiver.mk n)))
⋯) →
(∀ {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.castSucc)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i)))
⋯) →
(∀ {n : ℕ} {i j : Fin (n + 1)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j)))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j.succ))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i)))
⋯) →
motive a a_1 t |
GrpCat.toAddGrp._proof_1 | Mathlib.Algebra.Category.Grp.EquivalenceGroupAddGroup | ∀ (X : GrpCat),
AddGrpCat.ofHom (MonoidHom.toAdditive (GrpCat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id (AddGrpCat.of (Additive ↑X)) |
WithBot.unbot_mono | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithBot α} (hx : x ≠ ⊥) (hy : y ≠ ⊥), x ≤ y → x.unbot hx ≤ y.unbot hy |
Algebra.traceMatrix._proof_1 | Mathlib.RingTheory.Trace.Basic | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A |
Real.strictAntiOn_rpow_Ioi_of_exponent_neg | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {r : ℝ}, r < 0 → StrictAntiOn (fun x => x ^ r) (Set.Ioi 0) |
antisymm_of | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} (r : α → α → Prop) [Std.Antisymm r] {a b : α}, r a b → r b a → a = b |
isPurelyInseparable_iff | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u_1} {E : Type u_2} [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E],
IsPurelyInseparable F E ↔ ∀ (x : E), IsIntegral F x ∧ (IsSeparable F x → x ∈ (algebraMap F E).range) |
RatFunc.num_inv_dvd | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K}, x ≠ 0 → x⁻¹.num ∣ x.denom |
instCommRingCorner._proof_12 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommRing R] (idem : IsIdempotentElem e) (n : ℕ), ↑(n + 1) = ↑n + 1 |
Cardinal.mk_finsupp_lift_of_infinite' | Mathlib.SetTheory.Cardinal.Finsupp | ∀ (α : Type u) (β : Type v) [Nonempty α] [inst : Zero β] [Infinite β],
Cardinal.mk (α →₀ β) = max (Cardinal.lift.{v, u} (Cardinal.mk α)) (Cardinal.lift.{u, v} (Cardinal.mk β)) |
Batteries.PairingHeap.headI | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → [Inhabited α] → Batteries.PairingHeap α le → α |
ContinuousMap.instStar | Mathlib.Topology.ContinuousMap.Star | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] → [inst_1 : TopologicalSpace β] → [inst_2 : Star β] → [ContinuousStar β] → Star C(α, β) |
antitoneOn_of_le_sub_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Sub α] [inst_3 : One α]
[inst_4 : PredSubOrder α] [IsPredArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMin a → a ∈ s → a - 1 ∈ s → f a ≤ f (a - 1)) → AntitoneOn f s |
_private.Mathlib.Computability.PostTuringMachine.0.Turing.TM1to1.stepAux_write._simp_1_2 | Mathlib.Computability.PostTuringMachine | ∀ {a b : ℕ}, (a.succ = b.succ) = (a = b) |
CommGroup.toDistribLattice._proof_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_1) [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z |
Lean.Elab.Term.ToDepElimPattern.State._sizeOf_inst | Lean.Elab.Match | SizeOf Lean.Elab.Term.ToDepElimPattern.State |
SimpleGraph.Hom.ofLE_apply | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {G₁ G₂ : SimpleGraph V} (h : G₁ ≤ G₂) (v : V), (SimpleGraph.Hom.ofLE h) v = v |
AdjoinRoot.instNumberFieldRat | Mathlib.NumberTheory.NumberField.Basic | ∀ {f : Polynomial ℚ} [hf : Fact (Irreducible f)], NumberField (AdjoinRoot f) |
Int.le_add_of_sub_left_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a - b ≤ c → a ≤ b + c |
Lean.ResolveName.resolveNamespaceUsingOpenDecls | Lean.ResolveName | Lean.Environment → Lean.Name → List Lean.OpenDecl → List Lean.Name |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.map_eq_iff._simp_1_1 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {β : ι → Type w} [inst : (i : ι) → AddCommMonoid (β i)] {x y : DirectSum ι β},
(x = y) = ∀ (i : ι), x i = y i |
SkewMonoidAlgebra.algHom_ext | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : CommSemiring k] {A : Type u_3} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
⦃φ₁ φ₂ : SkewMonoidAlgebra k G →ₐ[k] A⦄,
(∀ (x : G), φ₁ (SkewMonoidAlgebra.single x 1) = φ₂ (SkewMonoidAlgebra.single x 1)) → φ₁ = φ₂ |
Mathlib.Meta.FunProp.LambdaTheoremArgs.ctorIdx | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremArgs → ℕ |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Complex.cos_eq_cos_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) |
Algebra.FormallyUnramified.localization_base | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} {Rₘ : Type u_3} {Sₘ : Type u_4} [inst : CommRing R] [inst_1 : CommRing Rₘ] [inst_2 : CommRing Sₘ]
(M : Submonoid R) [inst_3 : Algebra R Sₘ] [inst_4 : Algebra R Rₘ] [inst_5 : Algebra Rₘ Sₘ] [IsScalarTower R Rₘ Sₘ]
[Algebra.FormallyUnramified R Sₘ], Algebra.FormallyUnramified Rₘ Sₘ |
_private.Batteries.Data.MLList.Basic.0.MLList.specImpl | Batteries.Data.MLList.Basic | (m : Type u_1 → Type u_1) → MLList.Spec✝ m |
Lean.Omega.LinearCombo.sub | Init.Omega.LinearCombo | Lean.Omega.LinearCombo → Lean.Omega.LinearCombo → Lean.Omega.LinearCombo |
AddCommMonCat.FilteredColimits.M | Mathlib.Algebra.Category.MonCat.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.IsFiltered J] → CategoryTheory.Functor J AddCommMonCat → AddMonCat |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_6 | Std.Time.Date.ValidDate | ∀ (idx : Std.Time.Month.Ordinal) (acc : ℤ),
12 ≤ ↑idx → ∀ (ordinal : Std.Time.Day.Ordinal.OfYear true), ↑ordinal ≤ 366 → 366 < ↑ordinal → False |
Vector.findFinIdx?_singleton._proof_1 | Init.Data.Vector.Find | ∀ {α : Type u_1} {a : α}, 0 < #[a].size |
_private.Mathlib.Data.Nat.Cast.NeZero.0.NeZero.one_le._proof_1_1 | Mathlib.Data.Nat.Cast.NeZero | ∀ {n : ℕ}, n ≠ 0 → 1 ≤ n |
CategoryTheory.Preadditive.toCommGrp_obj_grp | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C] (X : C),
((CategoryTheory.Preadditive.toCommGrp C).obj X).grp = CategoryTheory.Preadditive.instGrpObj X |
Plausible.Gen.oneOfWithDefault | Plausible.Gen | {α : Type} → Plausible.Gen α → List (Plausible.Gen α) → Plausible.Gen α |
CategoryTheory.FinCategory.objAsTypeToAsType | Mathlib.CategoryTheory.FinCategory.AsType | (α : Type u_1) →
[inst : Fintype α] →
[inst_1 : CategoryTheory.SmallCategory α] →
[inst_2 : CategoryTheory.FinCategory α] →
CategoryTheory.Functor (CategoryTheory.FinCategory.ObjAsType α) (CategoryTheory.FinCategory.AsType α) |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_4 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z) (T : CategoryTheory.Limits.FormalCoproduct C)
(s : { p // CategoryTheory.CategoryStruct.comp p.1 f = CategoryTheory.CategoryStruct.comp p.2 g }) (i : T.I),
Z.obj (f.f (↑⟨((↑s).1.f i, (↑s).2.f i), ⋯⟩).1) = Z.obj (g.f (↑⟨((↑s).1.f i, (↑s).2.f i), ⋯⟩).2) |
Lean.Server.FileWorker.WorkerState.importCachingTask? | Lean.Server.FileWorker | Lean.Server.FileWorker.WorkerState →
Option (Lean.Server.ServerTask (Except IO.Error Lean.Server.FileWorker.AvailableImportsCache)) |
LinearOrder.mkOfAddGroupCone.eq_1 | Mathlib.Algebra.Order.Group.Cone | ∀ {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] (C : S) [inst_2 : AddGroupConeClass S G]
[inst_3 : HasMemOrNegMem C] [inst_4 : DecidablePred fun x => x ∈ C],
LinearOrder.mkOfAddGroupCone C =
{ toPartialOrder := PartialOrder.mkOfAddGroupCone C, min := fun a b => if a ≤ b then a else b,
max := fun a b => if a ≤ b then b else a, compare := fun a b => compareOfLessAndEq a b, le_total := ⋯,
toDecidableLE := fun x b => inst_4 (b - x), toDecidableEq := decidableEqOfDecidableLE,
toDecidableLT := decidableLTOfDecidableLE, min_def := ⋯, max_def := ⋯, compare_eq_compareOfLessAndEq := ⋯ } |
PEquiv.trans_assoc | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ),
(f.trans g).trans h = f.trans (g.trans h) |
Path.Homotopic.proj.eq_1 | Mathlib.Topology.Homotopy.Product | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i} (i : ι)
(p : Path.Homotopic.Quotient as bs), Path.Homotopic.proj i p = p.map { toFun := fun p => p i, continuous_toFun := ⋯ } |
UInt16.ofInt_one | Init.Data.UInt.Lemmas | UInt16.ofInt 1 = 1 |
SheafOfModules.instHasColimitsOfSizeOfPresheafOfModulesValRingCat | Mathlib.Algebra.Category.ModuleCat.Sheaf.Colimits | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
(R : CategoryTheory.Sheaf J RingCat) [CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[J.WEqualsLocallyBijective AddCommGrpCat]
[CategoryTheory.Limits.HasColimitsOfSize.{w', w, max u' v, max (max (max (v + 1) u) u') v'}
(PresheafOfModules R.val)],
CategoryTheory.Limits.HasColimitsOfSize.{w', w, max u' v, max (max (max (v + 1) u) u') v'} (SheafOfModules R) |
FormalMultilinearSeries.id._proof_4 | Mathlib.Analysis.Analytic.Composition | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E |
Equiv.Perm.Basis.toCentralizer_apply | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : α), ↑(a.toCentralizer τ) x = a.ofPermHomFun τ x |
_private.Lean.Meta.InferType.0.Lean.Meta.isProofQuickApp | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool |
ClopenUpperSet.ext_iff | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] {s t : ClopenUpperSet α}, s = t ↔ ↑s = ↑t |
Equiv.ext_iff | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, f = g ↔ ∀ (x : α), f x = g x |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C.match_1_4 | Mathlib.Algebra.Polynomial.Derivative | {R : Type u_1} →
{S : Finset R} →
(k : ℕ) →
(motive :
(x : Finset R × R) →
x ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T} →
Sort u_2) →
(x : Finset R × R) →
(x_1 :
x ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T}) →
((T : Finset R) →
(i : R) →
(x :
(T, i) ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T}) →
motive (T, i) x) →
motive x x_1 |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.blast | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {w : ℕ} → (aig : Std.Sat.AIG α) → aig.BinaryRefVec w → Std.Sat.AIG.RefVecEntry α w |
Std.Internal.List.Const.getKeyD_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {k fallback : α} {f : β → β} (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (Std.Internal.List.Const.modifyKey k f l) fallback =
if Std.Internal.List.containsKey k l = true then k else fallback |
String.Slice.Pattern.ForwardSliceSearcher.instToForwardSearcher | Init.Data.String.Pattern.String | {pat : String.Slice} → String.Slice.Pattern.ToForwardSearcher pat String.Slice.Pattern.ForwardSliceSearcher |
TopCat.GlueData.MkCore.cocycle | Mathlib.Topology.Gluing | ∀ (self : TopCat.GlueData.MkCore) (i j k : self.J) (x : ↥(self.V i j)) (h : ↑x ∈ self.V i k),
↑((CategoryTheory.ConcreteCategory.hom (self.t j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (self.t i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (self.t i k)) ⟨↑x, h⟩) |
MonCat.Colimits.monoidColimitType._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (n : ℕ)
(x : MonCat.Colimits.ColimitType F), npowRecAuto (n + 1) x = npowRecAuto n x * x |
_private.Mathlib.Data.Countable.Defs.0.Finite.to_countable.match_1 | Mathlib.Data.Countable.Defs | ∀ {α : Sort u_1} (motive : (∃ n, Nonempty (α ≃ Fin n)) → Prop) (x : ∃ n, Nonempty (α ≃ Fin n)),
(∀ (w : ℕ) (e : α ≃ Fin w), motive ⋯) → motive x |
LocallyConstant.instAddGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x_1 • x) = ⇑(x_1 • x) |
NormedAddGroupHom.toAddMonoidHomClass | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂],
AddMonoidHomClass (NormedAddGroupHom V₁ V₂) V₁ V₂ |
WType.instEncodable | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} → [(a : α) → Fintype (β a)] → [(a : α) → Encodable (β a)] → [Encodable α] → Encodable (WType β) |
Module.supportDim_le_of_surjective | Mathlib.RingTheory.KrullDimension.Module | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
Function.Surjective ⇑f → Module.supportDim R N ≤ Module.supportDim R M |
Matroid.cRk_map_eq | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} {X : Set β} (M : Matroid α) (hf : Set.InjOn f M.E), (M.map f hf).cRk X = M.cRk (f ⁻¹' X) |
Subarray.size_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u_1} {s : Subarray α}, Std.Slice.size s ≤ s.array.size |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_4 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} (n : ℕ) {stop start : ℕ}, start - stop = n + 1 → ¬stop < start → False |
Equiv.sumSigmaDistrib_symm_apply | Mathlib.Logic.Equiv.Sum | ∀ {α : Type u_10} {β : Type u_11} (t : α ⊕ β → Type u_9) (a : (i : α) × t (Sum.inl i) ⊕ (i : β) × t (Sum.inr i)),
(Equiv.sumSigmaDistrib t).symm a = Sum.elim (fun a => ⟨Sum.inl a.fst, a.snd⟩) (fun b => ⟨Sum.inr b.fst, b.snd⟩) a |
_private.Mathlib.Order.Atoms.0.IsAtomic.Set.Iic.isAtomic.match_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] (y : α) (motive : (∃ a, IsAtom a ∧ a ≤ y) → Prop)
(x : ∃ a, IsAtom a ∧ a ≤ y), (∀ (a : α) (ha : IsAtom a) (hay : a ≤ y), motive ⋯) → motive x |
Lean.Elab.Tactic.BVDecide.Frontend.TacticContext.ctorIdx | Lean.Elab.Tactic.BVDecide.Frontend.LRAT | Lean.Elab.Tactic.BVDecide.Frontend.TacticContext → ℕ |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Widget.InteractiveGoal.562241082._hygCtx._hyg.1.rec | Lean.Widget.InteractiveGoal | {motive : Lean.Widget.RpcEncodablePacket✝ → Sort u} →
((names fvarIds type : Lean.Json) →
(val? isInstance? isType? isInserted? isRemoved? : Option Lean.Json) →
motive
{ names := names, fvarIds := fvarIds, type := type, val? := val?, isInstance? := isInstance?,
isType? := isType?, isInserted? := isInserted?, isRemoved? := isRemoved? }) →
(t : Lean.Widget.RpcEncodablePacket✝) → motive t |
Int.sub_lt_self | Init.Data.Int.Order | ∀ (a : ℤ) {b : ℤ}, 0 < b → a - b < a |
Commute.eq | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b → a * b = b * a |
TopologicalSpace.Opens.frameMinimalAxioms._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a b c : TopologicalSpace.Opens α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c |
AddSubmonoid.addUnitsEquivAddUnitsType._proof_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M),
Function.LeftInverse (fun x => ⟨{ val := ↑↑x, neg := ↑↑(-x), val_neg := ⋯, neg_val := ⋯ }, ⋯⟩) fun x =>
match x with
| ⟨val, h⟩ =>
{ val := ⟨(AddUnits.coeHom M) val, ⋯⟩, neg := ⟨(AddUnits.coeHom M) (-val), ⋯⟩, val_neg := ⋯, neg_val := ⋯ } |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_eq_some_iff._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_30 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i < (List.filter p (head :: tail)).length → p head = true → -1 * ↑i + 1 ≤ 0 → i - 1 < (List.filter p tail).length |
TensorProduct.smul_tmul | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} {R' : Type u_4} [inst : CommSemiring R] [inst_1 : Monoid R'] {M : Type u_7} {N : Type u_8}
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : DistribMulAction R' M] [inst_5 : Module R M]
[inst_6 : Module R N] [inst_7 : DistribMulAction R' N] [TensorProduct.CompatibleSMul R R' M N] (r : R') (m : M)
(n : N), (r • m) ⊗ₜ[R] n = m ⊗ₜ[R] (r • n) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.