name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.Sat.AIG.RelabelNat.State.noConfusionType | Std.Sat.AIG.RelabelNat | Sort u →
{α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{decls : Array (Std.Sat.AIG.Decl α)} →
{idx : ℕ} →
Std.Sat.AIG.RelabelNat.State α decls idx →
{α' : Type} →
[inst' : DecidableEq α'] →
[inst'_1 : Hashable α'] →
{decls' : Array (Std.Sat.AIG.Decl α')} →
{idx' : ℕ} → Std.Sat.AIG.RelabelNat.State α' decls' idx' → Sort u |
_private.Mathlib.RingTheory.OrderOfVanishing.0.Ring.ordFrac._simp_1 | Mathlib.RingTheory.OrderOfVanishing | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a = (a ≠ 0) |
WellFounded.Nat.fix.go.congr_simp | Init.WF | ∀ {α : Sort u} {motive : α → Sort v} (h : α → ℕ)
(F F_1 : (x : α) → ((y : α) → InvImage (fun x1 x2 => x1 < x2) h y x → motive y) → motive x),
F = F_1 →
∀ (fuel fuel_1 : ℕ) (e_fuel : fuel = fuel_1) (x : α) (a : h x < fuel),
WellFounded.Nat.fix.go h F fuel x a = WellFounded.Nat.fix.go h F_1 fuel_1 x ⋯ |
hasSum_nat_jacobiTheta | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {τ : ℂ}, 0 < τ.im → HasSum (fun n => Complex.exp (↑Real.pi * Complex.I * (↑n + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2) |
Std.Sat.AIG.denote_idx_gate | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {assign : α → Bool} {invert : Bool}
{lhs rhs : Std.Sat.AIG.Fanin} {aig : Std.Sat.AIG α} {hstart : start < aig.decls.size}
(h : aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs),
⟦assign, { aig := aig, ref := { gate := start, invert := invert, hgate := hstart } }⟧ =
(⟦assign, { aig := aig, ref := { gate := lhs.gate, invert := lhs.invert, hgate := ⋯ } }⟧ &&
⟦assign, { aig := aig, ref := { gate := rhs.gate, invert := rhs.invert, hgate := ⋯ } }⟧ ^^
invert) |
TopologicalSpace.DiscreteTopology.metrizableSpace | Mathlib.Topology.Metrizable.Basic | ∀ {X : Type u_2} [inst : TopologicalSpace X] [DiscreteTopology X], TopologicalSpace.MetrizableSpace X |
CategoryTheory.Limits.isLimitOfHasBinaryProductOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] →
[CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.pair X Y) G] →
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.BinaryFan.mk (G.map CategoryTheory.Limits.prod.fst)
(G.map CategoryTheory.Limits.prod.snd)) |
Real.fourierIntegralInv_comp_linearIsometry | Mathlib.Analysis.Fourier.FourierTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V] {W : Type u_3}
[inst_6 : NormedAddCommGroup W] [inst_7 : InnerProductSpace ℝ W] [inst_8 : MeasurableSpace W] [inst_9 : BorelSpace W]
[inst_10 : FiniteDimensional ℝ W] [inst_11 : FiniteDimensional ℝ V] (A : W ≃ₗᵢ[ℝ] V) (f : V → E) (w : W),
FourierTransformInv.fourierInv (f ∘ ⇑A) w = FourierTransformInv.fourierInv f (A w) |
CategoryTheory.ShortComplex.Splitting.mk._flat_ctor | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S : CategoryTheory.ShortComplex C} →
(r : S.X₂ ⟶ S.X₁) →
(s : S.X₃ ⟶ S.X₂) →
autoParam (CategoryTheory.CategoryStruct.comp S.f r = CategoryTheory.CategoryStruct.id S.X₁)
CategoryTheory.ShortComplex.Splitting.f_r._autoParam →
autoParam (CategoryTheory.CategoryStruct.comp s S.g = CategoryTheory.CategoryStruct.id S.X₃)
CategoryTheory.ShortComplex.Splitting.s_g._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp r S.f + CategoryTheory.CategoryStruct.comp S.g s =
CategoryTheory.CategoryStruct.id S.X₂)
CategoryTheory.ShortComplex.Splitting.id._autoParam →
S.Splitting |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'._simp_1_6 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {α : Type u} [inst : Monoid α] (b : αˣ) {a c : α}, (↑b * a = c) = (a = ↑b⁻¹ * c) |
Mathlib.Tactic.ITauto.Proof.orImpL.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orImpL = 1 + sizeOf p |
Dense.eq_of_inner_right | Mathlib.Analysis.InnerProductSpace.Continuous | ∀ (𝕜 : Type u_4) {E : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E} {S : Set E}, Dense S → (∀ v ∈ S, inner 𝕜 v x = inner 𝕜 v y) → x = y |
FermatLastTheoremForThreeGen.Solution.toSolution' | Mathlib.NumberTheory.FLT.Three | {K : Type u_1} →
[inst : Field K] →
{ζ : K} →
{hζ : IsPrimitiveRoot ζ 3} → FermatLastTheoremForThreeGen.Solution hζ → FermatLastTheoremForThreeGen.Solution' hζ |
iteratedDerivWithin_add | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜} {s : Set 𝕜},
x ∈ s →
UniqueDiffOn 𝕜 s →
∀ {f g : 𝕜 → F},
ContDiffWithinAt 𝕜 (↑n) f s x →
ContDiffWithinAt 𝕜 (↑n) g s x →
iteratedDerivWithin n (f + g) s x = iteratedDerivWithin n f s x + iteratedDerivWithin n g s x |
MeasureTheory.lintegral_def | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
MeasureTheory.lintegral μ f = ⨆ g, ⨆ (_ : ⇑g ≤ f), g.lintegral μ |
Polynomial.Splits.X_pow | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (Polynomial.X ^ n).Splits |
Lean.Compiler.LCNF.Phase.le_refl._simp_1 | Lean.Compiler.LCNF.PassManager | ∀ (p : Lean.Compiler.LCNF.Phase), (p ≤ p) = True |
ENNReal.continuousAt_const_mul | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {a b : ENNReal}, a ≠ ⊤ ∨ b ≠ 0 → ContinuousAt (fun x => a * x) b |
DirectSum.Decomposition.mk.noConfusion | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
{inst : DecidableEq ι} →
{inst_1 : AddCommMonoid M} →
{inst_2 : SetLike σ M} →
{inst_3 : AddSubmonoidClass σ M} →
{ℳ : ι → σ} →
{P : Sort u} →
{decompose' : M → DirectSum ι fun i => ↥(ℳ i)} →
{left_inv : Function.LeftInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose'} →
{right_inv : Function.RightInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose'} →
{decompose'' : M → DirectSum ι fun i => ↥(ℳ i)} →
{left_inv' : Function.LeftInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose''} →
{right_inv' : Function.RightInverse (⇑(DirectSum.coeAddMonoidHom ℳ)) decompose''} →
{ decompose' := decompose', left_inv := left_inv, right_inv := right_inv } =
{ decompose' := decompose'', left_inv := left_inv', right_inv := right_inv' } →
(decompose' ≍ decompose'' → P) → P |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_1 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
{x : ↥S}, (x = 0) = (↑x = 0) |
intervalIntegral.FTCFilter.le_nhds | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {a : outParam ℝ} (outer : Filter ℝ) {inner : outParam (Filter ℝ)} [self : intervalIntegral.FTCFilter a outer inner],
inner ≤ nhds a |
Mathlib.Meta.Positivity.evalNNRealSqrt | Mathlib.Data.Real.Sqrt | Mathlib.Meta.Positivity.PositivityExt |
Submonoid.units._proof_2 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ},
x ∈ (Submonoid.comap (Units.coeHom M) S ⊓ (Submonoid.comap (Units.coeHom M) S)⁻¹).carrier →
x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S) ∧ x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S)⁻¹ |
Order.isPredLimitRecOn_pred_of_not_isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : LinearOrder α] [inst_1 : PredOrder α]
(isMax : (a : α) → IsMax a → motive a) (pred : (a : α) → ¬IsMin a → motive (Order.pred a))
(isPredLimit : (a : α) → Order.IsPredLimit a → motive a) (hb : ¬IsMin b),
Order.isPredLimitRecOn (Order.pred b) isMax pred isPredLimit = pred b hb |
CategoryTheory.ObjectProperty.isSeparating_unop_iff | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
P.unop.IsSeparating ↔ P.IsCoseparating |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Gaps.0.Finset.sum_eq_sum_range_intervalGapsWithin._proof_1_5 | Mathlib.Algebra.BigOperators.Group.Finset.Gaps | ∀ {k : ℕ}, ∀ i ∈ Set.Iio k, i ∈ Finset.range k |
Std.DTreeMap.Internal.Impl.get?ₘ_eq_getValueCast? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : Std.LawfulEqOrd α] [inst_3 : BEq α]
[inst_4 : Std.LawfulBEqOrd α] {k : α} {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get?ₘ k = Std.Internal.List.getValueCast? k t.toListModel |
MeasureTheory.SignedMeasure.null_of_totalVariation_zero | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α) {i : Set α},
s.totalVariation i = 0 → ↑s i = 0 |
Module.Free.chooseBasis._proof_1 | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M], Nonempty (Module.Basis (↑⋯.choose) R M) |
Affine.Simplex.excenterWeights_compl | 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) (signs : Finset (Fin (n + 1))),
s.excenterWeights signsᶜ = s.excenterWeights signs |
_private.Mathlib.NumberTheory.SumFourSquares.0.Int.sq_add_sq_of_two_mul_sq_add_sq._simp_1_1 | Mathlib.NumberTheory.SumFourSquares | ∀ {α : Type u_2} [inst : Semiring α] {a : α}, (2 ∣ a) = Even a |
Representation.Coinvariants.hom_ext_iff | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommRing k] [inst_1 : Monoid G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
{ρ : Representation k G V} {f g : ρ.Coinvariants →ₗ[k] W},
f = g ↔ f ∘ₗ Representation.Coinvariants.mk ρ = g ∘ₗ Representation.Coinvariants.mk ρ |
ValuativeRel.IsRankLeOne.mk | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R],
Nonempty (ValuativeRel.RankLeOneStruct R) → ValuativeRel.IsRankLeOne R |
Function.Antiperiodic.funext' | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Add α] [inst_1 : InvolutiveNeg β],
Function.Antiperiodic f c → (fun x => -f (x + c)) = f |
Array.getElem?_zip_eq_some | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β} {z : α × β} {i : ℕ},
(as.zip bs)[i]? = some z ↔ as[i]? = some z.1 ∧ bs[i]? = some z.2 |
Std.TreeMap.Raw.maxKey!_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).maxKey! = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' |
FirstOrder.Language.PartialEquiv.mk.injEq | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(dom : L.Substructure M) (cod : L.Substructure N) (toEquiv : L.Equiv ↥dom ↥cod) (dom_1 : L.Substructure M)
(cod_1 : L.Substructure N) (toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1),
({ dom := dom, cod := cod, toEquiv := toEquiv } = { dom := dom_1, cod := cod_1, toEquiv := toEquiv_1 }) =
(dom = dom_1 ∧ cod = cod_1 ∧ toEquiv ≍ toEquiv_1) |
Std.TreeMap.keys.eq_1 | Std.Data.TreeSet.Iterator | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp), t.keys = t.inner.keys |
List.unattach_append | Init.Data.List.Attach | ∀ {α : Type u_1} {p : α → Prop} {l₁ l₂ : List { x // p x }}, (l₁ ++ l₂).unattach = l₁.unattach ++ l₂.unattach |
TopologicalSpace.Opens.coe_eq_univ._simp_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {U : TopologicalSpace.Opens α}, (↑U = Set.univ) = (U = ⊤) |
AddMonoidAlgebra.sup_support_list_prod_le | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
[inst_3 : AddMonoid A] [inst_4 : AddMonoid B] [AddLeftMono B] [AddRightMono B] {degb : A → B},
degb 0 ≤ 0 →
(∀ (a b : A), degb (a + b) ≤ degb a + degb b) →
∀ (l : List (AddMonoidAlgebra R A)), l.prod.support.sup degb ≤ (List.map (fun f => f.support.sup degb) l).sum |
Primrec.fst | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec Prod.fst |
_private.Mathlib.Data.List.InsertIdx.0.List.take_eraseIdx_eq_take_of_le._proof_1_1 | Mathlib.Data.List.InsertIdx | ∀ {α : Type u_1} (l : List α) (i j : ℕ), i ≤ j → (List.take i (l.eraseIdx j)).length = (List.take i l).length |
Mathlib.Linter.linter.upstreamableDecl.private | Mathlib.Tactic.Linter.UpstreamableDecl | Lean.Option Bool |
QuadraticMap.proj_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] {n : Type u_9} (i j : n) (x : n → A),
(QuadraticMap.proj i j) x = x i * x j |
UInt8.xor_right_inj | Init.Data.UInt.Bitwise | ∀ {a b : UInt8} (c : UInt8), c ^^^ a = c ^^^ b ↔ a = b |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.instInhabitedStartsWithResult | Lean.Meta.Tactic.Grind.AC.Seq | Inhabited Lean.Grind.AC.StartsWithResult✝ |
AbsoluteValue.casesOn | Mathlib.Algebra.Order.AbsoluteValue.Basic | {R : Type u_5} →
{S : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : PartialOrder S] →
{motive : AbsoluteValue R S → Sort u} →
(t : AbsoluteValue R S) →
((toMulHom : R →ₙ* S) →
(nonneg' : ∀ (x : R), 0 ≤ toMulHom.toFun x) →
(eq_zero' : ∀ (x : R), toMulHom.toFun x = 0 ↔ x = 0) →
(add_le' : ∀ (x y : R), toMulHom.toFun (x + y) ≤ toMulHom.toFun x + toMulHom.toFun y) →
motive { toMulHom := toMulHom, nonneg' := nonneg', eq_zero' := eq_zero', add_le' := add_le' }) →
motive t |
Aesop.GoalId.mk | Aesop.Tree.Data | ℕ → Aesop.GoalId |
Lean.mkPropEq | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr |
Lean.Elab.Term.elabWaitIfContainsMVar._regBuiltin.Lean.Elab.Term.elabWaitIfContainsMVar_1 | Lean.Elab.BuiltinTerm | IO Unit |
CochainComplex.HomComplex.δ_comp_zero_cochain | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G K : CochainComplex C ℤ} {n₁ : ℤ} (z₁ : CochainComplex.HomComplex.Cochain F G n₁)
(z₂ : CochainComplex.HomComplex.Cochain G K 0) (m₁ : ℤ) (h₁ : n₁ + 1 = m₁),
CochainComplex.HomComplex.δ n₁ m₁ (z₁.comp z₂ ⋯) =
z₁.comp (CochainComplex.HomComplex.δ 0 1 z₂) h₁ + (CochainComplex.HomComplex.δ n₁ m₁ z₁).comp z₂ ⋯ |
CompTriple.instIsIdId | Mathlib.Logic.Function.CompTypeclasses | ∀ {M : Type u_1}, CompTriple.IsId id |
SimpleGraph.Walk.support_concat | Mathlib.Combinatorics.SimpleGraph.Walks.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w),
(p.concat h).support = p.support.concat w |
CategoryTheory.Limits.pullbackConeOfRightIso_π_app_none | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso g], (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app none = f |
List.Vector.snoc.eq_1 | Mathlib.Data.Vector.Snoc | ∀ {α : Type u_1} {n : ℕ} (xs : List.Vector α n) (x : α), xs.snoc x = xs ++ x ::ᵥ List.Vector.nil |
Finsupp.equivMapDomain.eq_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (l : α →₀ M),
Finsupp.equivMapDomain f l =
{ support := Finset.map f.toEmbedding l.support, toFun := fun a => l (f.symm a), mem_support_toFun := ⋯ } |
AlgHom.ext | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {φ₁ φ₂ : A →ₐ[R] B}, (∀ (x : A), φ₁ x = φ₂ x) → φ₁ = φ₂ |
Associated.instIsTrans | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], IsTrans M Associated |
IsFiniteLength.brecOn | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R]
{motive : (M : Type u_2) → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → IsFiniteLength R M → Prop}
{M : Type u_2} {inst_1 : AddCommGroup M} {inst_2 : Module R M} (t : IsFiniteLength R M),
(∀ (M : Type u_2) [inst_3 : AddCommGroup M] [inst_4 : Module R M] (t : IsFiniteLength R M),
IsFiniteLength.below t → motive M t) →
motive M t |
Int.ModEq.of_mul_right | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (m : ℤ), a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n] |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ_surjective._simp_1_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A}, (S ≤ T) = (↑S ⊆ ↑T) |
Std.Notify.wait | Std.Sync.Notify | Std.Notify → IO (Std.Internal.IO.Async.AsyncTask Unit) |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {α : Sort u_1} (a b : α), (a = b) = (a ≍ b) |
Matrix.mulVec_surjective_iff_isUnit | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Fintype m] {A : Matrix m m R},
Function.Surjective A.mulVec ↔ IsUnit A |
_private.Mathlib.Data.Nat.Factorization.PrimePow.0.isPrimePow_iff_card_primeFactors_eq_one._simp_1_2 | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (n : ℕ), n.primeFactors = n.factorization.support |
CategoryTheory.Bicategory.Pseudofunctor.ofLaxFunctorToLocallyGroupoid._proof_4 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {B' : Type u_5} [inst_1 : CategoryTheory.Bicategory B']
[CategoryTheory.Bicategory.IsLocallyGroupoid B] (F : CategoryTheory.LaxFunctor B' B) {a b c : B'} (f : a ⟶ b)
(g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g) |
StrictConvexSpace.of_norm_add_ne_two | Mathlib.Analysis.Convex.StrictConvexSpace | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
(∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2) → StrictConvexSpace ℝ E |
CompHausLike.LocallyConstant.adjunction | Mathlib.Condensed.Discrete.LocallyConstant | (P : TopCat → Prop) →
[∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
[inst : CompHausLike.HasProp P PUnit.{u + 1}] →
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P] →
[inst_2 : CompHausLike.HasExplicitPullbacks P] →
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
CategoryTheory.EffectiveEpi f → Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom f)) →
[CompHausLike.HasExplicitFiniteCoproducts P] →
CompHausLike.LocallyConstant.functor P hs ⊣
(CategoryTheory.sheafSections (CategoryTheory.coherentTopology (CompHausLike P)) (Type (max u w))).obj
(Opposite.op (CompHausLike.of P PUnit.{u + 1})) |
Int.subNatNat_sub | Init.Data.Int.Lemmas | ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), Int.subNatNat (m - n) k = Int.subNatNat m (k + n) |
Manifold.«_aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termHasMFDerivAt%_______1» | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab |
Ordinal.veblen_left_monotone | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Monotone fun x => Ordinal.veblen x o |
Ideal.primeHeight_eq_ringKrullDim_iff | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] [FiniteRingKrullDim R] [inst_2 : IsLocalRing R] {I : Ideal R} [inst_3 : I.IsPrime],
↑I.primeHeight = ringKrullDim R ↔ I = IsLocalRing.maximalIdeal R |
Aesop.EqualUpToIdsM.Context._sizeOf_1 | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM.Context → ℕ |
Lean.Meta.Grind.CnstrRHS.mk.inj | Lean.Meta.Tactic.Grind.Extension | ∀ {levelNames : Array Lean.Name} {numMVars : ℕ} {expr : Lean.Expr} {levelNames_1 : Array Lean.Name} {numMVars_1 : ℕ}
{expr_1 : Lean.Expr},
{ levelNames := levelNames, numMVars := numMVars, expr := expr } =
{ levelNames := levelNames_1, numMVars := numMVars_1, expr := expr_1 } →
levelNames = levelNames_1 ∧ numMVars = numMVars_1 ∧ expr = expr_1 |
CategoryTheory.Lax.LaxTrans.StrongCore.mk.inj | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η : F ⟶ G}
{naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅ CategoryTheory.CategoryStruct.comp (F.map f) (η.app b)}
{naturality_hom :
autoParam (∀ {a b : B} (f : a ⟶ b), (naturality f).hom = η.naturality f)
CategoryTheory.Lax.LaxTrans.StrongCore.naturality_hom._autoParam}
{naturality_1 :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅ CategoryTheory.CategoryStruct.comp (F.map f) (η.app b)}
{naturality_hom_1 :
autoParam (∀ {a b : B} (f : a ⟶ b), (naturality_1 f).hom = η.naturality f)
CategoryTheory.Lax.LaxTrans.StrongCore.naturality_hom._autoParam},
{ naturality := naturality, naturality_hom := naturality_hom } =
{ naturality := naturality_1, naturality_hom := naturality_hom_1 } →
naturality = naturality_1 |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_11 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length |
AddConstMap.instMonoid | Mathlib.Algebra.AddConstMap.Basic | {G : Type u_1} → [inst : Add G] → {a : G} → Monoid (AddConstMap G G a a) |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_principal._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.applyAltStx | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) →
Array Lean.Syntax → ℕ → Lean.Syntax → Lean.Elab.Tactic.ElimApp.Alt → Lean.Elab.Tactic.TacticM PUnit.{1} |
Finset.compls_inter | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] [inst_1 : DecidableEq α] (s t : Finset α),
(s ∩ t).compls = s.compls ∩ t.compls |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcₙ_rpowIntegrand₀₁._proof_1_6 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace ℝ A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass ℝ A] (a : A), 0 ≤ a → ∀ r ∈ quasispectrum ℝ a, r ∈ Set.Ici 0 |
AlgebraicGeometry.Scheme.Modules.Hom.mapPresheaf | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X : AlgebraicGeometry.Scheme} → {M N : X.Modules} → (M ⟶ N) → (M.presheaf ⟶ N.presheaf) |
add_neg_lt_iff_lt_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, a + -b < c ↔ a < c + b |
instHasColimitsCommAlgCat | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R], CategoryTheory.Limits.HasColimits (CommAlgCat R) |
BoundedLatticeHom.toInfTopHom._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom α β) (a b : α), f.toFun (a ⊓ b) = f.toFun a ⊓ f.toFun b |
BitVec.toInt_not | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (~~~x).toInt = (2 ^ w - 1 - ↑x.toNat).bmod (2 ^ w) |
CategoryTheory.MorphismProperty.colimitsOfShape_discrete_le_llp_rlp | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type w),
T.colimitsOfShape (CategoryTheory.Discrete J) ≤ T.rlp.llp |
_private.Lean.Elab.Deriving.Nonempty.0.Lean.Elab.Deriving.initFn._@.Lean.Elab.Deriving.Nonempty.1889502729._hygCtx._hyg.2 | Lean.Elab.Deriving.Nonempty | IO Unit |
String.toList.eq_1 | Init.Data.String.Basic | ∀ (s : String), s.toList = (String.Internal.toArray s).toList |
SchwartzMap.evalCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NormedField 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G],
ContinuousConstSMul 𝕜 G |
CoxeterMatrix.ext | Mathlib.GroupTheory.Coxeter.Matrix | ∀ {B : Type u_1} {x y : CoxeterMatrix B}, x.M = y.M → x = y |
Invertible.mulRight | Mathlib.Algebra.Group.Invertible.Basic | {α : Type u} → [inst : Monoid α] → (a : α) → {b : α} → Invertible b → Invertible a ≃ Invertible (a * b) |
Multiset.right_notMem_Ioo | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∉ Multiset.Ioo a b |
_private.Lean.Server.FileWorker.SetupFile.0.Lean.Server.FileWorker.runLakeSetupFile._sparseCasesOn_1 | Lean.Server.FileWorker.SetupFile | {motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.never → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
WeierstrassCurve.coe_variableChange_Δ' | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], ↑(C • W).Δ' = ↑C.u⁻¹ ^ 12 * ↑W.Δ' |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearRupUnits | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_452 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
instDecidableEqZNum.decEq._proof_10 | Mathlib.Data.Num.Basic | ∀ (a b : PosNum), ¬a = b → ¬ZNum.neg a = ZNum.neg b |
AbstractCompletion.closure_range | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α), closure (Set.range pkg.coe) = Set.univ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.