tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.MeasurePreserving.exists_mem_image_mem
File: Mathlib/Dynamics/Ergodic/MeasurePreserving.lean

tactic: rcases ENNReal.exists_nat_mul_gt hs' (measure_ne_top μ (Set.univ : Set α)) with ⟨N, hN⟩
state_before: α : Type u_1
β : Type ?u.275571
γ : Type ?u.275574
δ : Type ?u.275577
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
μ : Measure α
f : α → α
s : Set α
inst✝ : IsFiniteMeasure μ
hf : MeasurePreserving f
hs : MeasurableSet s
hs' : ↑↑μ s ≠ 0
⊢ ∃ x, x ∈ s ∧ ∃ m x_1, (f^[m]) x ∈ s

tactic: rcases hf.exists_mem_image_mem_of_volume_lt_mul_volume hs hN with ⟨x, hx, m, hm, hmx⟩
state_before: case intro
α : Type u_1
β : Type ?u.275571
γ : Type ?u.275574
δ : Type ?u.275577
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
μ : Measure α
f : α → α
s : Set α
inst✝ : IsFiniteMeasure μ
hf : MeasurePreserving f
hs : MeasurableSet s
hs' : ↑↑μ s ≠ 0
N : ℕ
hN : ↑↑μ Set.univ < ↑N * ↑↑μ s
⊢ ∃ x, x ∈ s ∧ ∃ m x_1, (f^[m]) x ∈ s

tactic: exact ⟨x, hx, m, hm.1.ne', hmx⟩
state_before: case intro.intro.intro.intro.intro
α : Type u_1
β : Type ?u.275571
γ : Type ?u.275574
δ : Type ?u.275577
inst✝⁴ : MeasurableSpace α
inst✝³ : MeasurableSpace β
inst✝² : MeasurableSpace γ
inst✝¹ : MeasurableSpace δ
μa : Measure α
μb : Measure β
μc : Measure γ
μd : Measure δ
μ : Measure α
f : α → α
s : Set α
inst✝ : IsFiniteMeasure μ
hf : MeasurePreserving f
hs : MeasurableSet s
hs' : ↑↑μ s ≠ 0
N : ℕ
hN : ↑↑μ Set.univ < ↑N * ↑↑μ s
x : α
hx : x ∈ s
m : ℕ
hm : m ∈ Set.Ioo 0 N
hmx : (f^[m]) x ∈ s
⊢ ∃ x, x ∈ s ∧ ∃ m x_1, (f^[m]) x ∈ s
Theorem: LieSubalgebra.ideal_in_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

tactic: rw [← lie_skew, neg_mem_iff (G := L)]
state_before: R : Type u_2
L : Type u_1
M : Type ?u.56361
M' : Type ?u.56364
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x y : L
hx : x ∈ normalizer H
hy : y ∈ H
⊢ ⁅x, y⁆ ∈ H

tactic: exact hx ⟨y, hy⟩
state_before: R : Type u_2
L : Type u_1
M : Type ?u.56361
M' : Type ?u.56364
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
H : LieSubalgebra R L
x y : L
hx : x ∈ normalizer H
hy : y ∈ H
⊢ ⁅y, x⁆ ∈ H
Theorem: ZMod.nat_cast_zmod_eq_zero_iff_dvd
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [← Nat.cast_zero, ZMod.nat_cast_eq_nat_cast_iff, Nat.modEq_zero_iff_dvd]
state_before: a b : ℕ
⊢ ↑a = 0 ↔ b ∣ a
Theorem: Nat.div_mul_le_self
File: Std/Data/Nat/Lemmas.lean

tactic: simp
state_before: m : Nat
⊢ m / 0 * 0 ≤ m
Theorem: IsCompact.div_closedBall_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, hs.mul_closedBall_one hδ]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
hs : IsCompact s
hδ : 0 ≤ δ
⊢ s / closedBall 1 δ = cthickening δ s
Theorem: MeasureTheory.setToFun_congr_measure_of_add_left
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: refine' setToFun_congr_measure_of_integrable 1 one_ne_top _ hT_add hT f hf
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1664515
G : Type ?u.1664518
𝕜 : Type ?u.1664521
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ' T C
f : α → E
hf : Integrable f
⊢ setToFun (μ + μ') T hT_add f = setToFun μ' T hT f

tactic: rw [one_smul]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1664515
G : Type ?u.1664518
𝕜 : Type ?u.1664521
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ' T C
f : α → E
hf : Integrable f
⊢ μ' ≤ 1 • (μ + μ')

tactic: nth_rw 1 [← zero_add μ']
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1664515
G : Type ?u.1664518
𝕜 : Type ?u.1664521
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ' T C
f : α → E
hf : Integrable f
⊢ μ' ≤ μ + μ'

tactic: exact add_le_add bot_le le_rfl
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.1664515
G : Type ?u.1664518
𝕜 : Type ?u.1664521
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
μ' : Measure α
hT_add : DominatedFinMeasAdditive (μ + μ') T C'
hT : DominatedFinMeasAdditive μ' T C
f : α → E
hf : Integrable f
⊢ 0 + μ' ≤ μ + μ'
Theorem: SemidirectProduct.map_comp_inl
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: ext <;> simp
state_before: N : Type u_1
G : Type u_4
H : Type ?u.251009
inst✝⁴ : Group N
inst✝³ : Group G
inst✝² : Group H
φ : G →* MulAut N
N₁ : Type u_2
G₁ : Type u_3
inst✝¹ : Group N₁
inst✝ : Group G₁
φ₁ : G₁ →* MulAut N₁
f₁ : N →* N₁
f₂ : G →* G₁
h : ∀ (g : G), MonoidHom.comp f₁ (MulEquiv.toMonoidHom (↑φ g)) = MonoidHom.comp (MulEquiv.toMonoidHom (↑φ₁ (↑f₂ g))) f₁
⊢ MonoidHom.comp (map f₁ f₂ h) inl = MonoidHom.comp inl f₁
Theorem: Matrix.empty_vecAlt1
File: Mathlib/Data/Fin/VecNotation.lean

tactic: simp
state_before: α✝ : Type u
m n o : ℕ
m' : Type ?u.54086
n' : Type ?u.54089
o' : Type ?u.54092
α : Type u_1
h : 0 = 0 + 0
⊢ vecAlt1 h ![] = ![]
Theorem: Nat.rfind_min'
File: Mathlib/Computability/Partrec.lean

tactic: injection mem_unique this (rfind_min hn h)
state_before: p : ℕ → Bool
m : ℕ
pm : p m = true
this : true ∈ ↑p m
n : ℕ
hn : n ∈ rfind ↑p
h : m < n
⊢ False
Theorem: Rack.assoc_iff_id
File: Mathlib/Algebra/Quandle.lean

tactic: rw [self_distrib]
state_before: R✝ : Type ?u.30897
inst✝¹ : Rack R✝
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z

tactic: rw [left_cancel]
state_before: R✝ : Type ?u.30897
inst✝¹ : Rack R✝
R : Type u_1
inst✝ : Rack R
x y z : R
⊢ (x ◃ y) ◃ x ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z
Theorem: toIcoDiv_zero_one
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp [toIcoDiv_eq_floor]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
p : α
hp : 0 < p
b : α
⊢ toIcoDiv (_ : 0 < 1) 0 b = ⌊b⌋
Theorem: BoxIntegral.HasIntegral.mcShane_of_forall_isLittleO
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: simpa only [McShane, Bool.coe_sort_false, false_imp_iff, true_imp_iff, diff_empty] using H
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
H :
  ℝ≥0 →
    ∀ (x : ι → ℝ),
      x ∈ ↑Box.Icc I →
        ∀ (ε : ℝ),
          ε > 0 →
            ∃ δ, δ > 0 ∧ ∀ (J : Box ι), J ≤ I → ↑Box.Icc J ⊆ closedBall x δ → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
⊢ ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ ∅ →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    (McShane.bHenstock = true → x ∈ ↑Box.Icc J) →
                      (McShane.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
Theorem: OrderHom.fst_prod_snd
File: Mathlib/Order/Hom/Basic.lean

tactic: ext ⟨x, y⟩ : 2
state_before: F : Type ?u.52049
α : Type u_1
β : Type u_2
γ : Type ?u.52058
δ : Type ?u.52061
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
⊢ OrderHom.prod fst snd = id

tactic: rfl
state_before: case h.h.mk
F : Type ?u.52049
α : Type u_1
β : Type u_2
γ : Type ?u.52058
δ : Type ?u.52061
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : Preorder γ
inst✝ : Preorder δ
x : α
y : β
⊢ ↑(OrderHom.prod fst snd) (x, y) = ↑id (x, y)
Theorem: Lagrange.degree_interpolate_erase_lt
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← Finset.card_erase_of_mem hi]
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ degree (↑(interpolate (Finset.erase s i) v) r) < ↑(card s - 1)

tactic: exact degree_interpolate_lt _ (Set.InjOn.mono (coe_subset.mpr (erase_subset _ _)) hvs)
state_before: F : Type u_2
inst✝¹ : Field F
ι : Type u_1
inst✝ : DecidableEq ι
s t : Finset ι
i j : ι
v r r' : ι → F
hvs : Set.InjOn v ↑s
hi : i ∈ s
⊢ degree (↑(interpolate (Finset.erase s i) v) r) < ↑(card (Finset.erase s i))
Theorem: List.forall₂_zip
File: Mathlib/Data/List/Forall2.lean

tactic: rw [zip, zipWith, mem_cons] at hx
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.33435
δ : Type ?u.33438
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) ∈ zip (a✝ :: l₁✝) (b✝ :: l₂✝)
⊢ R x y

tactic: match hx with
| Or.inl rfl => exact h₁
| Or.inr h₃ => exact forall₂_zip h₂ h₃
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.33435
δ : Type ?u.33438
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₁ : R a✝ b✝
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
⊢ R x y

tactic: exact h₁
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.33435
δ : Type ?u.33438
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
h₁ : R x y
⊢ R x y

tactic: exact forall₂_zip h₂ h₃
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.33435
δ : Type ?u.33438
R S : α → β → Prop
P : γ → δ → Prop
Rₐ : α → α → Prop
a✝ : α
b✝ : β
l₁✝ : List α
l₂✝ : List β
h₂ : Forall₂ R l₁✝ l₂✝
x : α
y : β
hx : (x, y) = (a✝, b✝) ∨ (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
x✝¹ : β
x✝ : α
h₃ : (x, y) ∈ zipWith Prod.mk l₁✝ l₂✝
h₁ : R x✝ x✝¹
⊢ R x y
Theorem: Equiv.id_map
File: Mathlib/Control/Traversable/Equiv.lean

tactic: simp [Equiv.map, id_map]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝¹ : Functor t
inst✝ : LawfulFunctor t
α : Type u
x : t' α
⊢ Equiv.map eqv id x = x
Theorem: IsFreeGroupoid.SpanningTree.treeHom_eq
File: Mathlib/GroupTheory/NielsenSchreier.lean

tactic: rw [treeHom, Unique.default_eq]
state_before: G : Type u
inst✝² : Groupoid G
inst✝¹ : IsFreeGroupoid G
T : WideSubquiver (Symmetrify (Generators G))
inst✝ : Arborescence (WideSubquiver.toType (Symmetrify (Generators G)) T)
a : G
p : Path (root (WideSubquiver.toType (Symmetrify (Generators G)) T)) a
⊢ treeHom T a = homOfPath T p
Theorem: Submodule.Quotient.equiv_trans
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: ext
state_before: R : Type u_3
M : Type u_4
r : R
x y : M
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
p p' : Submodule R M
R₂ : Type ?u.395898
M₂ : Type ?u.395901
inst✝⁶ : Ring R₂
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
N : Type u_1
O : Type u_2
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup O
inst✝ : Module R O
P : Submodule R M
Q : Submodule R N
S : Submodule R O
e : M ≃ₗ[R] N
f : N ≃ₗ[R] O
he : map e P = Q
hf : map f Q = S
hef : map (LinearEquiv.trans e f) P = S
⊢ equiv P S (LinearEquiv.trans e f) hef = LinearEquiv.trans (equiv P Q e he) (equiv Q S f hf)

tactic: simp only [Quotient.equiv_apply, LinearEquiv.trans_apply, LinearEquiv.coe_trans]
state_before: case h
R : Type u_3
M : Type u_4
r : R
x y : M
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
p p' : Submodule R M
R₂ : Type ?u.395898
M₂ : Type ?u.395901
inst✝⁶ : Ring R₂
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
N : Type u_1
O : Type u_2
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup O
inst✝ : Module R O
P : Submodule R M
Q : Submodule R N
S : Submodule R O
e : M ≃ₗ[R] N
f : N ≃ₗ[R] O
he : map e P = Q
hf : map f Q = S
hef : map (LinearEquiv.trans e f) P = S
x✝ : M ⧸ P
⊢ ↑(equiv P S (LinearEquiv.trans e f) hef) x✝ = ↑(LinearEquiv.trans (equiv P Q e he) (equiv Q S f hf)) x✝

tactic: rw [mapQ_comp, LinearMap.comp_apply]
state_before: case h
R : Type u_3
M : Type u_4
r : R
x y : M
inst✝⁹ : Ring R
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
p p' : Submodule R M
R₂ : Type ?u.395898
M₂ : Type ?u.395901
inst✝⁶ : Ring R₂
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R₂ M₂
τ₁₂ : R →+* R₂
q : Submodule R₂ M₂
N : Type u_1
O : Type u_2
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : AddCommGroup O
inst✝ : Module R O
P : Submodule R M
Q : Submodule R N
S : Submodule R O
e : M ≃ₗ[R] N
f : N ≃ₗ[R] O
he : map e P = Q
hf : map f Q = S
hef : map (LinearEquiv.trans e f) P = S
x✝ : M ⧸ P
⊢ ↑(mapQ P S (comp ↑f ↑e) (_ : P ≤ comap (comp ↑f ↑e) S)) x✝ =
    ↑(mapQ Q S ↑f (_ : ∀ (x : N), x ∈ Q → x ∈ comap (↑f) S))
      (↑(mapQ P Q ↑e (_ : ∀ (x : M), x ∈ P → x ∈ comap (↑e) Q)) x✝)
Theorem: MvPolynomial.totalDegree_sub
File: Mathlib/Data/MvPolynomial/CommRing.lean

tactic: rw [sub_eq_add_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p q a b : MvPolynomial σ R
⊢ totalDegree (a - b) = totalDegree (a + -b)

tactic: rw [totalDegree_neg]
state_before: R : Type u
S : Type v
σ : Type u_1
a✝ a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommRing R
p q a b : MvPolynomial σ R
⊢ max (totalDegree a) (totalDegree (-b)) = max (totalDegree a) (totalDegree b)
Theorem: conjugate_nonneg
File: Mathlib/Algebra/Star/Order.lean

tactic: rw [StarOrderedRing.nonneg_iff] at ha
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha : 0 ≤ a
c : R
⊢ 0 ≤ star c * a * c

tactic: refine' AddSubmonoid.closure_induction ha (fun x hx => _)
  (by rw [MulZeroClass.mul_zero, MulZeroClass.zero_mul]) fun x y hx hy => _
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c : R
⊢ 0 ≤ star c * a * c

tactic: rw [MulZeroClass.mul_zero, MulZeroClass.zero_mul]
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c : R
⊢ 0 ≤ star c * 0 * c

tactic: obtain ⟨x, rfl⟩ := hx
state_before: case refine'_1
R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x : R
hx : x ∈ Set.range fun s => star s * s
⊢ 0 ≤ star c * x * c

tactic: convert star_mul_self_nonneg (x * c) using 1
state_before: case refine'_1.intro
R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x : R
⊢ 0 ≤ star c * (fun s => star s * s) x * c

tactic: rw [star_mul, ← mul_assoc, mul_assoc _ _ c]
state_before: case h.e'_4
R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x : R
⊢ star c * (fun s => star s * s) x * c = star (x * c) * (x * c)

tactic: calc
  0 ≤ star c * x * c + 0 := by rw [add_zero]; exact hx
  _ ≤ star c * x * c + star c * y * c := add_le_add_left hy _
  _ ≤ _ := by rw [mul_add, add_mul]
state_before: case refine'_2
R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x y : R
hx : 0 ≤ star c * x * c
hy : 0 ≤ star c * y * c
⊢ 0 ≤ star c * (x + y) * c

tactic: rw [add_zero]
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x y : R
hx : 0 ≤ star c * x * c
hy : 0 ≤ star c * y * c
⊢ 0 ≤ star c * x * c + 0

tactic: exact hx
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x y : R
hx : 0 ≤ star c * x * c
hy : 0 ≤ star c * y * c
⊢ 0 ≤ star c * x * c

tactic: rw [mul_add, add_mul]
state_before: R : Type u
inst✝² : NonUnitalSemiring R
inst✝¹ : PartialOrder R
inst✝ : StarOrderedRing R
a : R
ha✝ : 0 ≤ a
ha : a ∈ AddSubmonoid.closure (Set.range fun s => star s * s)
c x y : R
hx : 0 ≤ star c * x * c
hy : 0 ≤ star c * y * c
⊢ star c * x * c + star c * y * c ≤ star c * (x + y) * c
Theorem: mul_div_mul_right_eq_div
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [div_mul_eq_div_div_swap]
state_before: α : Type ?u.58098
β : Type ?u.58101
G : Type u_1
inst✝ : Group G
a✝ b✝ c✝ d a b c : G
⊢ a * c / (b * c) = a / b

tactic: simp only [mul_left_inj, eq_self_iff_true, mul_div_cancel'']
state_before: α : Type ?u.58098
β : Type ?u.58101
G : Type u_1
inst✝ : Group G
a✝ b✝ c✝ d a b c : G
⊢ a * c / c / b = a / b
Theorem: PrimeSpectrum.zeroLocus_singleton_pow
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simpa using x.2.pow_mem_iff_mem n hn
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
f : R
n : ℕ
hn : 0 < n
x : PrimeSpectrum R
⊢ x ∈ zeroLocus {f ^ n} ↔ x ∈ zeroLocus {f}
Theorem: nhdsWithin_Iic_eq'
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [nhdsWithin_Iic_eq'', biInf_inf ha, inf_principal, Ioi_inter_Iic]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : OrderTopology α
a : α
ha : ∃ l, l < a
⊢ 𝓝[Iic a] a = ⨅ (l : α) (_ : l < a), 𝓟 (Ioc l a)
Theorem: Function.Antiperiodic.const_add
File: Mathlib/Algebra/Periodic.lean

tactic: simpa [add_assoc] using h (a + x)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.165187
f g : α → β
c c₁ c₂ x✝ : α
inst✝¹ : AddSemigroup α
inst✝ : Neg β
h : Antiperiodic f c
a x : α
⊢ (fun x => f (a + x)) (x + c) = -(fun x => f (a + x)) x
Theorem: Rel.preimage_comp
File: Mathlib/Data/Rel.lean

tactic: simp only [preimage, inv_comp, image_comp]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
r : Rel α β
s : Rel β γ
t : Set γ
⊢ preimage (r • s) t = preimage r (preimage s t)
Theorem: AlgebraicGeometry.StructureSheaf.const_zero
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: erw [RingHom.map_zero, Subring.coe_zero, Pi.zero_apply, MulZeroClass.zero_mul]
state_before: R : Type u
inst✝ : CommRing R
f : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ U → f ∈ Ideal.primeCompl x.asIdeal
x : { x // x ∈ U.op.unop }
⊢ ↑(algebraMap R (Localizations R ↑x)) 0 =
    ↑0 x * ↑(algebraMap R (Localizations R ↑x)) ↑{ val := f, property := (_ : f ∈ Ideal.primeCompl (↑x).asIdeal) }
Theorem: List.join_append
File: Mathlib/Data/List/Join.lean

tactic: induction L₁
state_before: α : Type u_1
β : Type ?u.996
L₁ L₂ : List (List α)
⊢ join (L₁ ++ L₂) = join L₁ ++ join L₂

tactic: rfl
state_before: case nil
α : Type u_1
β : Type ?u.996
L₂ : List (List α)
⊢ join ([] ++ L₂) = join [] ++ join L₂

tactic: simp [*]
state_before: case cons
α : Type u_1
β : Type ?u.996
L₂ : List (List α)
head✝ : List α
tail✝ : List (List α)
tail_ih✝ : join (tail✝ ++ L₂) = join tail✝ ++ join L₂
⊢ join (head✝ :: tail✝ ++ L₂) = join (head✝ :: tail✝) ++ join L₂
Theorem: List.countp_filter
File: Mathlib/Data/List/Count.lean

tactic: simp only [countp_eq_length_filter, filter_filter]
state_before: α : Type u_1
l✝ : List α
p q : α → Bool
l : List α
⊢ countp p (filter q l) = countp (fun a => decide (p a = true ∧ q a = true)) l
Theorem: Partrec.vector_mOfFn
File: Mathlib/Computability/Partrec.lean

tactic: simp [Vector.mOfFn]
state_before: α : Type u_1
β : Type ?u.137451
γ : Type ?u.137454
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin (n + 1) → α →. σ
hf : ∀ (i : Fin (n + 1)), Partrec (f i)
⊢ Partrec fun a => Vector.mOfFn fun i => f i a

tactic: exact
  (hf 0).bind
    (Partrec.bind ((vector_mOfFn fun i => hf i.succ).comp fst)
      (Primrec.vector_cons.to_comp.comp (snd.comp fst) snd))
state_before: α : Type u_1
β : Type ?u.137451
γ : Type ?u.137454
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
n : ℕ
f : Fin (n + 1) → α →. σ
hf : ∀ (i : Fin (n + 1)), Partrec (f i)
⊢ Partrec fun a =>
    Part.bind (f 0 a) fun a_1 => Part.bind (Vector.mOfFn fun i => f (Fin.succ i) a) fun v => Part.some (a_1 ::ᵥ v)
Theorem: SimplexCategory.iso_eq_iso_refl
File: Mathlib/AlgebraicTopology/SimplexCategory.lean

tactic: have h : (Finset.univ : Finset (Fin (x.len + 1))).card = x.len + 1 := Finset.card_fin (x.len + 1)
state_before: x : SimplexCategory
e : x ≅ x
⊢ e = Iso.refl x

tactic: have eq₁ := Finset.orderEmbOfFin_unique' h fun i => Finset.mem_univ ((orderIsoOfIso e) i)
state_before: x : SimplexCategory
e : x ≅ x
h : Finset.card Finset.univ = len x + 1
⊢ e = Iso.refl x

tactic: have eq₂ :=
  Finset.orderEmbOfFin_unique' h fun i => Finset.mem_univ ((orderIsoOfIso (Iso.refl x)) i)
state_before: x : SimplexCategory
e : x ≅ x
h : Finset.card Finset.univ = len x + 1
eq₁ : RelIso.toRelEmbedding (orderIsoOfIso e) = Finset.orderEmbOfFin Finset.univ h
⊢ e = Iso.refl x

tactic: ext x
state_before: x : SimplexCategory
e : x ≅ x
h : Finset.card Finset.univ = len x + 1
eq₁ : RelIso.toRelEmbedding (orderIsoOfIso e) = Finset.orderEmbOfFin Finset.univ h
eq₂ : RelIso.toRelEmbedding (orderIsoOfIso (Iso.refl x)) = Finset.orderEmbOfFin Finset.univ h
⊢ e = Iso.refl x

tactic: simp_all
state_before: case w.a.h.h.h
x✝ : SimplexCategory
e : x✝ ≅ x✝
h : Finset.card Finset.univ = len x✝ + 1
x : Fin (len x✝ + 1)
eq₁ :
  (fun x_1 => ↑x_1 x) (RelIso.toRelEmbedding (orderIsoOfIso e)) =
    (fun x_1 => ↑x_1 x) (Finset.orderEmbOfFin Finset.univ h)
eq₂ :
  (fun x_1 => ↑x_1 x) (Finset.orderEmbOfFin Finset.univ h) =
    (fun x_1 => ↑x_1 x) (RelIso.toRelEmbedding (orderIsoOfIso (Iso.refl x✝)))
⊢ ↑(↑(Hom.toOrderHom e.hom) x) = ↑(↑(Hom.toOrderHom (Iso.refl x✝).hom) x)