name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Parser.Attr.tactic_alt.parenthesizer | Lean.Parser.Attr | Lean.PrettyPrinter.Parenthesizer |
Sum.map_surjective | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {f : α → γ} {g : β → δ},
Function.Surjective (Sum.map f g) ↔ Function.Surjective f ∧ Function.Surjective g |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ext.match_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} {inst : CommRing R} (motive : ValuativeRel R → Prop) (h : ValuativeRel R),
(∀ (vle : R → R → Prop) (vle_total : ∀ (x y : R), vle x y ∨ vle y x)
(vle_trans : ∀ {z y x : R}, vle x y → vle y z → vle x z)
(vle_add : ∀ {x y z : R}, vle x z → vle y z → vle (x + y) z)
(mul_vle_mul_left : ∀ {x y : R}, vle x y → ∀ (z : R), vle (x * z) (y * z))
(vle_mul_cancel : ∀ {x y z : R}, ¬vle z 0 → vle (x * z) (y * z) → vle x y) (not_vle_one_zero : ¬vle 1 0),
motive
{ vle := vle, vle_total := vle_total, vle_trans := vle_trans, vle_add := vle_add,
mul_vle_mul_left := mul_vle_mul_left, vle_mul_cancel := vle_mul_cancel,
not_vle_one_zero := not_vle_one_zero }) →
motive h |
Module.Basis.prod_apply_inl_fst | Mathlib.LinearAlgebra.Basis.Prod | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} {M : Type u_5} {M' : Type u_6} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M']
(b : Module.Basis ι R M) (b' : Module.Basis ι' R M') (i : ι), ((b.prod b') (Sum.inl i)).1 = b i |
UInt8.toInt8_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (UInt8.ofNat n).toInt8 = Int8.ofNat n |
GradeOrder.wellFoundedGT | Mathlib.Order.Grade | ∀ {α : Type u_3} [inst : Preorder α] (𝕆 : Type u_5) [inst_1 : Preorder 𝕆] [GradeOrder 𝕆 α] [WellFoundedGT 𝕆],
WellFoundedGT α |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimageDiagram.eq_1 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))}
(hF : ∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.map (CategoryTheory.homOfLE ⋯).op)) (X : C)
(y : (F.obj (Opposite.op 0)).val.obj (Opposite.op X)),
CategoryTheory.coherentTopology.preimageDiagram✝ hF X y =
CategoryTheory.Functor.ofOpSequence
(CategoryTheory.coherentTopology.struct.map✝ (CategoryTheory.coherentTopology.preimageStruct✝ hF X y)) |
IsSimpleRing.of_surjective | Mathlib.RingTheory.SimpleRing.Congr | ∀ {R : Type u_1} {S : Type u_2} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] [Nontrivial S] (f : R →+* S),
IsSimpleRing R → Function.Surjective ⇑f → IsSimpleRing S |
Std.HashSet.getD_union_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ ∪ m₂).getD k fallback = m₂.getD k fallback |
Lean.Parser.Term.set_option.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
CircularPartialOrder.toCircularPreorder | Mathlib.Order.Circular | {α : Type u_1} → [self : CircularPartialOrder α] → CircularPreorder α |
ModuleCon.mk.noConfusion | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_2} →
{M : Type u_3} →
{inst : Add M} →
{inst_1 : SMul S M} →
{P : Sort u} →
{toAddCon : AddCon M} →
{smul : ∀ (s : S) {x y : M}, toAddCon.toSetoid x y → toAddCon.toSetoid (s • x) (s • y)} →
{toAddCon' : AddCon M} →
{smul' : ∀ (s : S) {x y : M}, toAddCon'.toSetoid x y → toAddCon'.toSetoid (s • x) (s • y)} →
{ toAddCon := toAddCon, smul := smul } = { toAddCon := toAddCon', smul := smul' } →
(toAddCon ≍ toAddCon' → P) → P |
MonoidHom.compLeftContinuousBounded_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type v} {γ : Type w} (α : Type u_3) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : Monoid β] [inst_3 : BoundedMul β] [inst_4 : ContinuousMul β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : Monoid γ] [inst_7 : BoundedMul γ] [inst_8 : ContinuousMul γ] (g : β →* γ) {C : NNReal}
(hg : LipschitzWith C ⇑g) (f : BoundedContinuousFunction α β),
(MonoidHom.compLeftContinuousBounded α g hg) f = BoundedContinuousFunction.comp (⇑g) hg f |
LinearOrderedAddCommMonoidWithTop.toIsOrderedAddMonoid | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_3} [self : LinearOrderedAddCommMonoidWithTop α], IsOrderedAddMonoid α |
IsAntichain.sperner | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : Fintype α] {𝒜 : Finset (Finset α)},
IsAntichain (fun x1 x2 => x1 ⊆ x2) ↑𝒜 → 𝒜.card ≤ (Fintype.card α).choose (Fintype.card α / 2) |
Batteries.BinomialHeap.Imp.FindMin.WF.casesOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
{res : Batteries.BinomialHeap.Imp.FindMin α} →
{motive : Batteries.BinomialHeap.Imp.FindMin.WF le res → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin.WF le res) →
((rank : ℕ) →
(before :
∀ {s : Batteries.BinomialHeap.Imp.Heap α},
Batteries.BinomialHeap.Imp.Heap.WF le rank s →
Batteries.BinomialHeap.Imp.Heap.WF le 0 (res.before s)) →
(node : Batteries.BinomialHeap.Imp.HeapNode.WF le res.val res.node rank) →
(next : Batteries.BinomialHeap.Imp.Heap.WF le (rank + 1) res.next) →
motive { rank := rank, before := before, node := node, next := next }) →
motive t |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_2 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x z : V},
¬InnerProductGeometry.angle x z = Real.pi →
¬InnerProductGeometry.angle x z = 0 → ¬Real.sin (InnerProductGeometry.angle x z) = 0 |
Std.Iterators.Types.TakeWhile.PlausibleStep.recOn | Std.Data.Iterators.Combinators.Monadic.TakeWhile | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β]
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} {it : Std.IterM m β}
{motive : (step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.TakeWhile.PlausibleStep it step → Prop}
{step : Std.IterStep (Std.IterM m β) β} (t : Std.Iterators.Types.TakeWhile.PlausibleStep it step),
(∀ {it' : Std.IterM m β} {out : β} (a : it.internalState.inner.IsPlausibleStep (Std.IterStep.yield it' out))
(a_1 : (P out).Property { down := true }),
motive (Std.IterStep.yield (Std.IterM.takeWhileWithPostcondition P it') out) ⋯) →
(∀ {it' : Std.IterM m β} (a : it.internalState.inner.IsPlausibleStep (Std.IterStep.skip it')),
motive (Std.IterStep.skip (Std.IterM.takeWhileWithPostcondition P it')) ⋯) →
(∀ (a : it.internalState.inner.IsPlausibleStep Std.IterStep.done), motive Std.IterStep.done ⋯) →
(∀ {it' : Std.IterM m β} {out : β} (a : it.internalState.inner.IsPlausibleStep (Std.IterStep.yield it' out))
(a_1 : (P out).Property { down := false }), motive Std.IterStep.done ⋯) →
motive step t |
CategoryTheory.uliftFunctor | Mathlib.CategoryTheory.Types.Basic | CategoryTheory.Functor (Type u) (Type (max u v)) |
Rep.standardComplex.forget₂ToModuleCat | Mathlib.RepresentationTheory.Homological.Resolution | (k G : Type u) → [inst : CommRing k] → [Monoid G] → HomologicalComplex (ModuleCat k) (ComplexShape.down ℕ) |
_private.Mathlib.Analysis.BoxIntegral.Partition.Additive.0.Option.elim'.match_1.eq_2 | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () |
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD_eq_getD_entryAtIdx? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} {i : ℕ} {fallback : α × β},
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD t i fallback =
(Std.DTreeMap.Internal.Impl.Const.entryAtIdx? t i).getD fallback |
Int64.le_minValue_iff | Init.Data.SInt.Lemmas | ∀ {a : Int64}, a ≤ Int64.minValue ↔ a = Int64.minValue |
TensorProduct.instInner | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : InnerProductSpace 𝕜 F] → Inner 𝕜 (TensorProduct 𝕜 E F) |
MeasureTheory.integral_union_ae | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{f : X → E} {s t : Set X} {μ : MeasureTheory.Measure X},
MeasureTheory.AEDisjoint μ s t →
MeasureTheory.NullMeasurableSet t μ →
MeasureTheory.IntegrableOn f s μ →
MeasureTheory.IntegrableOn f t μ → ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ + ∫ (x : X) in t, f x ∂μ |
Nat.le.below.refl | Init.Prelude | ∀ {n : ℕ} {motive : (a : ℕ) → n.le a → Prop}, Nat.le.below ⋯ |
Batteries.PairingHeapImp.Heap.foldTreeM._unsafe_rec | Batteries.Data.PairingHeap | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.PairingHeapImp.Heap α → m β |
Mathlib.Linter.TextBased.UnicodeLinter.replaceDisallowed | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → Option String |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_properDivisors._simp_1_5 | Mathlib.NumberTheory.Divisors | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) |
invMonoidHom.eq_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α], invMonoidHom = { toFun := Inv.inv, map_one' := ⋯, map_mul' := ⋯ } |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_iff_not_exists_mul_eq._simp_1_6 | Mathlib.Data.Nat.Prime.Defs | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) |
LeanSearchClient.LoogleResult.recOn | LeanSearchClient.LoogleSyntax | {motive : LeanSearchClient.LoogleResult → Sort u} →
(t : LeanSearchClient.LoogleResult) →
motive LeanSearchClient.LoogleResult.empty →
((a : Array LeanSearchClient.SearchResult) → motive (LeanSearchClient.LoogleResult.success a)) →
((error : String) →
(suggestions : Option (List String)) → motive (LeanSearchClient.LoogleResult.failure error suggestions)) →
motive t |
Std.Tactic.BVDecide.BVPred.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVPred → Sort u} →
({w : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinPred) →
(rhs : Std.Tactic.BVDecide.BVExpr w) → motive (Std.Tactic.BVDecide.BVPred.bin lhs op rhs)) →
({w : ℕ} →
(expr : Std.Tactic.BVDecide.BVExpr w) → (idx : ℕ) → motive (Std.Tactic.BVDecide.BVPred.getLsbD expr idx)) →
(t : Std.Tactic.BVDecide.BVPred) → motive t |
Topology.IsUpperSet.topology_eq_upperSetTopology | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_4} {t : TopologicalSpace α} {inst : Preorder α} [self : Topology.IsUpperSet α], t = Topology.upperSet α |
_private.Init.Data.UInt.Lemmas.0.USize.pos_iff_ne_zero._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
Vector.back? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → Option α |
Units.val_le_val._simp_2 | Mathlib.Algebra.Order.Monoid.Units | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (↑a ≤ ↑b) = (a ≤ b) |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.merge._sparseCasesOn_1 | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} →
(t : Lean.Compiler.LCNF.UnreachableBranches.Value) →
motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot →
motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.top →
((vs : List Lean.Compiler.LCNF.UnreachableBranches.Value) →
motive_1 (Lean.Compiler.LCNF.UnreachableBranches.Value.choice vs)) →
(Nat.hasNotBit 11 t.ctorIdx → motive_1 t) → motive_1 t |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo.mk._flat_ctor | Lean.Compiler.LCNF.ExplicitRC | Bool → Bool → Bool → ℕ → Lean.Compiler.LCNF.VarInfo✝ |
Int.le_emod_self_add_one_iff | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 < b → (b ≤ a % b + 1 ↔ b ∣ a + 1) |
Topology.instIsLowerSet | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α], Topology.IsLowerSet α |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate.0.PartialOrder.mem_nerve_nonDegenerate_iff_strictMono._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate | ∀ {X : Type u_1} [inst : PartialOrder X] {n : ℕ}
(s : (CategoryTheory.nerve X).obj (Opposite.op (SimplexCategory.mk (n + 1)))) (i : Fin (n + 1)),
(s ∈ Set.range (CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve X) i)) = (s.obj i.castSucc = s.obj i.succ) |
Nat.iSup_le_succ | Mathlib.Data.Nat.Lattice | ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ),
⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1) |
ContinuousMap.compMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : MulOneClass γ] (g : C(α, β)), ContinuousMap.comp 1 g = 1 |
CategoryTheory.Pseudofunctor.ObjectProperty.ι | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
(P : F.ObjectProperty) → [inst_1 : P.IsClosedUnderMapObj] → P.fullsubcategory.StrongTrans F |
Order.exists_series_of_le_coheight | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α) {n : ℕ}, ↑n ≤ Order.coheight a → ∃ p, RelSeries.head p = a ∧ p.length = n |
Mathlib.Tactic.Bicategory.evalWhiskerRight_cons_of_of | Mathlib.Tactic.CategoryTheory.Bicategory.Normalize | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g h i : a ⟶ b} {j : b ⟶ c} {α : f ≅ g} {η : g ⟶ h}
{ηs : h ⟶ i} {ηs₁ : CategoryTheory.CategoryStruct.comp h j ⟶ CategoryTheory.CategoryStruct.comp i j}
{η₁ : CategoryTheory.CategoryStruct.comp g j ⟶ CategoryTheory.CategoryStruct.comp h j}
{η₂ : CategoryTheory.CategoryStruct.comp g j ⟶ CategoryTheory.CategoryStruct.comp i j}
{η₃ : CategoryTheory.CategoryStruct.comp f j ⟶ CategoryTheory.CategoryStruct.comp i j},
CategoryTheory.Bicategory.whiskerRight ηs j = ηs₁ →
CategoryTheory.Bicategory.whiskerRight η j = η₁ →
CategoryTheory.CategoryStruct.comp η₁ ηs₁ = η₂ →
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRightIso α j).hom η₂ = η₃ →
CategoryTheory.Bicategory.whiskerRight
(CategoryTheory.CategoryStruct.comp α.hom (CategoryTheory.CategoryStruct.comp η ηs)) j =
η₃ |
MeasureTheory.tendsto_of_uncrossing_lt_top | Mathlib.Probability.Martingale.Convergence | ∀ {Ω : Type u_1} {f : ℕ → Ω → ℝ} {ω : Ω},
Filter.liminf (fun n => ↑‖f n ω‖₊) Filter.atTop < ⊤ →
(∀ (a b : ℚ), a < b → MeasureTheory.upcrossings (↑a) (↑b) f ω < ⊤) →
∃ c, Filter.Tendsto (fun n => f n ω) Filter.atTop (nhds c) |
Mathlib.Tactic.RingNF.RingMode.recOn | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} →
(t : Mathlib.Tactic.RingNF.RingMode) →
motive Mathlib.Tactic.RingNF.RingMode.SOP → motive Mathlib.Tactic.RingNF.RingMode.raw → motive t |
Algebra.Generators.toExtendScalars._proof_2 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_4} {S : Type u_3} {ι : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T]
(P : Algebra.Generators R T ι) (i : ι),
(MvPolynomial.aeval (Algebra.Generators.extendScalars S P).val) (MvPolynomial.X i) = (algebraMap T T) (P.val i) |
Polynomial.natDegree_pow_X_add_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] [Nontrivial R] (n : ℕ) (r : R), ((Polynomial.X + Polynomial.C r) ^ n).natDegree = n |
Substring.Raw.ValidFor.isEmpty | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → (s.isEmpty = true ↔ m = []) |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.step_intermediateZip.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ Id β₁] {it₁ : Std.Iter β₁} (motive : it₁.Step → Sort u_2)
(it₁' : Std.Iter β₁) (hp : it₁.IsPlausibleStep (Std.IterStep.skip it₁'))
(h_1 :
(it₁' : Std.Iter β₁) →
(out : β₁) → (hp : it₁.IsPlausibleStep (Std.IterStep.yield it₁' out)) → motive ⟨Std.IterStep.yield it₁' out, hp⟩)
(h_2 :
(it₁' : Std.Iter β₁) → (hp : it₁.IsPlausibleStep (Std.IterStep.skip it₁')) → motive ⟨Std.IterStep.skip it₁', hp⟩)
(h_3 : (hp : it₁.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, hp⟩),
(match ⟨Std.IterStep.skip it₁', hp⟩ with
| ⟨Std.IterStep.yield it₁' out, hp⟩ => h_1 it₁' out hp
| ⟨Std.IterStep.skip it₁', hp⟩ => h_2 it₁' hp
| ⟨Std.IterStep.done, hp⟩ => h_3 hp) =
h_2 it₁' hp |
Batteries.instOrientedCmpCompareOnOfOrientedOrd | Batteries.Classes.Deprecated | ∀ {β : Type u_1} {α : Sort u_2} [inst : Ord β] [Batteries.OrientedOrd β] (f : α → β),
Batteries.OrientedCmp (compareOn f) |
PFun.prodMap_id_id | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2}, (PFun.id α).prodMap (PFun.id β) = PFun.id (α × β) |
ModularForm.mk.noConfusion | Mathlib.NumberTheory.ModularForms.Basic | {Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
{P : Sort u} →
{toSlashInvariantForm : SlashInvariantForm Γ k} →
{holo' : MDifferentiable (modelWithCornersSelf ℂ ℂ) (modelWithCornersSelf ℂ ℂ) ⇑toSlashInvariantForm} →
{bdd_at_cusps' : ∀ {c : OnePoint ℝ}, IsCusp c Γ → c.IsBoundedAt toSlashInvariantForm.toFun k} →
{toSlashInvariantForm' : SlashInvariantForm Γ k} →
{holo'' : MDifferentiable (modelWithCornersSelf ℂ ℂ) (modelWithCornersSelf ℂ ℂ) ⇑toSlashInvariantForm'} →
{bdd_at_cusps'' : ∀ {c : OnePoint ℝ}, IsCusp c Γ → c.IsBoundedAt toSlashInvariantForm'.toFun k} →
{ toSlashInvariantForm := toSlashInvariantForm, holo' := holo', bdd_at_cusps' := bdd_at_cusps' } =
{ toSlashInvariantForm := toSlashInvariantForm', holo' := holo'',
bdd_at_cusps' := bdd_at_cusps'' } →
(toSlashInvariantForm ≍ toSlashInvariantForm' → P) → P |
Fin.foldr_congr | Init.Data.Fin.Fold | ∀ {α : Sort u_1} {n k : ℕ} (w : n = k) (f : Fin n → α → α), Fin.foldr n f = Fin.foldr k fun i => f (Fin.cast ⋯ i) |
topologicalGroup_of_lieGroup | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (n : WithTop ℕ∞)
{G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [LieGroup I n G],
IsTopologicalGroup G |
_private.Mathlib.Data.Finset.Prod.0.Finset.subset_product_image_fst._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 |
Finset.prod_bij' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : CommMonoid M] {s : Finset ι} {t : Finset κ} {f : ι → M}
{g : κ → M} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
(hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s),
(∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) →
(∀ (a : κ) (ha : a ∈ t), i (j a ha) ⋯ = a) →
(∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) → ∏ x ∈ s, f x = ∏ x ∈ t, g x |
Lean.Lsp.DependencyBuildMode._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.DependencyBuildMode |
CategoryTheory.Limits.Trident.ι | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : J → (X ⟶ Y)} →
(t : CategoryTheory.Limits.Trident f) →
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj t.pt).obj
CategoryTheory.Limits.WalkingParallelFamily.zero ⟶
(CategoryTheory.Limits.parallelFamily f).obj CategoryTheory.Limits.WalkingParallelFamily.zero |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_toInt_lt_neg_two_pow_iff._proof_1_8 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
((w + 1) * 2 - 2 < (w + 1) * 2 - 1 → 2 ^ ((w + 1) * 2 - 2) < 2 ^ ((w + 1) * 2 - 1)) →
x.toInt * y.toInt ≤ 2 ^ ((w + 1) * 2 - 2) → ¬x.toInt * y.toInt * 2 < 2 ^ ((w + 1) * 2 - 1) * 2 → False |
AlgebraicGeometry.Scheme.OpenCover.finiteSubcover_X | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [H : CompactSpace ↥X] (x : ↥⋯.choose),
𝒰.finiteSubcover.X x = 𝒰.X (AlgebraicGeometry.Scheme.Cover.idx 𝒰 ↑x) |
Lean.RBNode.leaf | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → Lean.RBNode α β |
Multiset.countP_congr | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {s s' : Multiset α},
s = s' →
∀ {p p' : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred p'],
(∀ x ∈ s, p x = p' x) → Multiset.countP p s = Multiset.countP p' s' |
instToStringFloat32 | Init.Data.Float32 | ToString Float32 |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput.lhs | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput aig len → aig.RefVec len |
Lean.Server.RequestHandler._sizeOf_inst | Lean.Server.Requests | SizeOf Lean.Server.RequestHandler |
BddOrd.instConcreteCategoryBoundedOrderHomCarrier._proof_2 | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} (f : X ⟶ Y), { hom' := f.hom' } = f |
Set.coe_snd_biUnionEqSigmaOfDisjoint | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_5} {ι : Type u_6} {s : Set ι} {f : ι → Set α} (h : s.PairwiseDisjoint f) (x : ↑(⋃ i ∈ s, f i)),
↑((Set.biUnionEqSigmaOfDisjoint h) x).snd = ↑x |
Quaternion.instNormedAddCommGroupReal._proof_3 | Mathlib.Analysis.Quaternion | ∀ (x y : Quaternion ℝ) (r : ℝ), inner ℝ (r • x) y = (starRingEnd ℝ) r * inner ℝ x y |
Aesop.TraceOption.mk.noConfusion | Aesop.Tracing | {P : Sort u} →
{traceClass : Lean.Name} →
{option : Lean.Option Bool} →
{traceClass' : Lean.Name} →
{option' : Lean.Option Bool} →
{ traceClass := traceClass, option := option } = { traceClass := traceClass', option := option' } →
(traceClass = traceClass' → option = option' → P) → P |
CategoryTheory.Functor.Elements.initialOfCorepresentableBy | Mathlib.CategoryTheory.Elements | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C (Type u_1)} → {X : C} → F.CorepresentableBy X → F.Elements |
torusMap_zero_radius | Mathlib.MeasureTheory.Integral.TorusIntegral | ∀ {n : ℕ} (c : Fin n → ℂ), torusMap c 0 = Function.const (Fin n → ℝ) c |
Ordinal.inductionOnWellOrder | Mathlib.SetTheory.Ordinal.Basic | ∀ {C : Ordinal.{u_1} → Prop} (o : Ordinal.{u_1}),
(∀ (α : Type u_1) [inst : LinearOrder α] [inst_1 : WellFoundedLT α], C (Ordinal.type fun x1 x2 => x1 < x2)) → C o |
MeasureTheory.MemLp.exists_boundedContinuous_integral_rpow_sub_le | Mathlib.MeasureTheory.Function.ContinuousMapDense | ∀ {α : Type u_1} [inst : TopologicalSpace α] [NormalSpace α] [inst_2 : MeasurableSpace α] [BorelSpace α] {E : Type u_2}
[inst_4 : NormedAddCommGroup E] {μ : MeasureTheory.Measure α} [NormedSpace ℝ E] [μ.WeaklyRegular] {p : ℝ},
0 < p →
∀ {f : α → E},
MeasureTheory.MemLp f (ENNReal.ofReal p) μ →
∀ {ε : ℝ}, 0 < ε → ∃ g, ∫ (x : α), ‖f x - g x‖ ^ p ∂μ ≤ ε ∧ MeasureTheory.MemLp (⇑g) (ENNReal.ofReal p) μ |
ContinuousOpenMap._sizeOf_inst | Mathlib.Topology.Hom.Open | (α : Type u_6) →
(β : Type u_7) →
{inst : TopologicalSpace α} → {inst_1 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →CO β) |
indicator_ae_eq_zero_of_restrict_ae_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
[inst_1 : Zero β], MeasurableSet s → f =ᵐ[μ.restrict s] 0 → s.indicator f =ᵐ[μ] 0 |
AlgebraicGeometry.pointEquivClosedPoint._proof_4 | Mathlib.AlgebraicGeometry.AlgClosed.Basic | ∀ {X : AlgebraicGeometry.Scheme} {K : Type u_1} [inst : Field K] [inst_1 : IsAlgClosed K]
(f : X ⟶ AlgebraicGeometry.Spec { carrier := K, commRing := Field.toEuclideanDomain.toCommRing })
[inst_2 : AlgebraicGeometry.LocallyOfFiniteType f] (x : ↑(closedPoints ↥X)),
(fun p => ⟨↑p (IsLocalRing.closedPoint K), ⋯⟩) ((fun x => ⟨AlgebraicGeometry.pointOfClosedPoint f ↑x ⋯, ⋯⟩) x) = x |
CategoryTheory.CommMon.X | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → C |
CategoryTheory.Limits.WalkingMulticospan.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u} →
(ctorIdx : ℕ) →
(t : CategoryTheory.Limits.WalkingMulticospan J) →
ctorIdx = t.ctorIdx → CategoryTheory.Limits.WalkingMulticospan.ctorElimType ctorIdx → motive t |
Lean.Doc.Block.brecOn_7 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1} →
{motive_5 : List (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_6 : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_7 : List (Lean.Doc.Block i b) → Sort u_1} →
{motive_8 : Lean.Doc.ListItem (Lean.Doc.Block i b) → Sort u_1} →
{motive_9 : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b) → Sort u_1} →
(t : Lean.Doc.ListItem (Lean.Doc.Block i b)) →
((t : Lean.Doc.Block i b) → t.below → motive_1 t) →
((t : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_1 t → motive_2 t) →
((t : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_2 t → motive_3 t) →
((t : Array (Lean.Doc.Block i b)) → Lean.Doc.Block.below_3 t → motive_4 t) →
((t : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_4 t → motive_5 t) →
((t : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) →
Lean.Doc.Block.below_5 t → motive_6 t) →
((t : List (Lean.Doc.Block i b)) → Lean.Doc.Block.below_6 t → motive_7 t) →
((t : Lean.Doc.ListItem (Lean.Doc.Block i b)) →
Lean.Doc.Block.below_7 t → motive_8 t) →
((t : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) →
Lean.Doc.Block.below_8 t → motive_9 t) →
motive_8 t |
AddMonoidAlgebra.single_mem_grade | Mathlib.Algebra.MonoidAlgebra.Grading | ∀ {M : Type u_1} {R : Type u_4} [inst : CommSemiring R] (i : M) (r : R), (fun₀ | i => r) ∈ AddMonoidAlgebra.grade R i |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._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) |
Equiv.invFun | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} → {β : Sort u_2} → α ≃ β → β → α |
Mathlib.TacticAnalysis.Pass._sizeOf_inst | Mathlib.Tactic.TacticAnalysis | SizeOf Mathlib.TacticAnalysis.Pass |
Matrix.vecMul_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {n' : Type uₙ} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n'] (v : n' → α)
(B : Matrix n' (Fin 0) α), Matrix.vecMul v B = ![] |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_24 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} (hl : l ≠ []), l.getLast ⋯ ∈ l |
NumberField.basisOfFractionalIdeal._proof_2 | Mathlib.NumberTheory.NumberField.FractionalIdeal | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
LinearMap.CompatibleSMul (↥↑↑I) K ℤ (NumberField.RingOfIntegers K) |
AddUnits.leftOfAdd.eq_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = ↑u) (hc : AddCommute a b),
u.leftOfAdd a b hu hc = { val := a, neg := b + ↑(-u), val_neg := ⋯, neg_val := ⋯ } |
Subring.instField._proof_13 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (x : ℚ≥0) (x_1 : ↥(Subring.center K)), ↑x * x_1 = ↑x * x_1 |
List.prod_inv_reverse | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Group G] (L : List G), L.prod⁻¹ = (List.map (fun x => x⁻¹) L).reverse.prod |
Equiv.prodAssoc.match_3 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_1) (β : Type u_3) (γ : Type u_2) (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (fst : α) (fst_1 : β) (snd : γ), motive (fst, fst_1, snd)) → motive x |
Ordinal.CNF.rec_pos | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_2}) {o : Ordinal.{u_2}} {C : Ordinal.{u_2} → Sort u_1} (ho : o ≠ 0) (H0 : C 0)
(H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o),
Ordinal.CNF.rec b H0 H o = H o ho (Ordinal.CNF.rec b H0 H (o % b ^ Ordinal.log b o)) |
Bundle.TotalSpace.toProd._proof_1 | Mathlib.Data.Bundle | ∀ (B : Type u_1) (F : Type u_2), Function.LeftInverse (fun x => { proj := x.1, snd := x.2 }) fun x => (x.proj, x.snd) |
Affine.Simplex.isCompact_closedInterior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_4} {V : Type u_5} {P : Type u_6} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderClosedTopology 𝕜] [CompactIccSpace 𝕜] [ContinuousAdd 𝕜] [inst_7 : AddCommGroup V]
[inst_8 : TopologicalSpace V] [IsTopologicalAddGroup V] [inst_10 : Module 𝕜 V] [ContinuousSMul 𝕜 V]
[inst_12 : AddTorsor V P] [inst_13 : TopologicalSpace P] [IsTopologicalAddTorsor P] {n : ℕ}
(s : Affine.Simplex 𝕜 P n), IsCompact s.closedInterior |
_private.Mathlib.Algebra.BigOperators.ModEq.0.Int.prod_modEq_single._simp_1_1 | Mathlib.Algebra.BigOperators.ModEq | ∀ (a b : ℤ) (c : ℕ), (a ≡ b [ZMOD ↑c]) = (↑a = ↑b) |
CategoryTheory.Comma.unopFunctor_map | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) {X Y : CategoryTheory.Comma L.op R.op} (f : X ⟶ Y),
(CategoryTheory.Comma.unopFunctor L R).map f = Opposite.op { left := f.right.unop, right := f.left.unop, w := ⋯ } |
AddCommMonCat.recOn | Mathlib.Algebra.Category.MonCat.Basic | {motive : AddCommMonCat → Sort u_1} →
(t : AddCommMonCat) →
((carrier : Type u) → [str : AddCommMonoid carrier] → motive { carrier := carrier, str := str }) → motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.