1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Substring.Valid.isEmpty
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [h.isEmpty, h.toString, ext_iff]
state_before: x✝ : Substring
h✝ : x✝.Valid
l m r : List Char
h : ValidFor l m r x✝
⊢ x✝.isEmpty = true ↔ x✝.toString = ""
state_after: no goals
Theorem: Orientation.oangle_add_left_eq_arcsin_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ o.oangle (x + y) y = ↑(Real.arcsin (‖x‖ / ‖x + y‖))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (x + y) = ↑(Real.arcsin (‖x‖ / ‖x + y‖))

tactic: rw [add_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (x + y) = ↑(Real.arcsin (‖x‖ / ‖x + y‖))
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (y + x) = ↑(Real.arcsin (‖x‖ / ‖y + x‖))

tactic: exact (-o).oangle_add_right_eq_arcsin_of_oangle_eq_pi_div_two h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ (-o).oangle y (y + x) = ↑(Real.arcsin (‖x‖ / ‖y + x‖))
state_after: no goals
Theorem: inv_le_one
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [inv_le (zero_lt_one.trans_le ha) zero_lt_one, inv_one]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 1 ≤ a
⊢ a⁻¹ ≤ 1
state_after: no goals
Theorem: QuotientAddGroup.norm_lt_iff
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rw [isGLB_lt_iff (isGLB_quotient_norm _), exists_mem_image]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ ‖x‖ < r ↔ ∃ m, ↑m = x ∧ ‖m‖ < r
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ (∃ x_1 ∈ {m | (mk' S) m = x}, ‖x_1‖ < r) ↔ ∃ m, ↑m = x ∧ ‖m‖ < r

tactic: rfl
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
x : M ⧸ S
r : ℝ
⊢ (∃ x_1 ∈ {m | (mk' S) m = x}, ‖x_1‖ < r) ↔ ∃ m, ↑m = x ∧ ‖m‖ < r
state_after: no goals
Theorem: MeasureTheory.Lp.simpleFunc.toSimpleFunc_eq_toFun
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: convert (AEEqFun.coeFn_mk (toSimpleFunc f)
      (toSimpleFunc f).aestronglyMeasurable).symm using 2
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : ↥(simpleFunc E p μ)
⊢ ↑(toSimpleFunc f) =ᶠ[ae μ] ↑↑↑f
state_after: case h.e'_5.h.e'_6
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : ↥(simpleFunc E p μ)
⊢ ↑↑f = AEEqFun.mk ↑(toSimpleFunc f) ⋯

tactic: exact (Classical.choose_spec f.2).symm
state_before: case h.e'_5.h.e'_6
α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f : ↥(simpleFunc E p μ)
⊢ ↑↑f = AEEqFun.mk ↑(toSimpleFunc f) ⋯
state_after: no goals
Theorem: Turing.Tape.move_left_right
File: Mathlib/Computability/TuringMachine.lean

tactic: cases T
state_before: Γ : Type u_1
inst✝ : Inhabited Γ
T : Tape Γ
⊢ move Dir.right (move Dir.left T) = T
state_after: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.right (move Dir.left { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }

tactic: simp [Tape.move]
state_before: case mk
Γ : Type u_1
inst✝ : Inhabited Γ
head✝ : Γ
left✝ right✝ : ListBlank Γ
⊢ move Dir.right (move Dir.left { head := head✝, left := left✝, right := right✝ }) =
    { head := head✝, left := left✝, right := right✝ }
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.LeftFraction.op_map
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: dsimp [map, RightFraction.map]
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
L✝ : C ⥤ D
W : MorphismProperty C
inst✝ : L✝.IsLocalization W
X Y : C
φ : W.LeftFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ (φ.map L hL).op = φ.op.map L.op ⋯
state_after: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
L✝ : C ⥤ D
W : MorphismProperty C
inst✝ : L✝.IsLocalization W
X Y : C
φ : W.LeftFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ (inv (L.map φ.s)).op ≫ (L.map φ.f).op = inv (L.map φ.s).op ≫ (L.map φ.f).op

tactic: rw [op_inv]
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
L✝ : C ⥤ D
W : MorphismProperty C
inst✝ : L✝.IsLocalization W
X Y : C
φ : W.LeftFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ (inv (L.map φ.s)).op ≫ (L.map φ.f).op = inv (L.map φ.s).op ≫ (L.map φ.f).op
state_after: no goals
Theorem: List.erase_get
File: Mathlib/Data/List/Basic.lean

tactic: simp
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
i : Fin [].length
⊢ [].erase ([].get i) ~ [].eraseIdx ↑i
state_after: no goals

tactic: simp
state_before: case cons.zero
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase (l.get i) ~ l.eraseIdx ↑i
⊢ (a :: l).erase ((a :: l).get 0) ~ (a :: l).eraseIdx ↑0
state_after: no goals

tactic: by_cases ha : a = l.get i
state_before: case cons.succ
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase (l.get i) ~ l.eraseIdx ↑i
i : Fin l.length
⊢ (a :: l).erase ((a :: l).get i.succ) ~ (a :: l).eraseIdx ↑i.succ
state_after: case pos
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase (l.get i) ~ l.eraseIdx ↑i
i : Fin l.length
ha : a = l.get i
⊢ (a :: l).erase ((a :: l).get i.succ) ~ (a :: l).eraseIdx ↑i.succ

case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase (l.get i) ~ l.eraseIdx ↑i
i : Fin l.length
ha : ¬a = l.get i
⊢ (a :: l).erase ((a :: l).get i.succ) ~ (a :: l).eraseIdx ↑i.succ

tactic: simpa [ha] using .trans (perm_cons_erase (l.get_mem i i.isLt)) (.cons _ (IH i))
state_before: case pos
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase (l.get i) ~ l.eraseIdx ↑i
i : Fin l.length
ha : a = l.get i
⊢ (a :: l).erase ((a :: l).get i.succ) ~ (a :: l).eraseIdx ↑i.succ
state_after: no goals

tactic: simp only [get_eq_getElem] at IH ha ⊢
state_before: case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase (l.get i) ~ l.eraseIdx ↑i
i : Fin l.length
ha : ¬a = l.get i
⊢ (a :: l).erase ((a :: l).get i.succ) ~ (a :: l).eraseIdx ↑i.succ
state_after: case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase l[↑i] ~ l.eraseIdx ↑i
i : Fin l.length
ha : ¬a = l[↑i]
⊢ (a :: l).erase (a :: l)[↑i.succ] ~ (a :: l).eraseIdx ↑i.succ

tactic: simpa [ha] using IH i
state_before: case neg
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq ι
a : ι
l : List ι
IH : ∀ (i : Fin l.length), l.erase l[↑i] ~ l.eraseIdx ↑i
i : Fin l.length
ha : ¬a = l[↑i]
⊢ (a :: l).erase (a :: l)[↑i.succ] ~ (a :: l).eraseIdx ↑i.succ
state_after: no goals
Theorem: frontier_Ioi'
File: Mathlib/Topology/Order/DenselyOrdered.lean

tactic: simp [frontier, closure_Ioi' ha, Iic_diff_Iio, Icc_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b : α
s : Set α
a : α
ha : (Ioi a).Nonempty
⊢ frontier (Ioi a) = {a}
state_after: no goals
Theorem: Filter.blimsup_and_le_inf
File: Mathlib/Order/LiminfLimsup.lean

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
⊢ ∀ (x : β), p x ∧ q x → p x
state_after: no goals

tactic: tauto
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
⊢ ∀ (x : β), p x ∧ q x → q x
state_after: no goals
Theorem: dist_prod_same_right
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: simp [Prod.dist_eq, dist_nonneg]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : PseudoMetricSpace β
x₁ x₂ : α
y : β
⊢ dist (x₁, y) (x₂, y) = dist x₁ x₂
state_after: no goals
Theorem: MeasureTheory.hasFiniteIntegral_count_iff
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [HasFiniteIntegral, lintegral_count, lt_top_iff_ne_top,
  ENNReal.tsum_coe_ne_top_iff_summable,  ← NNReal.summable_coe, coe_nnnorm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : MeasurableSingletonClass α
f : α → β
⊢ HasFiniteIntegral f Measure.count ↔ Summable fun x => ‖f x‖
state_after: no goals
Theorem: Continuous.exists_forall_le
File: Mathlib/Topology/Algebra/Order/Compact.lean

tactic: inhabit β
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty β
f : β → α
hf : Continuous f
hlim : Tendsto f (cocompact β) atTop
⊢ ∃ x, ∀ (y : β), f x ≤ f y
state_after: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty β
f : β → α
hf : Continuous f
hlim : Tendsto f (cocompact β) atTop
inhabited_h : Inhabited β
⊢ ∃ x, ∀ (y : β), f x ≤ f y

tactic: exact hf.exists_forall_le' default (hlim.eventually <| eventually_ge_atTop _)
state_before: α✝ : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁵ : LinearOrder α
inst✝⁴ : TopologicalSpace α
inst✝³ : TopologicalSpace β
inst✝² : TopologicalSpace γ
inst✝¹ : ClosedIicTopology α
inst✝ : Nonempty β
f : β → α
hf : Continuous f
hlim : Tendsto f (cocompact β) atTop
inhabited_h : Inhabited β
⊢ ∃ x, ∀ (y : β), f x ≤ f y
state_after: no goals
Theorem: Set.Nonempty.csSup_mem
File: Mathlib/Order/ConditionallyCompleteLattice/Finset.lean

tactic: lift s to Finset α using hs
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLinearOrder α
s t : Set α
a b : α
h : s.Nonempty
hs : s.Finite
⊢ sSup s ∈ s
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLinearOrder α
t : Set α
a b : α
s : Finset α
h : (↑s).Nonempty
⊢ sSup ↑s ∈ ↑s

tactic: exact Finset.Nonempty.csSup_mem h
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝ : ConditionallyCompleteLinearOrder α
t : Set α
a b : α
s : Finset α
h : (↑s).Nonempty
⊢ sSup ↑s ∈ ↑s
state_after: no goals
Theorem: AffineMap.lineMap_eq_right_iff
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: rw [← @lineMap_eq_lineMap_iff k V1, lineMap_apply_one]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹³ : Ring k
inst✝¹² : AddCommGroup V1
inst✝¹¹ : Module k V1
inst✝¹⁰ : AffineSpace V1 P1
inst✝⁹ : AddCommGroup V2
inst✝⁸ : Module k V2
inst✝⁷ : AffineSpace V2 P2
inst✝⁶ : AddCommGroup V3
inst✝⁵ : Module k V3
inst✝⁴ : AffineSpace V3 P3
inst✝³ : AddCommGroup V4
inst✝² : Module k V4
inst✝¹ : AffineSpace V4 P4
inst✝ : NoZeroSMulDivisors k V1
p₀ p₁ : P1
c : k
⊢ (lineMap p₀ p₁) c = p₁ ↔ p₀ = p₁ ∨ c = 1
state_after: no goals
Theorem: NonUnitalRingHom.comp_zero
File: Mathlib/Algebra/Ring/Hom/Defs.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
⊢ g.comp 0 = 0
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
x✝ : α
⊢ (g.comp 0) x✝ = 0 x✝

tactic: simp
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : NonUnitalNonAssocSemiring α
inst✝¹ : NonUnitalNonAssocSemiring β
inst✝ : NonUnitalNonAssocSemiring γ
g✝ : β →ₙ+* γ
f : α →ₙ+* β
g : β →ₙ+* γ
x✝ : α
⊢ (g.comp 0) x✝ = 0 x✝
state_after: no goals
Theorem: ENNReal.mul_div_cancel'
File: Mathlib/Data/ENNReal/Inv.lean

tactic: rw [mul_comm, ENNReal.div_mul_cancel h0 hI]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : a ≠ 0
hI : a ≠ ⊤
⊢ a * (b / a) = b
state_after: no goals
Theorem: Finset.sup'_inf_distrib_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [inf_comm, sup'_inf_distrib_left]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DistribLattice α
s : Finset ι
t : Finset κ
hs : s.Nonempty
ht : t.Nonempty
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ s.sup' hs f ⊓ a = s.sup' hs fun i => f i ⊓ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DistribLattice α
s : Finset ι
t : Finset κ
hs : s.Nonempty
ht : t.Nonempty
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ (s.sup' hs fun i => a ⊓ f i) = s.sup' hs fun i => f i ⊓ a

tactic: simp_rw [inf_comm]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DistribLattice α
s : Finset ι
t : Finset κ
hs : s.Nonempty
ht : t.Nonempty
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ (s.sup' hs fun i => a ⊓ f i) = s.sup' hs fun i => f i ⊓ a
state_after: no goals
Theorem: Ordinal.card_eq_zero
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: simpa using card_eq_nat (n := 0)
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ o.card = 0 ↔ o = 0
state_after: no goals
Theorem: Monoid.Coprod.mrange_inl_sup_mrange_inr
File: Mathlib/GroupTheory/Coprod/Basic.lean

tactic: rw [← mclosure_range_inl_union_inr, Submonoid.closure_union, ← MonoidHom.coe_mrange,
  ← MonoidHom.coe_mrange, Submonoid.closure_eq, Submonoid.closure_eq]
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
P : Type u_5
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass M'
inst✝¹ : MulOneClass N'
inst✝ : MulOneClass P
⊢ MonoidHom.mrange inl ⊔ MonoidHom.mrange inr = ⊤
state_after: no goals
Theorem: IsMulCentral.right_comm
File: Mathlib/Algebra/Group/Center.lean

tactic: simp only [h.right_assoc, h.mid_assoc, h.comm]
state_before: M : Type u_1
a✝ b✝ c : M
inst✝ : Mul M
h : IsMulCentral c
a b : M
⊢ a * b * c = a * c * b
state_after: no goals
Theorem: HomologicalComplex.Hom.comm
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

tactic: by_cases hij : c.Rel i j
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : A.Hom B
i j : ι
⊢ f.f i ≫ B.d i j = A.d i j ≫ f.f j
state_after: case pos
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : A.Hom B
i j : ι
hij : c.Rel i j
⊢ f.f i ≫ B.d i j = A.d i j ≫ f.f j

case neg
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : A.Hom B
i j : ι
hij : ¬c.Rel i j
⊢ f.f i ≫ B.d i j = A.d i j ≫ f.f j

tactic: exact f.comm' i j hij
state_before: case pos
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : A.Hom B
i j : ι
hij : c.Rel i j
⊢ f.f i ≫ B.d i j = A.d i j ≫ f.f j
state_after: no goals

tactic: rw [A.shape i j hij, B.shape i j hij, comp_zero, zero_comp]
state_before: case neg
ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C A B : HomologicalComplex V c
f : A.Hom B
i j : ι
hij : ¬c.Rel i j
⊢ f.f i ≫ B.d i j = A.d i j ≫ f.f j
state_after: no goals
Theorem: CliffordAlgebra.foldl_one
File: Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean

tactic: rw [← foldr_reverse, reverse.map_one, foldr_one]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticForm R M
f : M →ₗ[R] N →ₗ[R] N
hf : ∀ (m : M) (x : N), (f m) ((f m) x) = Q m • x
n : N
⊢ ((foldl Q f hf) n) 1 = n
state_after: no goals
Theorem: Function.mulSupport_prod_mk'
File: Mathlib/Algebra/Group/Support.lean

tactic: simp only [← mulSupport_prod_mk]
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
G : Type u_8
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M × N
⊢ mulSupport f = (mulSupport fun x => (f x).1) ∪ mulSupport fun x => (f x).2
state_after: no goals
Theorem: Ordinal.opow_lt_opow_left_of_succ
File: Mathlib/SetTheory/Ordinal/Exponential.lean

tactic: rw [opow_succ, opow_succ]
state_before: a b c : Ordinal.{u_1}
ab : a < b
⊢ a ^ succ c < b ^ succ c
state_after: a b c : Ordinal.{u_1}
ab : a < b
⊢ a ^ c * a < b ^ c * b

tactic: exact
  (mul_le_mul_right' (opow_le_opow_left c ab.le) a).trans_lt
    (mul_lt_mul_of_pos_left ab (opow_pos c ((Ordinal.zero_le a).trans_lt ab)))
state_before: a b c : Ordinal.{u_1}
ab : a < b
⊢ a ^ c * a < b ^ c * b
state_after: no goals
Theorem: IsAdjoinRootMonic.ext_elem
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [Basis.equivFun_apply, ← h.coeff_apply_coe, Basis.equivFun_apply, ← h.coeff_apply_coe,
  hxy i i.prop]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
x y : S
hxy : ∀ i < f.natDegree, h.coeff x i = h.coeff y i
i : Fin f.natDegree
⊢ h.basis.equivFun x i = h.basis.equivFun y i
state_after: no goals
Theorem: Set.Iic.coe_iInf
File: Mathlib/Order/CompleteLatticeIntervals.lean

tactic: rw [iInf, coe_sInf]
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ ↑(⨅ i, f i) = a ⊓ ⨅ i, ↑(f i)
state_after: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ a ⊓ sInf (Subtype.val '' range fun i => f i) = a ⊓ ⨅ i, ↑(f i)

tactic: congr
state_before: ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ a ⊓ sInf (Subtype.val '' range fun i => f i) = a ⊓ ⨅ i, ↑(f i)
state_after: case e_a.e_a
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ (Subtype.val '' range fun i => f i) = range fun i => ↑(f i)

tactic: ext
state_before: case e_a.e_a
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
⊢ (Subtype.val '' range fun i => f i) = range fun i => ↑(f i)
state_after: case e_a.e_a.h
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)

tactic: simp
state_before: case e_a.e_a.h
ι : Sort u_1
α : Type u_2
s : Set α
inst✝ : CompleteLattice α
a : α
S : Set ↑(Iic a)
f : ι → ↑(Iic a)
p : ι → Prop
x✝ : α
⊢ (x✝ ∈ Subtype.val '' range fun i => f i) ↔ x✝ ∈ range fun i => ↑(f i)
state_after: no goals
Theorem: UniformFun.precomp_uniformContinuous
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [UniformContinuous,
    (UniformFun.hasBasis_uniformity α β).tendsto_iff (UniformFun.hasBasis_uniformity γ β)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ UniformContinuous fun g => ofFun (toFun g ∘ f)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ ∀ ib ∈ 𝓤 β,
    ∃ ia ∈ 𝓤 β, ∀ x ∈ UniformFun.gen α β ia, (ofFun (toFun x.1 ∘ f), ofFun (toFun x.2 ∘ f)) ∈ UniformFun.gen γ β ib

tactic: exact fun U hU => ⟨U, hU, fun uv huv x => huv (f x)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
f : γ → α
⊢ ∀ ib ∈ 𝓤 β,
    ∃ ia ∈ 𝓤 β, ∀ x ∈ UniformFun.gen α β ia, (ofFun (toFun x.1 ∘ f), ofFun (toFun x.2 ∘ f)) ∈ UniformFun.gen γ β ib
state_after: no goals
Theorem: Cardinal.lift_lt_univ'
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: have := lift_lt.{_, max (u+1) v}.2 (lift_lt_univ c)
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal.{u}
⊢ lift.{max (u + 1) v, u} c < univ.{u, v}
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal.{u}
this : lift.{max (u + 1) v, u + 1} (lift.{u + 1, u} c) < lift.{max (u + 1) v, u + 1} univ.{u, u + 1}
⊢ lift.{max (u + 1) v, u} c < univ.{u, v}

tactic: rw [lift_lift, lift_univ, univ_umax.{u,v}] at this
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal.{u}
this : lift.{max (u + 1) v, u + 1} (lift.{u + 1, u} c) < lift.{max (u + 1) v, u + 1} univ.{u, u + 1}
⊢ lift.{max (u + 1) v, u} c < univ.{u, v}
state_after: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal.{u}
this : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} c < univ.{u, v}

tactic: exact this
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
c : Cardinal.{u}
this : lift.{max (u + 1) v, u} c < univ.{u, v}
⊢ lift.{max (u + 1) v, u} c < univ.{u, v}
state_after: no goals
Theorem: Ordnode.Valid'.rotateL_lemma₃
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: omega
state_before: α : Type u_1
inst✝ : Preorder α
a b c : ℕ
H2 : 3 * a ≤ b + c
h : b < 2 * c
⊢ a + b < 3 * c
state_after: no goals