1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Units.isOpen
File: Mathlib/Analysis/NormedSpace/Units.lean

tactic: nontriviality R
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
⊢ IsOpen {x | IsUnit x}
state_after: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
⊢ IsOpen {x | IsUnit x}

tactic: rw [Metric.isOpen_iff]
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
⊢ IsOpen {x | IsUnit x}
state_after: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
⊢ ∀ x ∈ {x | IsUnit x}, ∃ ε > 0, Metric.ball x ε ⊆ {x | IsUnit x}

tactic: rintro _ ⟨x, rfl⟩
state_before: R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
⊢ ∀ x ∈ {x | IsUnit x}, ∃ ε > 0, Metric.ball x ε ⊆ {x | IsUnit x}
state_after: case intro
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
x : Rˣ
⊢ ∃ ε > 0, Metric.ball (↑x) ε ⊆ {x | IsUnit x}

tactic: refine ⟨‖(↑x⁻¹ : R)‖⁻¹, _root_.inv_pos.mpr (Units.norm_pos x⁻¹), fun y hy ↦ ?_⟩
state_before: case intro
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
x : Rˣ
⊢ ∃ ε > 0, Metric.ball (↑x) ε ⊆ {x | IsUnit x}
state_after: case intro
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
x : Rˣ
y : R
hy : y ∈ Metric.ball ↑x ‖↑x⁻¹‖⁻¹
⊢ y ∈ {x | IsUnit x}

tactic: rw [mem_ball_iff_norm] at hy
state_before: case intro
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
x : Rˣ
y : R
hy : y ∈ Metric.ball ↑x ‖↑x⁻¹‖⁻¹
⊢ y ∈ {x | IsUnit x}
state_after: case intro
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
x : Rˣ
y : R
hy : ‖y - ↑x‖ < ‖↑x⁻¹‖⁻¹
⊢ y ∈ {x | IsUnit x}

tactic: exact (x.ofNearby y hy).isUnit
state_before: case intro
R : Type u_1
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
a✝ : Nontrivial R
x : Rˣ
y : R
hy : ‖y - ↑x‖ < ‖↑x⁻¹‖⁻¹
⊢ y ∈ {x | IsUnit x}
state_after: no goals
Theorem: MeasurableEmbedding.restrict_map
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: simp [hf.map_apply, ht, hf.measurable ht]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
m1 : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
μ : Measure α
s t : Set β
ht : MeasurableSet t
⊢ ((Measure.map f μ).restrict s) t = (Measure.map f (μ.restrict (f ⁻¹' s))) t
state_after: no goals
Theorem: SetTheory.PGame.powHalf_leftMoves
File: Mathlib/SetTheory/Surreal/Dyadic.lean

tactic: cases n <;> rfl
state_before: n : ℕ
⊢ (powHalf n).LeftMoves = PUnit.{u_1 + 1}
state_after: no goals
Theorem: Stream'.Seq1.join_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: dsimp [join]
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ join ((a, Seq.cons b s), S) = (a, (Seq.cons (b, s) S).join)
state_after: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ (match (Seq.cons b s).destruct with
    | none => (a, S.join)
    | some s' => (a, (Seq.cons s' S).join)) =
    (a, (Seq.cons (b, s) S).join)

tactic: rw [destruct_cons]
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ (match (Seq.cons b s).destruct with
    | none => (a, S.join)
    | some s' => (a, (Seq.cons s' S).join)) =
    (a, (Seq.cons (b, s) S).join)
state_after: no goals
Theorem: prod_mem_nhds_iff
File: Mathlib/Topology/Constructions.lean

tactic: rw [nhds_prod_eq, prod_mem_prod_iff]
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
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
s : Set X
t : Set Y
x : X
y : Y
⊢ s ×ˢ t ∈ 𝓝 (x, y) ↔ s ∈ 𝓝 x ∧ t ∈ 𝓝 y
state_after: no goals
Theorem: affineIndependent_iff_not_collinear
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rw [collinear_iff_finrank_le_one,
  affineIndependent_iff_not_finrank_vectorSpan_le k p (Fintype.card_fin 3)]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p : Fin 3 → P
⊢ AffineIndependent k p ↔ ¬Collinear k (Set.range p)
state_after: no goals
Theorem: Relation.reflTransGen_transGen
File: Mathlib/Logic/Relation.lean

tactic: simp only [← reflGen_transGen, transGen_idem]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
⊢ ReflTransGen (TransGen r) = ReflTransGen r
state_after: no goals
Theorem: IsPGroup.index
File: Mathlib/GroupTheory/PGroup.lean

tactic: haveI := H.normalCore.fintypeQuotientOfFiniteIndex
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
⊢ ∃ n, H.index = p ^ n
state_after: p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
this : Fintype (G ⧸ H.normalCore)
⊢ ∃ n, H.index = p ^ n

tactic: obtain ⟨n, hn⟩ := iff_card.mp (hG.to_quotient H.normalCore)
state_before: p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
this : Fintype (G ⧸ H.normalCore)
⊢ ∃ n, H.index = p ^ n
state_after: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
this : Fintype (G ⧸ H.normalCore)
n : ℕ
hn : card (G ⧸ H.normalCore) = p ^ n
⊢ ∃ n, H.index = p ^ n

tactic: obtain ⟨k, _, hk2⟩ :=
  (Nat.dvd_prime_pow hp.out).mp
    ((congr_arg _ (H.normalCore.index_eq_card.trans hn)).mp
      (Subgroup.index_dvd_of_le H.normalCore_le))
state_before: case intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
this : Fintype (G ⧸ H.normalCore)
n : ℕ
hn : card (G ⧸ H.normalCore) = p ^ n
⊢ ∃ n, H.index = p ^ n
state_after: case intro.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
this : Fintype (G ⧸ H.normalCore)
n : ℕ
hn : card (G ⧸ H.normalCore) = p ^ n
k : ℕ
left✝ : k ≤ n
hk2 : H.index = p ^ k
⊢ ∃ n, H.index = p ^ n

tactic: exact ⟨k, hk2⟩
state_before: case intro.intro.intro
p : ℕ
G : Type u_1
inst✝¹ : Group G
hG : IsPGroup p G
hp : Fact (Nat.Prime p)
H : Subgroup G
inst✝ : H.FiniteIndex
this : Fintype (G ⧸ H.normalCore)
n : ℕ
hn : card (G ⧸ H.normalCore) = p ^ n
k : ℕ
left✝ : k ≤ n
hk2 : H.index = p ^ k
⊢ ∃ n, H.index = p ^ n
state_after: no goals
Theorem: PresentedGroup.toGroup.unique
File: Mathlib/GroupTheory/PresentedGroup.lean

tactic: intro x
state_before: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
⊢ ∀ {x : PresentedGroup rels}, g x = (toGroup h) x
state_after: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ g x = (toGroup h) x

tactic: refine QuotientGroup.induction_on x ?_
state_before: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ g x = (toGroup h) x
state_after: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ ∀ (z : FreeGroup α), g ↑z = (toGroup h) ↑z

tactic: exact fun _ ↦ FreeGroup.lift.unique (g.comp (QuotientGroup.mk' _)) hg
state_before: α : Type u_1
G : Type u_2
inst✝ : Group G
f : α → G
rels : Set (FreeGroup α)
h : ∀ r ∈ rels, (FreeGroup.lift f) r = 1
g : PresentedGroup rels →* G
hg : ∀ (x : α), g (PresentedGroup.of x) = f x
x : PresentedGroup rels
⊢ ∀ (z : FreeGroup α), g ↑z = (toGroup h) ↑z
state_after: no goals
Theorem: CategoryTheory.braiding_tensorUnit_right
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

tactic: simp [← rightUnitor_inv_braiding]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (β_ X (𝟙_ C)).hom = (ρ_ X).hom ≫ (λ_ X).inv
state_after: no goals
Theorem: pow_card_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [← Nat.card_eq_fintype_card, pow_card_eq_one']
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Fintype G
x : G
n : ℕ
⊢ x ^ card G = 1
state_after: no goals
Theorem: List.isRotated_iff_mem_map_range
File: Mathlib/Data/List/Rotate.lean

tactic: simp_rw [mem_map, mem_range, isRotated_iff_mod]
state_before: α : Type u
l l' : List α
⊢ l ~r l' ↔ l' ∈ map l.rotate (range (l.length + 1))
state_after: α : Type u
l l' : List α
⊢ (∃ n ≤ l.length, l.rotate n = l') ↔ ∃ a < l.length + 1, l.rotate a = l'

tactic: exact
  ⟨fun ⟨n, hn, h⟩ => ⟨n, Nat.lt_succ_of_le hn, h⟩,
    fun ⟨n, hn, h⟩ => ⟨n, Nat.le_of_lt_succ hn, h⟩⟩
state_before: α : Type u
l l' : List α
⊢ (∃ n ≤ l.length, l.rotate n = l') ↔ ∃ a < l.length + 1, l.rotate a = l'
state_after: no goals
Theorem: Batteries.UnionFind.parentD_findAux_lt
File: .lake/packages/batteries/Batteries/Data/UnionFind/Basic.lean

tactic: if h' : (self.arr.get x).parent = x then
  rw [findAux_s, if_pos h']; apply self.parentD_lt h
else
  rw [parentD_findAux]; split <;> [simp [rootD_lt]; skip]
  have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›)
  apply parentD_findAux_lt h
state_before: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
⊢ parentD (self.findAux x).s i < self.size
state_after: no goals

tactic: rw [findAux_s, if_pos h']
state_before: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : (self.arr.get x).parent = ↑x
⊢ parentD (self.findAux x).s i < self.size
state_after: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : (self.arr.get x).parent = ↑x
⊢ parentD self.arr i < self.size

tactic: apply self.parentD_lt h
state_before: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : (self.arr.get x).parent = ↑x
⊢ parentD self.arr i < self.size
state_after: no goals

tactic: rw [parentD_findAux]
state_before: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
⊢ parentD (self.findAux x).s i < self.size
state_after: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
⊢ (if i = ↑x then self.rootD ↑x else parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s i) < self.size

tactic: split <;> [simp [rootD_lt]; skip]
state_before: i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
⊢ (if i = ↑x then self.rootD ↑x else parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s i) < self.size
state_after: case isFalse
i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s i < self.size

tactic: have := Nat.sub_lt_sub_left (self.lt_rankMax x) (self.rank'_lt _ ‹_›)
state_before: case isFalse
i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
h✝ : ¬i = ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s i < self.size
state_after: case isFalse
i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
h✝ : ¬i = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s i < self.size

tactic: apply parentD_findAux_lt h
state_before: case isFalse
i : Nat
self : UnionFind
x : Fin self.size
h : i < self.size
h' : ¬(self.arr.get x).parent = ↑x
h✝ : ¬i = ↑x
this : self.rankMax - self.rank (self.arr.get x).parent < self.rankMax - self.rank ↑x
⊢ parentD (self.findAux ⟨(self.arr.get x).parent, ⋯⟩).s i < self.size
state_after: no goals
Theorem: CategoryTheory.PreGaloisCategory.non_zero_card_fiber_of_not_initial
File: Mathlib/CategoryTheory/Galois/Basic.lean

tactic: intro hzero
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
⊢ Nat.card ↑(F.obj X) ≠ 0
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
hzero : Nat.card ↑(F.obj X) = 0
⊢ False

tactic: refine Nonempty.elim ?_ h
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
hzero : Nat.card ↑(F.obj X) = 0
⊢ False
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
hzero : Nat.card ↑(F.obj X) = 0
⊢ Nonempty (IsInitial X)

tactic: rw [initial_iff_fiber_empty F]
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
hzero : Nat.card ↑(F.obj X) = 0
⊢ Nonempty (IsInitial X)
state_after: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
hzero : Nat.card ↑(F.obj X) = 0
⊢ IsEmpty ↑(F.obj X)

tactic: exact Finite.card_eq_zero_iff.mp hzero
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
inst✝¹ : PreGaloisCategory C
F : C ⥤ FintypeCat
inst✝ : FiberFunctor F
X : C
h : IsInitial X → False
hzero : Nat.card ↑(F.obj X) = 0
⊢ IsEmpty ↑(F.obj X)
state_after: no goals
Theorem: Polynomial.reverse_C
File: Mathlib/Algebra/Polynomial/Reverse.lean

tactic: simp [reverse]
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
t : R
⊢ (C t).reverse = C t
state_after: no goals
Theorem: ContextFreeGrammar.mem_language_iff
File: Mathlib/Computability/ContextFreeGrammar.lean

tactic: rfl
state_before: T : Type uT
g : ContextFreeGrammar T
w : List T
⊢ w ∈ g.language ↔ g.Derives [Symbol.nonterminal g.initial] (List.map Symbol.terminal w)
state_after: no goals
Theorem: List.length_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: rw [rotate_eq_rotate', length_rotate']
state_before: α : Type u
l : List α
n : ℕ
⊢ (l.rotate n).length = l.length
state_after: no goals
Theorem: sq_le_sq
File: Mathlib/Algebra/Order/Ring/Abs.lean

tactic: simpa only [sq_abs] using
  (pow_left_strictMonoOn two_ne_zero).le_iff_le (abs_nonneg a) (abs_nonneg b)
state_before: α : Type u_1
inst✝ : LinearOrderedRing α
n : ℕ
a b c : α
⊢ a ^ 2 ≤ b ^ 2 ↔ |a| ≤ |b|
state_after: no goals
Theorem: pow_add_pow_le'
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: rw [two_mul]
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
n m : ℕ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ a ^ n + b ^ n ≤ 2 * (a + b) ^ n
state_after: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
n m : ℕ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ a ^ n + b ^ n ≤ (a + b) ^ n + (a + b) ^ n

tactic: exact add_le_add (pow_le_pow_left ha (le_add_of_nonneg_right hb) _)
  (pow_le_pow_left hb (le_add_of_nonneg_left ha) _)
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : OrderedSemiring R
a b x y : R
n m : ℕ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ a ^ n + b ^ n ≤ (a + b) ^ n + (a + b) ^ n
state_after: no goals
Theorem: IsUnit.div_left_inj
File: Mathlib/Algebra/Group/Units.lean

tactic: simp only [div_eq_mul_inv]
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit c
⊢ a / c = b / c ↔ a = b
state_after: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit c
⊢ a * c⁻¹ = b * c⁻¹ ↔ a = b

tactic: exact Units.mul_left_inj h.inv.unit'
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit c
⊢ a * c⁻¹ = b * c⁻¹ ↔ a = b
state_after: no goals
Theorem: multipliable_of_finite_mulSupport
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: apply multipliable_of_ne_finset_one (s := h.toFinset)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ Multipliable f
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ ∀ b ∉ h.toFinset, f b = 1

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
h : (mulSupport f).Finite
⊢ ∀ b ∉ h.toFinset, f b = 1
state_after: no goals
Theorem: CategoryTheory.Localization.essSurj_mapArrow_of_hasRightCalculusOfFractions
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: have := Localization.essSurj_mapArrow L.op W.op
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
inst✝ : W.HasRightCalculusOfFractions
f : Arrow D
⊢ f ∈ L.mapArrow.essImage
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
inst✝ : W.HasRightCalculusOfFractions
f : Arrow D
this : L.op.mapArrow.EssSurj
⊢ f ∈ L.mapArrow.essImage

tactic: obtain ⟨g, ⟨e⟩⟩ : ∃ (g : _), Nonempty (L.op.mapArrow.obj g ≅ Arrow.mk f.hom.op) :=
  ⟨_, ⟨Functor.objObjPreimageIso _ _⟩⟩
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
inst✝ : W.HasRightCalculusOfFractions
f : Arrow D
this : L.op.mapArrow.EssSurj
⊢ f ∈ L.mapArrow.essImage
state_after: case intro.intro
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
inst✝ : W.HasRightCalculusOfFractions
f : Arrow D
this : L.op.mapArrow.EssSurj
g : Arrow Cᵒᵖ
e : L.op.mapArrow.obj g ≅ Arrow.mk f.hom.op
⊢ f ∈ L.mapArrow.essImage

tactic: exact ⟨Arrow.mk g.hom.unop, ⟨Arrow.isoMk (Arrow.rightFunc.mapIso e.symm).unop
  (Arrow.leftFunc.mapIso e.symm).unop (Quiver.Hom.op_inj e.inv.w.symm)⟩⟩
state_before: case intro.intro
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
inst✝ : W.HasRightCalculusOfFractions
f : Arrow D
this : L.op.mapArrow.EssSurj
g : Arrow Cᵒᵖ
e : L.op.mapArrow.obj g ≅ Arrow.mk f.hom.op
⊢ f ∈ L.mapArrow.essImage
state_after: no goals
Theorem: CategoryTheory.Limits.IsLimit.OfNatIso.cone_fac
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: rw [← coneOfHom_homOfCone h s]
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ (limitCone h).extend (homOfCone h s) = s
state_after: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ (limitCone h).extend (homOfCone h (coneOfHom h (homOfCone h s))) = coneOfHom h (homOfCone h s)

tactic: conv_lhs => simp only [homOfCone_coneOfHom]
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ (limitCone h).extend (homOfCone h (coneOfHom h (homOfCone h s))) = coneOfHom h (homOfCone h s)
state_after: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ (limitCone h).extend (homOfCone h s) = coneOfHom h (homOfCone h s)

tactic: apply (coneOfHom_fac _ _).symm
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ F.cones
s : Cone F
⊢ (limitCone h).extend (homOfCone h s) = coneOfHom h (homOfCone h s)
state_after: no goals
Theorem: CategoryTheory.StructuredArrow.map_id
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

tactic: rw [eq_mk f]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj f = f
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj (mk f.hom) = mk f.hom

tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj (mk f.hom) = mk f.hom
state_after: no goals
Theorem: toIcoMod_sub_eq_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: simp_rw [toIcoMod, toIcoDiv_sub_eq_toIcoDiv_add, sub_right_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoMod hp a (b - c) = toIcoMod hp (a + c) b - c
state_after: no goals
Theorem: closure_Ioc
File: Mathlib/Topology/Order/DenselyOrdered.lean

tactic: apply Subset.antisymm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioc a b) = Icc a b
state_after: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioc a b) ⊆ Icc a b

case h₂
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioc a b)

tactic: exact closure_minimal Ioc_subset_Icc_self isClosed_Icc
state_before: case h₁
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ioc a b) ⊆ Icc a b
state_after: no goals

tactic: apply Subset.trans _ (closure_mono Ioo_subset_Ioc_self)
state_before: case h₂
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioc a b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioo a b)

tactic: rw [closure_Ioo hab]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioo a b)
state_after: no goals
Theorem: List.foldlIdx_eq_foldl_enum
File: Mathlib/Data/List/Indexes.lean

tactic: simp only [foldlIdx, foldlIdxSpec, foldlIdx_eq_foldlIdxSpec, enum]
state_before: α : Type u
β : Type v
f : ℕ → α → β → α
a : α
bs : List β
⊢ foldlIdx f a bs = foldl (fun a p => f p.1 a p.2) a bs.enum
state_after: no goals