ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Subgroup.prod_le_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁵ : Group G
inst✝⁴ : Group G'
inst✝³ : Group G''
A : Type u_4
inst✝² : AddGroup A
H✝ K✝ : Subgroup G
k : Set G
N : Type u_5
inst✝¹ : Group N
P : Type u_6
inst✝ : Group P
H : Subgroup G
K : Subgroup N
J : Subgroup (G × N)
⊢ H.prod K ≤ J ↔ map (MonoidHom.inl G N) H ≤ J ∧ map (MonoidHom.inr G N) K ≤ J
state_after: no goals
tactic: simpa only [← Subgroup.toSubmonoid_le] using Submonoid.prod_le_iff
Theorem: Equiv.pointReflection_involutive
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddGroup G
inst✝ : AddTorsor G P
x y : P
⊢ (pointReflection x) y = (Equiv.symm (pointReflection x)) y
state_after: no goals
tactic: rw [pointReflection_symm]
Theorem: CategoryTheory.MonoidalCategory.tensorRightTensor_inv_app
File: Mathlib/CategoryTheory/Monoidal/Category.lean

Proof steps:
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Z : C
⊢ (tensorRightTensor X Y).inv.app Z = (α_ Z X Y).hom
state_after: no goals
tactic: simp [tensorRightTensor]
Theorem: CategoryTheory.Limits.ImageMap.mk.injEq'
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ (map = map') = True
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'
tactic: simp only [Functor.id_obj, eq_iff_iff, iff_true]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
f✝ g✝ : Arrow C
inst✝³ : HasImage f✝.hom
inst✝² : HasImage g✝.hom
sq✝ : f✝ ⟶ g✝
f g : Arrow C
inst✝¹ : HasImage f.hom
inst✝ : HasImage g.hom
sq : f ⟶ g
map : image f.hom ⟶ image g.hom
map_ι : autoParam (map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) _auto✝
map' : image f.hom ⟶ image g.hom
map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right
⊢ map = map'
state_after: no goals
tactic: apply ImageMap.map_uniq_aux _ map_ι _ map_ι'
Theorem: WithLp.prod_nnnorm_equiv
File: Mathlib/Analysis/Normed/Lp/ProdLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
α : Type u_2
β : Type u_3
hp : Fact (1 ≤ p)
inst✝¹ : SeminormedAddCommGroup α
inst✝ : SeminormedAddCommGroup β
f : WithLp ⊤ (α × β)
⊢ ‖(WithLp.equiv ⊤ (α × β)) f‖₊ = ‖f‖₊
state_after: no goals
tactic: rw [prod_nnnorm_eq_sup, Prod.nnnorm_def', _root_.sup_eq_max, equiv_fst, equiv_snd]
Theorem: FiniteField.pow_card
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
⊢ a ^ q = a
state_after: case pos
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
h : a = 0
⊢ a ^ q = a

case neg
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
h : ¬a = 0
⊢ a ^ q = a
tactic: by_cases h : a = 0
state_before: case neg
K : Type u_1
R : Type u_2
inst✝¹ : GroupWithZero K
inst✝ : Fintype K
a : K
h : ¬a = 0
⊢ a ^ q = a
state_after: no goals
tactic: rw [← Nat.succ_pred_eq_of_pos Fintype.card_pos, pow_succ, Nat.pred_eq_sub_one,
    pow_card_sub_one_eq_one a h, one_mul]
Theorem: Real.logb_lt_logb_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hxy : x < y
⊢ logb b y < logb b x
state_after: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hxy : x < y
⊢ log x < log y
tactic: rw [logb, logb, div_lt_div_right_of_neg (log_neg b_pos b_lt_one)]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hxy : x < y
⊢ log x < log y
state_after: no goals
tactic: exact log_lt_log hx hxy
Theorem: QuadraticMap.polar_smul_right_of_tower
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝¹⁰ : CommRing R
inst✝⁹ : AddCommGroup M
inst✝⁸ : AddCommGroup N
inst✝⁷ : Module R M
inst✝⁶ : Module R N
Q : QuadraticMap R M N
inst✝⁵ : CommSemiring S
inst✝⁴ : Algebra S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : Module S N
inst✝ : IsScalarTower S R N
a : S
x y : M
⊢ polar (⇑Q) x (a • y) = a • polar (⇑Q) x y
state_after: no goals
tactic: rw [← IsScalarTower.algebraMap_smul R a y, polar_smul_right, algebraMap_smul]
Theorem: Set.Finite.dependent_image
File: Mathlib/Data/Set/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : s.Finite
F : (i : α) → i ∈ s → β
⊢ {y | ∃ x, ∃ (hx : x ∈ s), F x hx = y}.Finite
state_after: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : s.Finite
F : (i : α) → i ∈ s → β
this : Finite ↑s
⊢ {y | ∃ x, ∃ (hx : x ∈ s), F x hx = y}.Finite
tactic: have := hs.to_subtype
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
hs : s.Finite
F : (i : α) → i ∈ s → β
this : Finite ↑s
⊢ {y | ∃ x, ∃ (hx : x ∈ s), F x hx = y}.Finite
state_after: no goals
tactic: simpa [range] using finite_range fun x : s => F x x.2
Theorem: eq_of_slope_eq_zero
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

Proof steps:
state_before: k : Type u_1
E : Type u_2
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b : k
h : slope f a b = 0
⊢ f a = f b
state_after: no goals
tactic: rw [← sub_smul_slope_vadd f a b, h, smul_zero, zero_vadd]
Theorem: sphere_pi
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
π : β → Type u_3
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
x : (b : β) → π b
r : ℝ
h : 0 < r ∨ Nonempty β
⊢ sphere x r = (⋃ i, Function.eval i ⁻¹' sphere (x i) r) ∩ closedBall x r
state_after: case inl
α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
π : β → Type u_3
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
x : (b : β) → π b
r : ℝ
h : 0 < r ∨ Nonempty β
hr : r < 0
⊢ sphere x r = (⋃ i, Function.eval i ⁻¹' sphere (x i) r) ∩ closedBall x r

case inr.inl
α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
π : β → Type u_3
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
x : (b : β) → π b
h : 0 < 0 ∨ Nonempty β
⊢ sphere x 0 = (⋃ i, Function.eval i ⁻¹' sphere (x i) 0) ∩ closedBall x 0

case inr.inr
α : Type u_1
β : Type u_2
inst✝² : PseudoMetricSpace α
π : β → Type u_3
inst✝¹ : Fintype β
inst✝ : (b : β) → PseudoMetricSpace (π b)
x : (b : β) → π b
r : ℝ
h : 0 < r ∨ Nonempty β
hr : 0 < r
⊢ sphere x r = (⋃ i, Function.eval i ⁻¹' sphere (x i) r) ∩ closedBall x r
tactic: obtain hr | rfl | hr := lt_trichotomy r 0
Theorem: Fin.sum_univ_get
File: Mathlib/Algebra/BigOperators/Fin.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid α
l : List α
⊢ ∏ i : Fin l.length, l[↑i] = l.prod
state_after: no goals
tactic: simp [Finset.prod_eq_multiset_prod]
Theorem: ENNReal.toReal_le_toReal
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ ⊤
⊢ a.toReal ≤ b.toReal ↔ a ≤ b
state_after: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a).toReal ≤ b.toReal ↔ ↑a ≤ b
tactic: lift a to ℝ≥0 using ha
state_before: case intro
b c d : ℝ≥0∞
r p q : ℝ≥0
hb : b ≠ ⊤
a : ℝ≥0
⊢ (↑a).toReal ≤ b.toReal ↔ ↑a ≤ b
state_after: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a).toReal ≤ (↑b).toReal ↔ ↑a ≤ ↑b
tactic: lift b to ℝ≥0 using hb
state_before: case intro.intro
c d : ℝ≥0∞
r p q a b : ℝ≥0
⊢ (↑a).toReal ≤ (↑b).toReal ↔ ↑a ≤ ↑b
state_after: no goals
tactic: norm_cast
Theorem: Matrix.trace_kroneckerMapBilinear
File: Mathlib/Data/Matrix/Kronecker.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
α' : Type u_3
β : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
l : Type u_8
m : Type u_9
n : Type u_10
p : Type u_11
q : Type u_12
r : Type u_13
l' : Type u_14
m' : Type u_15
n' : Type u_16
p' : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype m
inst✝⁶ : Fintype n
inst✝⁵ : AddCommMonoid α
inst✝⁴ : AddCommMonoid β
inst✝³ : AddCommMonoid γ
inst✝² : Module R α
inst✝¹ : Module R β
inst✝ : Module R γ
f : α →ₗ[R] β →ₗ[R] γ
A : Matrix m m α
B : Matrix n n β
⊢ (((kroneckerMapBilinear f) A) B).trace = (f A.trace) B.trace
state_after: no goals
tactic: simp_rw [Matrix.trace, Matrix.diag, kroneckerMapBilinear_apply_apply, LinearMap.map_sum₂,
    map_sum, ← Finset.univ_product_univ, Finset.sum_product, kroneckerMap_apply]
Theorem: ZMod.isQuadratic_χ₈
File: Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean

Proof steps:
state_before: ⊢ χ₈.IsQuadratic
state_after: ⊢ ∀ (a : ZMod 8), χ₈ a = 0 ∨ χ₈ a = 1 ∨ χ₈ a = -1
tactic: unfold MulChar.IsQuadratic
state_before: ⊢ ∀ (a : ZMod 8), χ₈ a = 0 ∨ χ₈ a = 1 ∨ χ₈ a = -1
state_after: no goals
tactic: decide
Theorem: FirstOrder.Language.BoundedFormula.encoding_encode
File: Mathlib/ModelTheory/Encoding.lean

Proof steps:
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
⊢ (fun l => (listDecode l)[0]?) ((fun φ => φ.snd.listEncode) φ) = some φ
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode ([φ].bind fun φ => φ.snd.listEncode) = [φ]
⊢ (fun l => (listDecode l)[0]?) ((fun φ => φ.snd.listEncode) φ) = some φ
tactic: have h := listDecode_encode_list [φ]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode ([φ].bind fun φ => φ.snd.listEncode) = [φ]
⊢ (fun l => (listDecode l)[0]?) ((fun φ => φ.snd.listEncode) φ) = some φ
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode φ.snd.listEncode = [φ]
⊢ (fun l => (listDecode l)[0]?) ((fun φ => φ.snd.listEncode) φ) = some φ
tactic: rw [bind_singleton] at h
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode φ.snd.listEncode = [φ]
⊢ (fun l => (listDecode l)[0]?) ((fun φ => φ.snd.listEncode) φ) = some φ
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode φ.snd.listEncode = [φ]
⊢ (listDecode φ.snd.listEncode)[0]? = some φ
tactic: simp only
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode φ.snd.listEncode = [φ]
⊢ (listDecode φ.snd.listEncode)[0]? = some φ
state_after: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode φ.snd.listEncode = [φ]
⊢ [φ][0]? = some φ
tactic: rw [h]
state_before: L : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
φ : (n : ℕ) × L.BoundedFormula α n
h : listDecode φ.snd.listEncode = [φ]
⊢ [φ][0]? = some φ
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.map_iff
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
inst✝² : Category.{u_4, u_1} C₁
inst✝¹ : Category.{u_5, u_2} C₂
inst✝ : Category.{u_6, u_3} C₃
W : MorphismProperty C₁
F : C₁ ⥤ C₂
G : C₂ ⥤ C₃
⊢ (W.map F).IsInvertedBy G ↔ W.IsInvertedBy (F ⋙ G)
state_after: no goals
tactic: simp only [IsInvertedBy.iff_map_le_isomorphisms, map_map]
Theorem: Basis.reindexFinsetRange_apply
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x✝ : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
x : { x // x ∈ Finset.image (⇑b) Finset.univ }
⊢ b.reindexFinsetRange x = ↑x
state_after: case mk
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
bi : M
hbi : bi ∈ Finset.image (⇑b) Finset.univ
⊢ b.reindexFinsetRange ⟨bi, hbi⟩ = ↑⟨bi, hbi⟩
tactic: rcases x with ⟨bi, hbi⟩
state_before: case mk
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
bi : M
hbi : bi ∈ Finset.image (⇑b) Finset.univ
⊢ b.reindexFinsetRange ⟨bi, hbi⟩ = ↑⟨bi, hbi⟩
state_after: case mk.intro.intro
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
hbi : b i ∈ Finset.image (⇑b) Finset.univ
⊢ b.reindexFinsetRange ⟨b i, hbi⟩ = ↑⟨b i, hbi⟩
tactic: rcases Finset.mem_image.mp hbi with ⟨i, -, rfl⟩
state_before: case mk.intro.intro
ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
i : ι
hbi : b i ∈ Finset.image (⇑b) Finset.univ
⊢ b.reindexFinsetRange ⟨b i, hbi⟩ = ↑⟨b i, hbi⟩
state_after: no goals
tactic: exact b.reindexFinsetRange_self i
Theorem: leftLim_eq_of_tendsto
File: Mathlib/Topology/Order/LeftRightLim.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
⊢ leftLim f a = y
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y)
⊢ leftLim f a = y
tactic: have h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y) := ⟨y, h'⟩
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y)
⊢ leftLim f a = y
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y)
⊢ limUnder (𝓝[<] a) f = y
tactic: simp only [leftLim, h, h'', not_true, or_self_iff, if_false]
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y)
⊢ limUnder (𝓝[<] a) f = y
state_after: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y)
this : (𝓝[<] a).NeBot
⊢ limUnder (𝓝[<] a) f = y
tactic: haveI := neBot_iff.2 h
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrder α
inst✝¹ : TopologicalSpace β
hα : TopologicalSpace α
h'α : OrderTopology α
inst✝ : T2Space β
f : α → β
a : α
y : β
h : 𝓝[<] a ≠ ⊥
h' : Tendsto f (𝓝[<] a) (𝓝 y)
h'' : ∃ y, Tendsto f (𝓝[<] a) (𝓝 y)
this : (𝓝[<] a).NeBot
⊢ limUnder (𝓝[<] a) f = y
state_after: no goals
tactic: exact lim_eq h'
Theorem: MeasureTheory.Measure.fst_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ρ : Measure (α × β)
inst✝ : IsProbabilityMeasure ν
⊢ (μ.prod ν).fst = μ
state_after: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ρ : Measure (α × β)
inst✝ : IsProbabilityMeasure ν
s : Set α
hs : MeasurableSet s
⊢ (μ.prod ν).fst s = μ s
tactic: ext1 s hs
state_before: case h
α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
ρ : Measure (α × β)
inst✝ : IsProbabilityMeasure ν
s : Set α
hs : MeasurableSet s
⊢ (μ.prod ν).fst s = μ s
state_after: no goals
tactic: rw [fst_apply hs, ← prod_univ, prod_prod, measure_univ, mul_one]
Theorem: minpoly_algEquiv_toLinearMap
File: Mathlib/FieldTheory/Minpoly/Field.lean

Proof steps:
state_before: K : Type u_1
L : Type u_2
inst✝³ : Field K
inst✝² : CommRing L
inst✝¹ : IsDomain L
inst✝ : Algebra K L
σ : L ≃ₐ[K] L
hσ : IsOfFinOrder σ
⊢ minpoly K σ.toLinearMap = X ^ orderOf σ - C 1
state_after: case refine_1
K : Type u_1
L : Type u_2
inst✝³ : Field K
inst✝² : CommRing L
inst✝¹ : IsDomain L
inst✝ : Algebra K L
σ : L ≃ₐ[K] L
hσ : IsOfFinOrder σ
⊢ (Polynomial.aeval σ.toLinearMap) (X ^ orderOf σ - C 1) = 0

case refine_2
K : Type u_1
L : Type u_2
inst✝³ : Field K
inst✝² : CommRing L
inst✝¹ : IsDomain L
inst✝ : Algebra K L
σ : L ≃ₐ[K] L
hσ : IsOfFinOrder σ
⊢ ∀ (q : K[X]), q.Monic → (Polynomial.aeval σ.toLinearMap) q = 0 → (X ^ orderOf σ - C 1).degree ≤ q.degree
tactic: refine (minpoly.unique _ _ (monic_X_pow_sub_C _ hσ.orderOf_pos.ne.symm) ?_ ?_).symm
Theorem: LinearMap.mulRight_mul
File: Mathlib/Algebra/Algebra/Bilinear.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : NonUnitalSemiring A
inst✝² : Module R A
inst✝¹ : SMulCommClass R A A
inst✝ : IsScalarTower R A A
a b : A
⊢ mulRight R (a * b) = mulRight R b ∘ₗ mulRight R a
state_after: case h
R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : NonUnitalSemiring A
inst✝² : Module R A
inst✝¹ : SMulCommClass R A A
inst✝ : IsScalarTower R A A
a b x✝ : A
⊢ (mulRight R (a * b)) x✝ = (mulRight R b ∘ₗ mulRight R a) x✝
tactic: ext
state_before: case h
R : Type u_1
A : Type u_2
inst✝⁴ : CommSemiring R
inst✝³ : NonUnitalSemiring A
inst✝² : Module R A
inst✝¹ : SMulCommClass R A A
inst✝ : IsScalarTower R A A
a b x✝ : A
⊢ (mulRight R (a * b)) x✝ = (mulRight R b ∘ₗ mulRight R a) x✝
state_after: no goals
tactic: simp only [mulRight_apply, comp_apply, mul_assoc]
Theorem: isOpenMap_sum
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace W
f : X ⊕ Y → Z
⊢ IsOpenMap f ↔ (IsOpenMap fun a => f (inl a)) ∧ IsOpenMap fun b => f (inr b)
state_after: no goals
tactic: simp only [isOpenMap_iff_nhds_le, Sum.forall, nhds_inl, nhds_inr, Filter.map_map, comp]
Theorem: ArithmeticFunction.not_LSeriesSummable_moebius_at_one
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

Proof steps:
state_before: ⊢ ¬LSeriesSummable (fun n => ↑(μ n)) 1
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ False
tactic: intro h
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ False
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable fun b => -↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) b)
tactic: refine not_summable_one_div_on_primes <| summable_ofReal.mp <| Summable.of_neg ?_
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable fun b => -↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) b)
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i))
tactic: simp only [← Pi.neg_def, Set.indicator_comp_of_zero ofReal_zero, ofReal_inv, ofReal_natCast]
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
⊢ Summable (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i))
state_after: h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n
tactic: refine (h.indicator {n | n.Prime}).congr (fun n ↦ ?_)
state_before: h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n
state_after: case pos
h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
hn : n ∈ {p | Nat.Prime p}
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n

case neg
h : LSeriesSummable (fun n => ↑(μ n)) 1
n : ℕ
hn : n ∉ {p | Nat.Prime p}
⊢ {n | Nat.Prime n}.indicator (term (fun n => ↑(μ n)) 1) n =
    (-fun i => ↑({p | Nat.Prime p}.indicator (fun n => 1 / ↑n) i)) n
tactic: by_cases hn : n ∈ {p | p.Prime}