1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SetTheory.PGame.nim_fuzzy_zero_of_ne_zero
File: Mathlib/SetTheory/Game/Nim.lean

tactic: rw [Impartial.fuzzy_zero_iff_lf, nim_def, lf_zero_le]
state_before: o : Ordinal.{u_1}
ho : o ≠ 0
⊢ nim o ‖ 0
state_after: o : Ordinal.{u_1}
ho : o ≠ 0
⊢ ∃ j,
    (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
            nim (typein (fun x x_1 => x < x_1) o₂)).moveRight
        j ≤
      0

tactic: rw [← Ordinal.pos_iff_ne_zero] at ho
state_before: o : Ordinal.{u_1}
ho : o ≠ 0
⊢ ∃ j,
    (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
            nim (typein (fun x x_1 => x < x_1) o₂)).moveRight
        j ≤
      0
state_after: o : Ordinal.{u_1}
ho : 0 < o
⊢ ∃ j,
    (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
            nim (typein (fun x x_1 => x < x_1) o₂)).moveRight
        j ≤
      0

tactic: exact ⟨(Ordinal.principalSegOut ho).top, by simp⟩
state_before: o : Ordinal.{u_1}
ho : 0 < o
⊢ ∃ j,
    (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
            nim (typein (fun x x_1 => x < x_1) o₂)).moveRight
        j ≤
      0
state_after: no goals

tactic: simp
state_before: o : Ordinal.{u_1}
ho : 0 < o
⊢ (mk (Quotient.out o).α (Quotient.out o).α (fun o₂ => nim (typein (fun x x_1 => x < x_1) o₂)) fun o₂ =>
          nim (typein (fun x x_1 => x < x_1) o₂)).moveRight
      (principalSegOut ho).top ≤
    0
state_after: no goals
Theorem: CategoryTheory.Limits.Pi.map'_id_id
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: ext
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : α → C
inst✝ : HasProduct f
⊢ (map' id fun a => 𝟙 (f a)) = 𝟙 (∏ᶜ f)
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : α → C
inst✝ : HasProduct f
b✝ : α
⊢ (map' id fun a => 𝟙 (f a)) ≫ π f b✝ = 𝟙 (∏ᶜ f) ≫ π f b✝

tactic: simp
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
f : α → C
inst✝ : HasProduct f
b✝ : α
⊢ (map' id fun a => 𝟙 (f a)) ≫ π f b✝ = 𝟙 (∏ᶜ f) ≫ π f b✝
state_after: no goals
Theorem: CategoryTheory.simple_iff_subobject_isSimpleOrder
File: Mathlib/CategoryTheory/Simple.lean

tactic: intro h
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
⊢ Simple X → IsSimpleOrder (Subobject X)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
h : Simple X
⊢ IsSimpleOrder (Subobject X)

tactic: infer_instance
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
h : Simple X
⊢ IsSimpleOrder (Subobject X)
state_after: no goals

tactic: intro h
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
⊢ IsSimpleOrder (Subobject X) → Simple X
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
h : IsSimpleOrder (Subobject X)
⊢ Simple X

tactic: exact simple_of_isSimpleOrder_subobject X
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
h : IsSimpleOrder (Subobject X)
⊢ Simple X
state_after: no goals
Theorem: PartialHomeomorph.continuous_iff_continuous_comp_left
File: Mathlib/Topology/PartialHomeomorph.lean

tactic: simp only [continuous_iff_continuousOn_univ]
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
f : Z → X
h : f ⁻¹' e.source = univ
⊢ Continuous f ↔ Continuous (↑e ∘ f)
state_after: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
f : Z → X
h : f ⁻¹' e.source = univ
⊢ ContinuousOn f univ ↔ ContinuousOn (↑e ∘ f) univ

tactic: exact e.continuousOn_iff_continuousOn_comp_left (Eq.symm h).subset
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e : PartialHomeomorph X Y
f : Z → X
h : f ⁻¹' e.source = univ
⊢ ContinuousOn f univ ↔ ContinuousOn (↑e ∘ f) univ
state_after: no goals
Theorem: Irrational.int_sub
File: Mathlib/Data/Real/Irrational.lean

tactic: simpa only [Rat.cast_intCast] using h.rat_sub m
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
⊢ Irrational (↑m - x)
state_after: no goals
Theorem: antitone_dual_iff
File: Mathlib/Order/Monotone/Basic.lean

tactic: rw [antitone_toDual_comp_iff, monotone_comp_ofDual_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ Antitone (⇑toDual ∘ f ∘ ⇑ofDual) ↔ Antitone f
state_after: no goals
Theorem: Lagrange.eval_nodal_not_at_node
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp_rw [nodal, eval_prod, prod_ne_zero_iff, eval_sub, eval_X, eval_C, sub_ne_zero]
state_before: R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
x : R
hx : ∀ i ∈ s, x ≠ v i
⊢ eval x (nodal s v) ≠ 0
state_after: R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
x : R
hx : ∀ i ∈ s, x ≠ v i
⊢ ∀ a ∈ s, x ≠ v a

tactic: exact hx
state_before: R : Type u_1
inst✝² : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝¹ : Nontrivial R
inst✝ : NoZeroDivisors R
x : R
hx : ∀ i ∈ s, x ≠ v i
⊢ ∀ a ∈ s, x ≠ v a
state_after: no goals
Theorem: Algebra.commute_of_mem_adjoin_singleton_of_commute
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: simpa
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
inst✝⁸ : CommSemiring R
inst✝⁷ : CommSemiring S
inst✝⁶ : Semiring A
inst✝⁵ : Semiring B
inst✝⁴ : Algebra R S
inst✝³ : Algebra R A
inst✝² : Algebra S A
inst✝¹ : Algebra R B
inst✝ : IsScalarTower R S A
s t : Set A
a b c : A
hc : c ∈ adjoin R {b}
h : Commute a b
⊢ ∀ b_1 ∈ {b}, Commute a b_1
state_after: no goals
Theorem: Polynomial.eval₂_modByMonic_eq_self_of_root
File: Mathlib/Algebra/Polynomial/Div.lean

tactic: rw [modByMonic_eq_sub_mul_div p hq, eval₂_sub, eval₂_mul, hx, zero_mul, sub_zero]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝¹ : CommRing R
p✝ q✝ : R[X]
inst✝ : CommRing S
f : R →+* S
p q : R[X]
hq : q.Monic
x : S
hx : eval₂ f x q = 0
⊢ eval₂ f x (p %ₘ q) = eval₂ f x p
state_after: no goals
Theorem: CategoryTheory.Functor.isEquivalence_of_comp_right
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: rw [isEquivalence_iff_of_iso (F.rightUnitor.symm ≪≫ isoWhiskerLeft F (G.asEquivalence.unitIso))]
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F : C ⥤ D
G : D ⥤ E
inst✝¹ : G.IsEquivalence
inst✝ : (F ⋙ G).IsEquivalence
⊢ F.IsEquivalence
state_after: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F : C ⥤ D
G : D ⥤ E
inst✝¹ : G.IsEquivalence
inst✝ : (F ⋙ G).IsEquivalence
⊢ (F ⋙ G.asEquivalence.functor ⋙ G.asEquivalence.inverse).IsEquivalence

tactic: exact ((F ⋙ G).asEquivalence.trans G.asEquivalence.symm).isEquivalence_functor
state_before: C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
E : Type u_1
inst✝² : Category.{u_2, u_1} E
F : C ⥤ D
G : D ⥤ E
inst✝¹ : G.IsEquivalence
inst✝ : (F ⋙ G).IsEquivalence
⊢ (F ⋙ G.asEquivalence.functor ⋙ G.asEquivalence.inverse).IsEquivalence
state_after: no goals
Theorem: List.prev_cons_cons_of_ne'
File: Mathlib/Data/List/Cycle.lean

tactic: cases l
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x y z : α
h : x ∈ y :: z :: l
hy : x ≠ y
hz : x = z
⊢ (y :: z :: l).prev x h = y
state_after: case nil
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x = z
h : x ∈ [y, z]
⊢ [y, z].prev x h = y

case cons
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x = z
head✝ : α
tail✝ : List α
h : x ∈ y :: z :: head✝ :: tail✝
⊢ (y :: z :: head✝ :: tail✝).prev x h = y

tactic: simp [prev, hy, hz]
state_before: case nil
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x = z
h : x ∈ [y, z]
⊢ [y, z].prev x h = y
state_after: no goals

tactic: rw [prev, dif_neg hy, if_pos hz]
state_before: case cons
α : Type u_1
inst✝ : DecidableEq α
x y z : α
hy : x ≠ y
hz : x = z
head✝ : α
tail✝ : List α
h : x ∈ y :: z :: head✝ :: tail✝
⊢ (y :: z :: head✝ :: tail✝).prev x h = y
state_after: no goals
Theorem: GeneralizedContinuedFraction.convergents'Aux_stable_of_terminated
File: Mathlib/Algebra/ContinuedFractions/TerminatedStable.lean

tactic: induction' n_le_m with m n_le_m IH
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
n_le_m : n ≤ m
terminated_at_n : s.TerminatedAt n
⊢ convergents'Aux s m = convergents'Aux s n
state_after: case refl
K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : s.TerminatedAt n
⊢ convergents'Aux s n = convergents'Aux s n

case step
K : Type u_1
g : GeneralizedContinuedFraction K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : s.TerminatedAt n
m : ℕ
n_le_m : n.le m
IH : convergents'Aux s m = convergents'Aux s n
⊢ convergents'Aux s m.succ = convergents'Aux s n

tactic: rfl
state_before: case refl
K : Type u_1
g : GeneralizedContinuedFraction K
n m : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : s.TerminatedAt n
⊢ convergents'Aux s n = convergents'Aux s n
state_after: no goals

tactic: refine (convergents'Aux_stable_step_of_terminated ?_).trans IH
state_before: case step
K : Type u_1
g : GeneralizedContinuedFraction K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : s.TerminatedAt n
m : ℕ
n_le_m : n.le m
IH : convergents'Aux s m = convergents'Aux s n
⊢ convergents'Aux s m.succ = convergents'Aux s n
state_after: case step
K : Type u_1
g : GeneralizedContinuedFraction K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : s.TerminatedAt n
m : ℕ
n_le_m : n.le m
IH : convergents'Aux s m = convergents'Aux s n
⊢ s.TerminatedAt m

tactic: exact s.terminated_stable n_le_m terminated_at_n
state_before: case step
K : Type u_1
g : GeneralizedContinuedFraction K
n m✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
terminated_at_n : s.TerminatedAt n
m : ℕ
n_le_m : n.le m
IH : convergents'Aux s m = convergents'Aux s n
⊢ s.TerminatedAt m
state_after: no goals
Theorem: MvPolynomial.NewtonIdentities.esymm_to_weight
File: Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean

tactic: rw [esymm, sum_filter_pairs_eq_sum_powersetCard_sum σ R k (fun t ↦ weight σ R k t),
  sum_congr rfl (esymm_summand_to_weight σ R k), mul_comm (k : MvPolynomial σ R) ((-1) ^ k),
  ← mul_sum, ← mul_assoc, ← mul_assoc, ← pow_add, Even.neg_one_pow ⟨k, rfl⟩, one_mul]
state_before: σ : Type u_1
inst✝² : Fintype σ
inst✝¹ : DecidableEq σ
R : Type u_2
inst✝ : CommRing R
k : ℕ
⊢ ↑k * esymm σ R k =
    (-1) ^ k *
      ∑ t ∈ filter (fun t => t.1.card = k) (MvPolynomial.NewtonIdentities.pairs σ k),
        MvPolynomial.NewtonIdentities.weight σ R k t
state_after: no goals
Theorem: Std.Range.mem_range'_elems
File: .lake/packages/batteries/Batteries/Data/Range/Lemmas.lean

tactic: obtain ⟨i, h', rfl⟩ := List.mem_range'.1 h
state_before: x : Nat
r : Range
h : x ∈ List.range' r.start r.numElems r.step
⊢ x ∈ r
state_after: case intro.intro
r : Range
i : Nat
h' : i < r.numElems
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
⊢ r.start + r.step * i ∈ r

tactic: refine ⟨Nat.le_add_right .., ?_⟩
state_before: case intro.intro
r : Range
i : Nat
h' : i < r.numElems
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
⊢ r.start + r.step * i ∈ r
state_after: case intro.intro
r : Range
i : Nat
h' : i < r.numElems
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
⊢ r.start + r.step * i < r.stop

tactic: unfold numElems at h'
state_before: case intro.intro
r : Range
i : Nat
h' : i < r.numElems
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
⊢ r.start + r.step * i < r.stop
state_after: case intro.intro
r : Range
i : Nat
h' : i < if r.step = 0 then if r.stop ≤ r.start then 0 else r.stop else (r.stop - r.start + r.step - 1) / r.step
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
⊢ r.start + r.step * i < r.stop

tactic: split at h'
state_before: case intro.intro
r : Range
i : Nat
h' : i < if r.step = 0 then if r.stop ≤ r.start then 0 else r.stop else (r.stop - r.start + r.step - 1) / r.step
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
⊢ r.start + r.step * i < r.stop
state_after: case intro.intro.isTrue
r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
h✝ : r.step = 0
h' : i < if r.stop ≤ r.start then 0 else r.stop
⊢ r.start + r.step * i < r.stop

case intro.intro.isFalse
r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
h✝ : ¬r.step = 0
h' : i < (r.stop - r.start + r.step - 1) / r.step
⊢ r.start + r.step * i < r.stop

tactic: split at h' <;> [cases h'; simp_all]
state_before: case intro.intro.isTrue
r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
h✝ : r.step = 0
h' : i < if r.stop ≤ r.start then 0 else r.stop
⊢ r.start + r.step * i < r.stop
state_after: no goals

tactic: next step0 =>
refine Nat.not_le.1 fun h =>
  Nat.not_le.2 h' <| (numElems_le_iff (Nat.pos_of_ne_zero step0)).2 h
state_before: case intro.intro.isFalse
r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
h✝ : ¬r.step = 0
h' : i < (r.stop - r.start + r.step - 1) / r.step
⊢ r.start + r.step * i < r.stop
state_after: no goals

tactic: refine Nat.not_le.1 fun h =>
  Nat.not_le.2 h' <| (numElems_le_iff (Nat.pos_of_ne_zero step0)).2 h
state_before: r : Range
i : Nat
h : r.start + r.step * i ∈ List.range' r.start r.numElems r.step
step0 : ¬r.step = 0
h' : i < (r.stop - r.start + r.step - 1) / r.step
⊢ r.start + r.step * i < r.stop
state_after: no goals
Theorem: Trivialization.mem_source
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [e.source_eq, mem_preimage]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x : Z
⊢ x ∈ e.source ↔ proj x ∈ e.baseSet
state_after: no goals
Theorem: Part.mod_get_eq
File: Mathlib/Data/Part.lean

tactic: simp [mod_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mod α
a b : Part α
hab : (a % b).Dom
⊢ (a % b).get hab = a.get ⋯ % b.get ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mod α
a b : Part α
hab : (a % b).Dom
⊢ (a.bind fun y => map (fun x => y % x) b).get ⋯ = a.get ⋯ % b.get ⋯

tactic: aesop
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Mod α
a b : Part α
hab : (a % b).Dom
⊢ (a.bind fun y => map (fun x => y % x) b).get ⋯ = a.get ⋯ % b.get ⋯
state_after: no goals
Theorem: Nat.lor_assoc
File: Mathlib/Data/Nat/Bitwise.lean

tactic: bitwise_assoc_tac
state_before: n m k : ℕ
⊢ n ||| m ||| k = n ||| (m ||| k)
state_after: no goals
Theorem: Batteries.BinomialHeap.Imp.Heap.WF.tail
File: .lake/packages/batteries/Batteries/Data/BinomialHeap/Basic.lean

tactic: simp only [Heap.tail]
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
hwf : WF le n s
⊢ WF le 0 (Heap.tail le s)
state_after: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
hwf : WF le n s
⊢ WF le 0 ((Heap.tail? le s).getD Heap.nil)

tactic: match eq : s.tail? le with
| none => exact Heap.WF.nil
| some tl => exact hwf.tail? eq
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
hwf : WF le n s
⊢ WF le 0 ((Heap.tail? le s).getD Heap.nil)
state_after: no goals

tactic: exact Heap.WF.nil
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
hwf : WF le n s
eq : Heap.tail? le s = none
⊢ WF le 0 (none.getD Heap.nil)
state_after: no goals

tactic: exact hwf.tail? eq
state_before: α : Type u_1
s : Heap α
le : α → α → Bool
n : Nat
hwf : WF le n s
tl : Heap α
eq : Heap.tail? le s = some tl
⊢ WF le 0 ((some tl).getD Heap.nil)
state_after: no goals
Theorem: CategoryTheory.Limits.Types.colimit_sound'
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: rw [← colimit.w _ f, ← colimit.w _ f']
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ colimit.ι F j x = colimit.ι F j' x'
state_after: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ (F.map f ≫ colimit.ι F j'') x = (F.map f' ≫ colimit.ι F j'') x'

tactic: rw [types_comp_apply, types_comp_apply, w]
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ (F.map f ≫ colimit.ι F j'') x = (F.map f' ≫ colimit.ι F j'') x'
state_after: no goals
Theorem: Ordinal.iterate_le_nfp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← sup_iterate_eq_nfp]
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
a : Ordinal.{u_1}
n : ℕ
⊢ f^[n] a ≤ nfp f a
state_after: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
a : Ordinal.{u_1}
n : ℕ
⊢ f^[n] a ≤ (fun a => sup fun n => f^[n] a) a

tactic: exact le_sup _ n
state_before: f✝ : Ordinal.{u} → Ordinal.{u}
f : Ordinal.{u_1} → Ordinal.{u_1}
a : Ordinal.{u_1}
n : ℕ
⊢ f^[n] a ≤ (fun a => sup fun n => f^[n] a) a
state_after: no goals
Theorem: Convex.combo_affine_apply
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: simp only [Convex.combo_eq_smul_sub_add h, ← vsub_eq_sub]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ f (a • x + b • y) = a • f x + b • f y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ f (b • (y -ᵥ x) + x) = b • (f y -ᵥ f x) + f x

tactic: exact f.apply_lineMap _ _ _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup E
inst✝² : AddCommGroup F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y : E
a b : 𝕜
f : E →ᵃ[𝕜] F
h : a + b = 1
⊢ f (b • (y -ᵥ x) + x) = b • (f y -ᵥ f x) + f x
state_after: no goals
Theorem: Filter.prod_atTop_atTop_eq
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: cases isEmpty_or_nonempty α
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
⊢ atTop ×ˢ atTop = atTop
state_after: case inl
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : IsEmpty α
⊢ atTop ×ˢ atTop = atTop

case inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : Nonempty α
⊢ atTop ×ˢ atTop = atTop

tactic: cases isEmpty_or_nonempty β
state_before: case inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : Nonempty α
⊢ atTop ×ˢ atTop = atTop
state_after: case inr.inl
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : IsEmpty β
⊢ atTop ×ˢ atTop = atTop

case inr.inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : Nonempty β
⊢ atTop ×ˢ atTop = atTop

tactic: simpa [atTop, prod_iInf_left, prod_iInf_right, iInf_prod] using iInf_comm
state_before: case inr.inr
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : Nonempty β
⊢ atTop ×ˢ atTop = atTop
state_after: no goals

tactic: exact Subsingleton.elim _ _
state_before: case inl
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : IsEmpty α
⊢ atTop ×ˢ atTop = atTop
state_after: no goals

tactic: exact Subsingleton.elim _ _
state_before: case inr.inl
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : IsEmpty β
⊢ atTop ×ˢ atTop = atTop
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.negY_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: linear_combination (norm := (rw [negY, Affine.negY]; ring1))
  -W.a₁ * P x / P z ^ 2 * div_self hPz - W.a₃ * div_self (pow_ne_zero 3 hPz)
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.negY P / P z ^ 3 = W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3)
state_after: no goals

tactic: rw [negY, Affine.negY]
state_before: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ W.negY P / P z ^ 3 - W.toAffine.negY (P x / P z ^ 2) (P y / P z ^ 3) -
      (-W.a₁ * P x / P z ^ 2 * (P z / P z) - W.a₃ * (P z ^ 3 / P z ^ 3) - (-W.a₁ * P x / P z ^ 2 * 1 - W.a₃ * 1)) =
    0
state_after: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (-P y - W.a₁ * P x * P z - W.a₃ * P z ^ 3) / P z ^ 3 -
        (-(P y / P z ^ 3) - W.toAffine.a₁ * (P x / P z ^ 2) - W.toAffine.a₃) -
      (-W.a₁ * P x / P z ^ 2 * (P z / P z) - W.a₃ * (P z ^ 3 / P z ^ 3) - (-W.a₁ * P x / P z ^ 2 * 1 - W.a₃ * 1)) =
    0

tactic: ring1
state_before: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (-P y - W.a₁ * P x * P z - W.a₃ * P z ^ 3) / P z ^ 3 -
        (-(P y / P z ^ 3) - W.toAffine.a₁ * (P x / P z ^ 2) - W.toAffine.a₃) -
      (-W.a₁ * P x / P z ^ 2 * (P z / P z) - W.a₃ * (P z ^ 3 / P z ^ 3) - (-W.a₁ * P x / P z ^ 2 * 1 - W.a₃ * 1)) =
    0
state_after: no goals
Theorem: mul_eq_one_iff_eq_inv
File: Mathlib/Algebra/Group/Basic.lean

tactic: rw [h, mul_left_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a = b⁻¹
⊢ a * b = 1
state_after: no goals
Theorem: Real.rpow_two
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← rpow_natCast]
state_before: x✝ y z : ℝ
n : ℕ
x : ℝ
⊢ x ^ 2 = x ^ 2
state_after: x✝ y z : ℝ
n : ℕ
x : ℝ
⊢ x ^ 2 = x ^ ↑2

tactic: simp only [Nat.cast_ofNat]
state_before: x✝ y z : ℝ
n : ℕ
x : ℝ
⊢ x ^ 2 = x ^ ↑2
state_after: no goals
Theorem: directedOn_range
File: Mathlib/Order/Directed.lean

tactic: simp_rw [Directed, DirectedOn, Set.forall_mem_range, Set.exists_range_iff]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s : α → α → Prop
f : ι → α
⊢ Directed r f ↔ DirectedOn r (Set.range f)
state_after: no goals