name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Finset.image_comm | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq β] {s : Finset α} {β' : Type u_4}
[inst_1 : DecidableEq β'] [inst_2 : DecidableEq γ] {f : β → γ} {g : α → β} {f' : α → β'} {g' : β' → γ},
(∀ (a : α), f (g a) = g' (f' a)) → Finset.image f (Finset.image g s) = Finset.image g' (Finset.image f' s) |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_le_size | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w),
aig.decls.size ≤ (Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go aig lhs rhs curr hcurr cin s).aig.decls.size |
CategoryTheory.Limits.CategoricalPullback.fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} → CategoryTheory.Limits.CategoricalPullback F G → A |
_private.Mathlib.Analysis.Distribution.TemperateGrowth.0.Function.HasTemperateGrowth.sub._proof_1_1 | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup F] {f g : E → F}, f - g = f + -g |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.inf_neBot_iff_frequently_left._simp_1_3 | Mathlib.Order.Filter.Bases.Basic | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) |
Projectivization.Independent.mk | Mathlib.LinearAlgebra.Projectivization.Independence | ∀ {ι : Type u_1} {K : Type u_2} {V : Type u_3} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(f : ι → V) (hf : ∀ (i : ι), f i ≠ 0),
LinearIndependent K f → Projectivization.Independent fun i => Projectivization.mk K (f i) ⋯ |
Ordinal.CNF_of_le_one | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {b o : Ordinal.{u_1}}, b ≤ 1 → o ≠ 0 → Ordinal.CNF b o = [(0, o)] |
FloorRing.gc_ceil_coe | Mathlib.Algebra.Order.Floor.Defs | ∀ {α : Type u_4} {inst : Ring α} {inst_1 : LinearOrder α} [self : FloorRing α], GaloisConnection FloorRing.ceil Int.cast |
inner_self_eq_one_of_norm_eq_one | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x : E}, ‖x‖ = 1 → inner 𝕜 x x = 1 |
Lean.Grind.CommRing.Expr.sub.sizeOf_spec | Init.Grind.Ring.CommSolver | ∀ (a b : Lean.Grind.CommRing.Expr), sizeOf (a.sub b) = 1 + sizeOf a + sizeOf b |
OreLocalization.instAddGroupOreLocalization._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : AddGroup X] [inst_3 : DistribMulAction R X] (a : OreLocalization S X), OreLocalization.zsmul 0 a = 0 |
Lean.Meta.Rewrites.RewriteResultConfig.mk._flat_ctor | Lean.Meta.Tactic.Rewrites | Bool →
ℕ →
ℕ →
Lean.MVarId →
Lean.Expr → Lean.Meta.Rewrites.SideConditions → Lean.MetavarContext → Lean.Meta.Rewrites.RewriteResultConfig |
_private.Mathlib.RingTheory.PowerSeries.Basic.0.PowerSeries.coeff_one_pow._simp_1_8 | Mathlib.RingTheory.PowerSeries.Basic | ∀ {a b c : Prop}, ((a ∨ b) ∨ c) = (a ∨ b ∨ c) |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isLevelDefEqS.match_1.eq_11 | Lean.Meta.Sym.Pattern | ∀ (motive : Lean.Level → Lean.Level → Sort u_1) (u₁ u₂ v₁ v₂ : Lean.Level)
(h_1 : (u v : Lean.Name) → motive (Lean.Level.param u) (Lean.Level.param v))
(h_2 : Unit → motive Lean.Level.zero Lean.Level.zero) (h_3 : (u v : Lean.Level) → motive u.succ v.succ)
(h_4 : (a : Lean.Level) → motive Lean.Level.zero a.succ) (h_5 : (a : Lean.Level) → motive a.succ Lean.Level.zero)
(h_6 : (v₁ v₂ : Lean.Level) → motive Lean.Level.zero (v₁.max v₂))
(h_7 : (u₁ u₂ : Lean.Level) → motive (u₁.max u₂) Lean.Level.zero)
(h_8 : (a v : Lean.Level) → motive Lean.Level.zero (a.imax v))
(h_9 : (a u : Lean.Level) → motive (a.imax u) Lean.Level.zero)
(h_10 : (u₁ u₂ v₁ v₂ : Lean.Level) → motive (u₁.max u₂) (v₁.max v₂))
(h_11 : (u₁ u₂ v₁ v₂ : Lean.Level) → motive (u₁.imax u₂) (v₁.imax v₂)) (h_12 : (x x_1 : Lean.Level) → motive x x_1),
(match u₁.imax u₂, v₁.imax v₂ with
| Lean.Level.param u, Lean.Level.param v => h_1 u v
| Lean.Level.zero, Lean.Level.zero => h_2 ()
| u.succ, v.succ => h_3 u v
| Lean.Level.zero, a.succ => h_4 a
| a.succ, Lean.Level.zero => h_5 a
| Lean.Level.zero, v₁.max v₂ => h_6 v₁ v₂
| u₁.max u₂, Lean.Level.zero => h_7 u₁ u₂
| Lean.Level.zero, a.imax v => h_8 a v
| a.imax u, Lean.Level.zero => h_9 a u
| u₁.max u₂, v₁.max v₂ => h_10 u₁ u₂ v₁ v₂
| u₁.imax u₂, v₁.imax v₂ => h_11 u₁ u₂ v₁ v₂
| x, x_1 => h_12 x x_1) =
h_11 u₁ u₂ v₁ v₂ |
Lean.JsonNumber.instNeg | Lean.Data.Json.Basic | Neg Lean.JsonNumber |
Finsupp.span_image_eq_map_linearCombination | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_5) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{v : α → M} (s : Set α),
Submodule.span R (v '' s) = Submodule.map (Finsupp.linearCombination R v) (Finsupp.supported R R s) |
_private.Lean.Server.ProtocolOverview.0.Lean.Server.Overview.MessageOverview.request | Lean.Server.ProtocolOverview | Lean.Server.Overview.RequestOverview✝ → Lean.Server.Overview.MessageOverview✝ |
ByteArray.toUInt64BE! | Init.Data.ByteArray.Extra | ByteArray → UInt64 |
CategoryTheory.Kleisli.Adjunction.adj._proof_3 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : CategoryTheory.Monad C) {X Y : C}
{Z : CategoryTheory.Kleisli T} (f : X ⟶ Y) (g : Y ⟶ (CategoryTheory.Kleisli.Adjunction.fromKleisli T).obj Z),
{ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }.symm
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Kleisli.Adjunction.toKleisli T).map f)
({ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }.symm g) |
ProbabilityTheory.HasGaussianLaw.memLp | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] [CompleteSpace E]
[SecondCountableTopology E], ProbabilityTheory.HasGaussianLaw X P → ∀ {p : ENNReal}, p ≠ ⊤ → MeasureTheory.MemLp X p P |
Mathlib.Tactic.ITauto.Proof.orInR | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Proof → Mathlib.Tactic.ITauto.Proof |
Set.finite_iff_bddAbove | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_3} {s : Set α} [inst : SemilatticeSup α] [LocallyFiniteOrder α] [OrderBot α], s.Finite ↔ BddAbove s |
Representation.Equiv.trans_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A G W}
{τ : Representation A G U} (φ : ρ.Equiv σ) (ψ : σ.Equiv τ) (v : V), (φ.trans ψ) v = ψ (φ v) |
banach_steinhaus_iSup_nnnorm | Mathlib.Analysis.Normed.Operator.BanachSteinhaus | ∀ {E : Type u_1} {F : Type u_2} {𝕜 : Type u_3} {𝕜₂ : Type u_4} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂] {ι : Type u_5}
[CompleteSpace E] {g : ι → E →SL[σ₁₂] F}, (∀ (x : E), ⨆ i, ↑‖(g i) x‖₊ < ⊤) → ⨆ i, ↑‖g i‖₊ < ⊤ |
RootPairing.EmbeddedG2.threeShortAddLongRoot | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | {ι : 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) → [P.EmbeddedG2] → M |
CategoryTheory.Presheaf.instPreservesFiniteProductsOppositeObjFunctorIsSheafCoherentTopology | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u₃}
[inst_1 : CategoryTheory.Category.{v₃, u₃} A] [inst_2 : CategoryTheory.Preregular C]
[inst_3 : CategoryTheory.FinitaryExtensive C] (F : CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) A),
CategoryTheory.Limits.PreservesFiniteProducts F.obj |
CategoryTheory.Limits.PullbackCone.unopOpIso | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y Z : Cᵒᵖ} → {f : X ⟶ Z} → {g : Y ⟶ Z} → (c : CategoryTheory.Limits.PullbackCone f g) → c.unop.op ≅ c |
BoundedContinuousFunction.toContinuousMapₐ._proof_4 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {γ : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedRing γ]
(x x_1 : BoundedContinuousFunction α γ), ↑(x * x_1) = ↑(x * x_1) |
Lean.Meta.UnificationConstraint.mk.sizeOf_spec | Lean.Meta.UnificationHint | ∀ (lhs rhs : Lean.Expr), sizeOf { lhs := lhs, rhs := rhs } = 1 + sizeOf lhs + sizeOf rhs |
instUniqueEmbOfIsPurelyInseparable._proof_1 | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (E : Type u_1) [inst : Field E], IsReduced (AlgebraicClosure E) |
HomologicalComplex.cylinder.homotopy₀₁._proof_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_1}
{c : ComplexShape ι} (K : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel]
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)]
[inst_4 :
HomologicalComplex.HasHomotopyCofiber
(CategoryTheory.Limits.biprod.lift (CategoryTheory.CategoryStruct.id K) (-CategoryTheory.CategoryStruct.id K))],
HomologicalComplex.cylinder.ι₀ K =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.cylinder.ι₁ K)
(CategoryTheory.CategoryStruct.comp (HomologicalComplex.cylinder.π K) (HomologicalComplex.cylinder.ι₀ K)) |
Lean.Elab.ContextInfo.mk.sizeOf_spec | Lean.Elab.InfoTree.Types | ∀ (toCommandContextInfo : Lean.Elab.CommandContextInfo) (parentDecl? : Option Lean.Name)
(autoImplicits : Array Lean.Expr),
sizeOf { toCommandContextInfo := toCommandContextInfo, parentDecl? := parentDecl?, autoImplicits := autoImplicits } =
1 + sizeOf toCommandContextInfo + sizeOf parentDecl? + sizeOf autoImplicits |
CategoryTheory.GrothendieckTopology.Point.skyscraperPresheafHomEquiv | Mathlib.CategoryTheory.Sites.Point.Skyscraper | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
(Φ : J.Point) →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[inst_2 : CategoryTheory.Limits.HasProducts A] →
{P : CategoryTheory.Functor Cᵒᵖ A} →
{M : A} →
[inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A] →
(Φ.presheafFiber.obj P ⟶ M) ≃ (P ⟶ Φ.skyscraperPresheaf M) |
sup_inf_left | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : DistribLattice α] (a b c : α), a ⊔ b ⊓ c = (a ⊔ b) ⊓ (a ⊔ c) |
_private.Mathlib.Data.Subtype.0.Subtype.coe_eq_iff._proof_1_1 | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {a : { a // p a }} {b : α}, ↑a = b → p b |
OrderMonoidHom.casesOn | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : MulOneClass α] →
[inst_3 : MulOneClass β] →
{motive : (α →*o β) → Sort u} →
(t : α →*o β) →
((toMonoidHom : α →* β) →
(monotone' : Monotone (↑toMonoidHom).toFun) →
motive { toMonoidHom := toMonoidHom, monotone' := monotone' }) →
motive t |
CategoryTheory.RetractArrow.unop | Mathlib.CategoryTheory.Retract | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z W : Cᵒᵖ} →
{f : X ⟶ Y} → {g : Z ⟶ W} → CategoryTheory.RetractArrow f g → CategoryTheory.RetractArrow f.unop g.unop |
Lean.Expr.CollectLooseBVars.State.bvars._default | Lean.Util.CollectLooseBVars | Std.HashSet ℕ |
Array.insertIdx_comm._proof_5 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} (b : α) {i j : ℕ} {xs : Array α}, i ≤ j → ∀ (x : j ≤ xs.size), i ≤ (xs.insertIdx j b x).size |
HomotopicalAlgebra.ModelCategory.instIsWeakFactorizationSystemTrivialCofibrationsFibrations | Mathlib.AlgebraicTopology.ModelCategory.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlgebra.fibrations C) |
Aesop.instInhabitedSubstitution | Aesop.Forward.Substitution | Inhabited Aesop.Substitution |
_private.Mathlib.RingTheory.SimpleRing.Field.0.IsSimpleRing.isField_center._simp_1_4 | Mathlib.RingTheory.SimpleRing.Field | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x |
CategoryTheory.Endofunctor.Coalgebra.Hom.comp._proof_2 | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor C C}
{V₀ V₁ V₂ : CategoryTheory.Endofunctor.Coalgebra F} (f : V₀.Hom V₁) (g : V₁.Hom V₂),
CategoryTheory.CategoryStruct.comp V₀.str (F.map (CategoryTheory.CategoryStruct.comp f.f g.f)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.f g.f) V₂.str |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_1 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (x q : R) (motive : x ∣ q → Prop) (x_1 : x ∣ q),
(∀ (r : R) (hr : q = x * r), motive ⋯) → motive x_1 |
LinearEquiv.isPrincipal_iff | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M₂] (e : M ≃ₗ[R] M₂), Module.IsPrincipal R M ↔ Module.IsPrincipal R M₂ |
HomotopicalAlgebra.PrepathObject.ι_p₁_assoc | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (self : HomotopicalAlgebra.PrepathObject A) {Z : C}
(h : A ⟶ Z), CategoryTheory.CategoryStruct.comp self.ι (CategoryTheory.CategoryStruct.comp self.p₁ h) = h |
Algebra.Generators.cotangentCompLocalizationAwayEquiv_symm_comp_inl | Mathlib.RingTheory.Extension.Cotangent.LocalizationAway | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} {ι : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T]
[inst_6 : IsScalarTower R S T] (g : S) [inst_7 : IsLocalization.Away g T] (P : Algebra.Generators R S ι)
{x : ((Algebra.Generators.localizationAway T g).comp P).toExtension.Cotangent}
(hx :
(Algebra.Extension.Cotangent.map ((Algebra.Generators.localizationAway T g).ofComp P).toExtensionHom) x =
Algebra.Generators.cMulXSubOneCotangent T g),
↑(Algebra.Generators.cotangentCompLocalizationAwayEquiv g P hx).symm ∘ₗ
LinearMap.inl T (TensorProduct S T P.toExtension.Cotangent)
(Algebra.Generators.localizationAway T g).toExtension.Cotangent =
LinearMap.liftBaseChange T
(Algebra.Extension.Cotangent.map ((Algebra.Generators.localizationAway T g).toComp P).toExtensionHom) |
DirichletCharacter.unit_norm_eq_one | Mathlib.NumberTheory.DirichletCharacter.Bounds | ∀ {F : Type u_1} [inst : NormedField F] {n : ℕ} (χ : DirichletCharacter F n) (a : (ZMod n)ˣ), ‖χ ↑a‖ = 1 |
IsAlgClosed.roots_eq_zero_iff | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {k : Type u} [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, p.roots = 0 ↔ p = Polynomial.C (p.coeff 0) |
_private.Mathlib.Data.Finset.Prod.0.Finset.product_image_snd._simp_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b |
Lean.Meta.Ext.ExtTheorems.erased | Lean.Meta.Tactic.Ext | Lean.Meta.Ext.ExtTheorems → Lean.PHashSet Lean.Name |
Ideal.radical_minimalPrimes | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {I : Ideal R}, I.radical.minimalPrimes = I.minimalPrimes |
AddSubgroup.quotientEquivProdOfLE | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [inst : AddGroup α] → {s t : AddSubgroup α} → s ≤ t → α ⧸ s ≃ (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t |
Set.Subsingleton.isDiscrete | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, s.Subsingleton → IsDiscrete s |
_private.Mathlib.Topology.Order.IntermediateValue.0.isTotallyDisconnected_iff_lt._simp_1_2 | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {s : Set α}, IsPreconnected s = s.OrdConnected |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular.0.Matrix.IsTotallyUnimodular.fromRows_unitlike._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β}, (∃ y, x = Sum.inr y) = (x.isRight = true) |
Mathlib.Tactic.Widget.StringDiagram.Node.rec | Mathlib.Tactic.Widget.StringDiagram | {motive : Mathlib.Tactic.Widget.StringDiagram.Node → Sort u} →
((a : Mathlib.Tactic.Widget.StringDiagram.AtomNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.atom a)) →
((a : Mathlib.Tactic.Widget.StringDiagram.IdNode) → motive (Mathlib.Tactic.Widget.StringDiagram.Node.id a)) →
(t : Mathlib.Tactic.Widget.StringDiagram.Node) → motive t |
Lean.Compiler.LCNF.Code.unreach.injEq | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (type type_1 : Lean.Expr),
(Lean.Compiler.LCNF.Code.unreach type = Lean.Compiler.LCNF.Code.unreach type_1) = (type = type_1) |
RelIso.sumLexCongr._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α₁ : Type u_3} {α₂ : Type u_4} {β₁ : Type u_1} {β₂ : Type u_2} {r₁ : α₁ → α₁ → Prop} {r₂ : α₂ → α₂ → Prop}
{s₁ : β₁ → β₁ → Prop} {s₂ : β₂ → β₂ → Prop} (e₁ : r₁ ≃r s₁) (e₂ : r₂ ≃r s₂) (a b : α₁ ⊕ α₂),
Sum.Lex s₁ s₂ ((e₁.sumCongr e₂.toEquiv) a) ((e₁.sumCongr e₂.toEquiv) b) ↔ Sum.Lex r₁ r₂ a b |
MulAction.mem_fixedPoints' | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] {a : α},
a ∈ MulAction.fixedPoints M α ↔ ∀ a' ∈ MulAction.orbit M a, a' = a |
_private.Mathlib.Topology.Algebra.InfiniteSum.Basic.0.hasProd_prod._simp_1_5 | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
Algebra.Extension.cotangentEquiv._proof_4 | Mathlib.RingTheory.Extension.Basic | ∀ {S : Type u_1} [inst : CommRing S], RingHomInvPair (RingHom.id S) (RingHom.id S) |
SimpleGraph.Subgraph.IsInduced | Mathlib.Combinatorics.SimpleGraph.Subgraph | {V : Type u} → {G : SimpleGraph V} → G.Subgraph → Prop |
Std.DTreeMap.Internal.Zipper.toList | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Zipper α β → List ((a : α) × β a) |
MeromorphicOn.divisor_fun_mul | Mathlib.Analysis.Meromorphic.Divisor | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {U : Set 𝕜} {f₁ f₂ : 𝕜 → 𝕜},
MeromorphicOn f₁ U →
MeromorphicOn f₂ U →
(∀ z ∈ U, meromorphicOrderAt f₁ z ≠ ⊤) →
(∀ z ∈ U, meromorphicOrderAt f₂ z ≠ ⊤) →
MeromorphicOn.divisor (fun z => f₁ z * f₂ z) U = MeromorphicOn.divisor f₁ U + MeromorphicOn.divisor f₂ U |
Rat.num_natCast | Init.Data.Rat.Lemmas | ∀ (n : ℕ), (↑n).num = ↑n |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.isDershowitzMannaLT_of_transGen_oneStep | Mathlib.Data.Multiset.DershowitzManna | ∀ {α : Type u_1} [inst : Preorder α] {M N : Multiset α},
Relation.TransGen Multiset.OneStep✝ M N → M.IsDershowitzMannaLT N |
MeasureTheory.SimpleFunc.piecewise_univ | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f g : MeasureTheory.SimpleFunc α β),
MeasureTheory.SimpleFunc.piecewise Set.univ ⋯ f g = f |
Std.DHashMap.Raw.get!_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k k' : α} [hi : Inhabited (β k')] {f : Option (β k) → Option (β k)},
m.WF → (m.alter k f).get! k' = if heq : (k == k') = true then (Option.map (cast ⋯) (f (m.get? k))).get! else m.get! k' |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_5 | Std.Data.DTreeMap.Internal.Operations | ¬0 ≤ 0 + 1 → False |
AffineIsometryEquiv.coe_mk' | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_1} {V₁ : Type u_3} {V₂ : Type u_5} {P₁ : Type u_8} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V₁] [inst_2 : NormedSpace 𝕜 V₁] [inst_3 : PseudoMetricSpace P₁]
[inst_4 : NormedAddTorsor V₁ P₁] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMetricSpace P₂] [inst_8 : NormedAddTorsor V₂ P₂] (e : P₁ → P₂) (e' : V₁ ≃ₗᵢ[𝕜] V₂) (p : P₁)
(h : ∀ (p' : P₁), e p' = e' (p' -ᵥ p) +ᵥ e p), ⇑(AffineIsometryEquiv.mk' e e' p h) = e |
CategoryTheory.Limits.WalkingReflexivePair.rec | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {motive : CategoryTheory.Limits.WalkingReflexivePair → Sort u} →
motive CategoryTheory.Limits.WalkingReflexivePair.zero →
motive CategoryTheory.Limits.WalkingReflexivePair.one → (t : CategoryTheory.Limits.WalkingReflexivePair) → motive t |
Std.HashSet.Raw.noConfusion | Std.Data.HashSet.Raw | {P : Sort u_1} →
{α : Type u} →
{t : Std.HashSet.Raw α} →
{α' : Type u} → {t' : Std.HashSet.Raw α'} → α = α' → t ≍ t' → Std.HashSet.Raw.noConfusionType P t t' |
Nat.sq_mul_squarefree_of_pos' | Mathlib.Data.Nat.Squarefree | ∀ {n : ℕ}, 0 < n → ∃ a b, (b + 1) ^ 2 * (a + 1) = n ∧ Squarefree (a + 1) |
Bialgebra.TensorProduct.assoc._proof_4 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_4) (C : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Bialgebra S A] [inst_4 : Algebra R A] [inst_5 : Algebra R S]
[inst_6 : IsScalarTower R S A] [inst_7 : Semiring C] [inst_8 : Bialgebra S C], SMulCommClass R S (TensorProduct S A C) |
BoxIntegral.TaggedPrepartition.distortion_le_of_mem | Mathlib.Analysis.BoxIntegral.Partition.Tagged | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} (π : BoxIntegral.TaggedPrepartition I) [inst : Fintype ι],
J ∈ π → J.distortion ≤ π.distortion |
instZeroLieSubalgebra | Mathlib.Algebra.Lie.Subalgebra | (R : Type u) →
(L : Type v) → [inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → Zero (LieSubalgebra R L) |
CategoryTheory.Limits.WalkingReflexivePair.Hom.rightCompReflexion.elim | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {motive : (a a_1 : CategoryTheory.Limits.WalkingReflexivePair) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WalkingReflexivePair} →
(t : a.Hom a_1) →
t.ctorIdx = 4 →
motive CategoryTheory.Limits.WalkingReflexivePair.one CategoryTheory.Limits.WalkingReflexivePair.one
CategoryTheory.Limits.WalkingReflexivePair.Hom.rightCompReflexion →
motive a a_1 t |
CategoryTheory.Functor.LeftExtension.postcompose₂_obj_hom_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} {D' : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
[inst_3 : CategoryTheory.Category.{v_5, u_5} D'] (L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H)
(G : CategoryTheory.Functor H D')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit F) ((CategoryTheory.Functor.whiskeringLeft C D H).obj L))
(X_1 : C), ((CategoryTheory.Functor.LeftExtension.postcompose₂ L F G).obj X).hom.app X_1 = G.map (X.hom.app X_1) |
Fin.reduceCastLT._regBuiltin.Fin.reduceCastLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.3768712919._hygCtx._hyg.16 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit |
_private.Lean.Elab.Print.0.Lean.Elab.Command.levelParamsToMessageData | Lean.Elab.Print | List Lean.Name → Lean.MessageData |
Mathlib.Tactic.Bicategory.structuralIsoOfExpr_whiskerRight | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g : a ⟶ b} (h : b ⟶ c) (η : f ⟶ g) (η' : f ≅ g),
η'.hom = η → (CategoryTheory.Bicategory.whiskerRightIso η' h).hom = CategoryTheory.Bicategory.whiskerRight η h |
LinearEquiv.image_closure_of_convex | Mathlib.Analysis.LocallyConvex.WeakSpace | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : AddCommGroup F] [inst_4 : Module 𝕜 F] [inst_5 : Module ℝ E] [IsScalarTower ℝ 𝕜 E] [inst_7 : Module ℝ F]
[IsScalarTower ℝ 𝕜 F] [inst_9 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E]
[LocallyConvexSpace ℝ E] [inst_13 : TopologicalSpace F] [IsTopologicalAddGroup F] [ContinuousSMul 𝕜 F]
[LocallyConvexSpace ℝ F] {s : Set E},
Convex ℝ s →
∀ (e : E ≃ₗ[𝕜] F),
(∀ (f : StrongDual 𝕜 F), Continuous ⇑(e.dualMap ↑f)) →
(∀ (f : StrongDual 𝕜 E), Continuous ⇑(e.symm.dualMap ↑f)) → ⇑e '' closure s = closure (⇑e '' s) |
Affine.Simplex.sign_signedInfDist_lineMap_incenter_touchpoint | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) {i j : Fin (n + 1)},
i ≠ j →
∀ {r : ℝ},
r ∈ Set.Icc 0 1 →
SignType.sign ((s.signedInfDist j) ((AffineMap.lineMap s.incenter (s.touchpoint ∅ i)) r)) =
SignType.sign ((s.signedInfDist j) s.incenter) |
CategoryTheory.Limits.Bicones.functoriality_obj_pt | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {D : Type uD} [inst_2 : CategoryTheory.Category.{uD', uD} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : J → C) (G : CategoryTheory.Functor C D)
[inst_4 : G.PreservesZeroMorphisms] (A : CategoryTheory.Limits.Bicone F),
((CategoryTheory.Limits.Bicones.functoriality F G).obj A).pt = G.obj A.pt |
_private.Lean.MetavarContext.0.Lean.MetavarContext.MkBinding.visit._unsafe_rec | Lean.MetavarContext | Array Lean.Expr → Lean.Expr → Lean.MetavarContext.MkBinding.M Lean.Expr |
Aesop.BestFirstQueue.ActiveGoal.mk | Aesop.Search.Queue | Aesop.GoalRef → Aesop.Percent → Aesop.Iteration → Aesop.Iteration → Aesop.BestFirstQueue.ActiveGoal |
SMulMemClass.toModule' | Mathlib.Algebra.Module.Submodule.Defs | (S : Type u_2) →
(R' : Type u_3) →
(R : Type u_4) →
(A : Type u_5) →
[inst : Semiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Semiring R'] →
[inst_4 : SMul R' R] →
[inst_5 : Module R' A] →
[IsScalarTower R' R A] →
[inst_7 : SetLike S A] →
[inst_8 : AddSubmonoidClass S A] → [SMulMemClass S R A] → (s : S) → Module R' ↥s |
deriv.lhopital_zero_right_on_Ico | Mathlib.Analysis.Calculus.LHopital | ∀ {a b : ℝ} {l : Filter ℝ} {f g : ℝ → ℝ},
a < b →
DifferentiableOn ℝ f (Set.Ioo a b) →
ContinuousOn f (Set.Ico a b) →
ContinuousOn g (Set.Ico a b) →
(∀ x ∈ Set.Ioo a b, deriv g x ≠ 0) →
f a = 0 →
g a = 0 →
Filter.Tendsto (fun x => deriv f x / deriv g x) (nhdsWithin a (Set.Ioi a)) l →
Filter.Tendsto (fun x => f x / g x) (nhdsWithin a (Set.Ioi a)) l |
_private.Mathlib.GroupTheory.Index.0.Subgroup.index_eq_two_iff'._simp_1_2 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : DivisionMonoid G] (a b : G), b⁻¹ * a⁻¹ = (a * b)⁻¹ |
PowerSeries.isUnit_iff_constantCoeff | Mathlib.RingTheory.PowerSeries.Inverse | ∀ {R : Type u_1} [inst : Ring R] {φ : PowerSeries R}, IsUnit φ ↔ IsUnit (PowerSeries.constantCoeff φ) |
Equiv.Perm.IsCycle.nonempty_support | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α}, g.IsCycle → g.support.Nonempty |
List.IsInfix.reverse | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+: l₂ → l₁.reverse <:+: l₂.reverse |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.valuation_div_le_one_iff._simp_1_3 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R),
(v.intValuation r < 1) = (r ∈ v.asIdeal) |
UInt16.toUInt8_lt._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a.toUInt8 < b.toUInt8) = (a % 256 < b % 256) |
Lean.Parser.Error._sizeOf_1 | Lean.Parser.Types | Lean.Parser.Error → ℕ |
_private.Mathlib.Analysis.Calculus.ContDiff.Comp.0.ContDiffWithinAt.comp.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_2} {G : Type u_3} [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} {t : Set F} {g : F → G} {f : E → F} (x : E)
(motive : (n : WithTop ℕ∞) → ContDiffWithinAt 𝕜 n g t (f x) → ContDiffWithinAt 𝕜 n f s x → Prop) (n : WithTop ℕ∞)
(hg : ContDiffWithinAt 𝕜 n g t (f x)) (hf : ContDiffWithinAt 𝕜 n f s x),
(∀ (hg : ContDiffWithinAt 𝕜 ⊤ g t (f x)) (hf : ContDiffWithinAt 𝕜 ⊤ f s x), motive none hg hf) →
(∀ (n : ℕ∞) (hg : ContDiffWithinAt 𝕜 (↑n) g t (f x)) (hf : ContDiffWithinAt 𝕜 (↑n) f s x), motive (some n) hg hf) →
motive n hg hf |
LinearIndepOn.id_union | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {s t : Set M},
LinearIndepOn R id s →
LinearIndepOn R id t → Disjoint (Submodule.span R s) (Submodule.span R t) → LinearIndepOn R id (s ∪ t) |
UInt8.reduceOfNatLT._regBuiltin.UInt8.reduceOfNatLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.322 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit |
Lean.LocalDecl.rec | Lean.LocalContext | {motive : Lean.LocalDecl → Sort u} →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) → motive (Lean.LocalDecl.cdecl index fvarId userName type bi kind)) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type value : Lean.Expr) →
(nondep : Bool) →
(kind : Lean.LocalDeclKind) →
motive (Lean.LocalDecl.ldecl index fvarId userName type value nondep kind)) →
(t : Lean.LocalDecl) → motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.