File: Mathlib/Order/Filter/FilterProduct.lean

full_name: Filter.«_aux_Mathlib_Order_Filter_FilterProduct___macroRules_Filter_term∀*_,__1»
code: local notation3 "∀* "(...)", "r:(scoped p => Filter.Eventually p (Ultrafilter.toFilter φ)) => r
goal: Lean.Macro

full_name: Filter.Germ._aux_Mathlib_Order_Filter_FilterProduct___unexpand_Filter_Germ_1
code: local notation "β*" => Germ (φ : Filter α) β
goal: Lean.PrettyPrinter.Unexpander

full_name: Filter.Germ.«_aux_Mathlib_Order_Filter_FilterProduct___macroRules_Filter_Germ_termβ*_1»
code: local notation "β*" => Germ (φ : Filter α) β
goal: Lean.Macro

full_name: Filter.Germ.instGroupWithZero
code: instance instGroupWithZero [GroupWithZero β] : GroupWithZero β* 
goal: GroupWithZero ((↑φ).Germ β)

full_name: Filter.Germ.instDivisionSemiring
code: instance instDivisionSemiring [DivisionSemiring β] : DivisionSemiring β* 
goal: DivisionSemiring ((↑φ).Germ β)

full_name: Filter.Germ.instDivisionRing
code: instance instDivisionRing [DivisionRing β] : DivisionRing β* 
goal: DivisionRing ((↑φ).Germ β)

full_name: Filter.Germ.instSemifield
code: instance instSemifield [Semifield β] : Semifield β* 
goal: Semifield ((↑φ).Germ β)

full_name: Filter.Germ.instField
code: instance instField [Field β] : Field β* 
goal: Field ((↑φ).Germ β)

full_name: Filter.Germ.coe_lt
code: theorem coe_lt [Preorder β] {f g : α → β} : (f : β*) < g ↔ ∀* x, f x < g x 
goal: ↑f < ↑g ↔ ∀ᶠ (x : α) in ↑φ, f x < g x

full_name: Filter.Germ.coe_pos
code: theorem coe_pos [Preorder β] [Zero β] {f : α → β} : 0 < (f : β*) ↔ ∀* x, 0 < f x 
goal: 0 < ↑f ↔ ∀ᶠ (x : α) in ↑φ, 0 < f x

full_name: Filter.Germ.const_lt
code: theorem const_lt [Preorder β] {x y : β} : x < y → (↑x : β*) < ↑y 
goal: x < y → ↑x < ↑y

full_name: Filter.Germ.const_lt_iff
code: @[simp, norm_cast]
theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y 
goal: ↑x < ↑y ↔ x < y

full_name: Filter.Germ.lt_def
code: theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·) 
goal: (fun x x_1 => x < x_1) = Filter.Germ.LiftRel fun x x_1 => x < x_1

full_name: Filter.Germ.isTotal
code: instance isTotal [LE β] [IsTotal β (· ≤ ·)] : IsTotal β* (· ≤ ·) 
goal: IsTotal ((↑φ).Germ β) fun x x_1 => x ≤ x_1

full_name: Filter.Germ.instLinearOrder
code: /-- If `φ` is an ultrafilter then the ultraproduct is a linear order. -/
noncomputable instance instLinearOrder [LinearOrder β] : LinearOrder β* 
goal: LinearOrder ((↑φ).Germ β)

full_name: Filter.Germ.linearOrderedAddCommGroup
code: @[to_additive]
noncomputable instance linearOrderedCommGroup [LinearOrderedCommGroup β] :
    LinearOrderedCommGroup β* 
goal: LinearOrderedAddCommGroup ((↑φ).Germ β)

full_name: Filter.Germ.linearOrderedCommGroup
code: @[to_additive]
noncomputable instance linearOrderedCommGroup [LinearOrderedCommGroup β] :
    LinearOrderedCommGroup β* 
goal: LinearOrderedCommGroup ((↑φ).Germ β)

full_name: Filter.Germ.instStrictOrderedSemiring
code: instance instStrictOrderedSemiring [StrictOrderedSemiring β] : StrictOrderedSemiring β* 
goal: StrictOrderedSemiring ((↑φ).Germ β)

full_name: Filter.Germ.instStrictOrderedCommSemiring
code: instance instStrictOrderedCommSemiring [StrictOrderedCommSemiring β] :
    StrictOrderedCommSemiring β* 
goal: StrictOrderedCommSemiring ((↑φ).Germ β)

full_name: Filter.Germ.instStrictOrderedRing
code: instance instStrictOrderedRing [StrictOrderedRing β] : StrictOrderedRing β* 
goal: StrictOrderedRing ((↑φ).Germ β)

full_name: Filter.Germ.instStrictOrderedCommRing
code: instance instStrictOrderedCommRing [StrictOrderedCommRing β] : StrictOrderedCommRing β* 
goal: StrictOrderedCommRing ((↑φ).Germ β)

full_name: Filter.Germ.instLinearOrderedRing
code: noncomputable instance instLinearOrderedRing [LinearOrderedRing β] : LinearOrderedRing β* 
goal: LinearOrderedRing ((↑φ).Germ β)

full_name: Filter.Germ.instLinearOrderedField
code: noncomputable instance instLinearOrderedField [LinearOrderedField β] : LinearOrderedField β* 
goal: LinearOrderedField ((↑φ).Germ β)

full_name: Filter.Germ.instLinearOrderedCommRing
code: noncomputable instance instLinearOrderedCommRing [LinearOrderedCommRing β] :
    LinearOrderedCommRing β* 
goal: LinearOrderedCommRing ((↑φ).Germ β)

full_name: Filter.Germ.max_def
code: theorem max_def [LinearOrder β] (x y : β*) : max x y = map₂ max x y 
goal: max x y = Filter.Germ.map₂ max x y

full_name: Filter.Germ.min_def
code: theorem min_def [K : LinearOrder β] (x y : β*) : min x y = map₂ min x y 
goal: min x y = Filter.Germ.map₂ min x y

full_name: Filter.Germ.abs_def
code: theorem abs_def [LinearOrderedAddCommGroup β] (x : β*) : |x| = map abs x 
goal: |x| = Filter.Germ.map abs x

full_name: Filter.Germ.const_max
code: @[simp]
theorem const_max [LinearOrder β] (x y : β) : (↑(max x y : β) : β*) = max ↑x ↑y 
goal: ↑(max x y) = max ↑x ↑y

full_name: Filter.Germ.const_min
code: @[simp]
theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min ↑x ↑y 
goal: ↑(min x y) = min ↑x ↑y

full_name: Filter.Germ.const_abs
code: @[simp]
theorem const_abs [LinearOrderedAddCommGroup β] (x : β) : (↑|x| : β*) = |↑x| 
goal: ↑|x| = |↑x|