1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: tsub_nonpos
File: Mathlib/Algebra/Order/Sub/Defs.lean

tactic: rw [tsub_le_iff_left, add_zero]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : AddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b ≤ 0 ↔ a ≤ b
state_after: no goals
Theorem: CategoryTheory.Subobject.prod_eq_inf
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: apply le_antisymm
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) = f₁ ⊓ f₂
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) ≤ f₁ ⊓ f₂

case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ≤ (f₁ ⨯ f₂)

tactic: refine le_inf _ _ _ (Limits.prod.fst.le) (Limits.prod.snd.le)
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ (f₁ ⨯ f₂) ≤ f₁ ⊓ f₂
state_after: no goals

tactic: apply leOfHom
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ≤ (f₁ ⨯ f₂)
state_after: case a.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ⟶ f₁ ⨯ f₂

tactic: exact prod.lift (inf_le_left _ _).hom (inf_le_right _ _).hom
state_before: case a.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasPullbacks C
A : C
f₁ f₂ : Subobject A
inst✝ : HasBinaryProduct f₁ f₂
⊢ f₁ ⊓ f₂ ⟶ f₁ ⨯ f₂
state_after: no goals
Theorem: orderOf_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf, ← minimalPeriod_id (x := (1:G)), ← one_mul_eq_id]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
⊢ orderOf 1 = 1
state_after: no goals
Theorem: fderivWithin_zero_of_isolated
File: Mathlib/Analysis/Calculus/FDeriv/Basic.lean

tactic: rw [fderivWithin, if_pos h]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : 𝓝[s \ {x}] x = ⊥
⊢ fderivWithin 𝕜 f s x = 0
state_after: no goals
Theorem: List.tfae_cons_self
File: Mathlib/Data/List/TFAE.lean

tactic: simp [tfae_cons_cons]
state_before: a : Prop
l : List Prop
⊢ (a :: a :: l).TFAE ↔ (a :: l).TFAE
state_after: no goals
Theorem: Multiset.le_prod_nonempty_of_submultiplicative
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

tactic: simp [h_mul]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
hs_nonempty : s ≠ ∅
⊢ ∀ (a b : α), (fun x => True) a → (fun x => True) b → f (a * b) ≤ f a * f b
state_after: no goals

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
hs_nonempty : s ≠ ∅
⊢ ∀ (a b : α), (fun x => True) a → (fun x => True) b → (fun x => True) (a * b)
state_after: no goals

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : CommMonoid α
inst✝ : OrderedCommMonoid β
f : α → β
h_mul : ∀ (a b : α), f (a * b) ≤ f a * f b
s : Multiset α
hs_nonempty : s ≠ ∅
⊢ ∀ a ∈ s, (fun x => True) a
state_after: no goals
Theorem: coplanar_iff_finrank_le_two
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: have h : Coplanar k s ↔ Module.rank k (vectorSpan k s) ≤ 2 := Iff.rfl
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
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
⊢ Coplanar k s ↔ finrank k ↥(vectorSpan k s) ≤ 2
state_after: 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
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Coplanar k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 2
⊢ Coplanar k s ↔ finrank k ↥(vectorSpan k s) ≤ 2

tactic: rw [← finrank_eq_rank] at h
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
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Coplanar k s ↔ Module.rank k ↥(vectorSpan k s) ≤ 2
⊢ Coplanar k s ↔ finrank k ↥(vectorSpan k s) ≤ 2
state_after: 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
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Coplanar k s ↔ ↑(finrank k ↥(vectorSpan k s)) ≤ 2
⊢ Coplanar k s ↔ finrank k ↥(vectorSpan k s) ≤ 2

tactic: exact mod_cast h
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
s : Set P
inst✝ : FiniteDimensional k ↥(vectorSpan k s)
h : Coplanar k s ↔ ↑(finrank k ↥(vectorSpan k s)) ≤ 2
⊢ Coplanar k s ↔ finrank k ↥(vectorSpan k s) ≤ 2
state_after: no goals
Theorem: Function.LeftInverse.map_nhds_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: simpa only [nhdsWithin_univ, image_univ] using
  (h.leftInvOn univ).map_nhdsWithin_eq (h x) (by rwa [image_univ]) hg.continuousWithinAt
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → α
x : β
h : LeftInverse f g
hf : ContinuousWithinAt f (range g) (g x)
hg : ContinuousAt g x
⊢ map g (𝓝 x) = 𝓝[range g] g x
state_after: no goals

tactic: rwa [image_univ]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
g : β → α
x : β
h : LeftInverse f g
hf : ContinuousWithinAt f (range g) (g x)
hg : ContinuousAt g x
⊢ ContinuousWithinAt f (g '' univ) (g x)
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.dblX_smul
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: simp_rw [dblX, dblU_smul, negY_smul, smul_fin3_ext]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ W'.dblX (u • P) = (u ^ 4) ^ 2 * W'.dblX P
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ (u ^ 4 * W'.dblU P) ^ 2 - W'.a₁ * (u ^ 4 * W'.dblU P) * (u * P z) * (u ^ 3 * P y - u ^ 3 * W'.negY P) -
        W'.a₂ * (u * P z) ^ 2 * (u ^ 3 * P y - u ^ 3 * W'.negY P) ^ 2 -
      2 * (u ^ 2 * P x) * (u ^ 3 * P y - u ^ 3 * W'.negY P) ^ 2 =
    (u ^ 4) ^ 2 *
      (W'.dblU P ^ 2 - W'.a₁ * W'.dblU P * P z * (P y - W'.negY P) - W'.a₂ * P z ^ 2 * (P y - W'.negY P) ^ 2 -
        2 * P x * (P y - W'.negY P) ^ 2)

tactic: ring1
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
u : R
⊢ (u ^ 4 * W'.dblU P) ^ 2 - W'.a₁ * (u ^ 4 * W'.dblU P) * (u * P z) * (u ^ 3 * P y - u ^ 3 * W'.negY P) -
        W'.a₂ * (u * P z) ^ 2 * (u ^ 3 * P y - u ^ 3 * W'.negY P) ^ 2 -
      2 * (u ^ 2 * P x) * (u ^ 3 * P y - u ^ 3 * W'.negY P) ^ 2 =
    (u ^ 4) ^ 2 *
      (W'.dblU P ^ 2 - W'.a₁ * W'.dblU P * P z * (P y - W'.negY P) - W'.a₂ * P z ^ 2 * (P y - W'.negY P) ^ 2 -
        2 * P x * (P y - W'.negY P) ^ 2)
state_after: no goals
Theorem: supClosure_empty
File: Mathlib/Order/SupClosed.lean

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
s t : Set α
a b : α
⊢ supClosure ∅ = ∅
state_after: no goals
Theorem: Ordnode.dual_eraseMin
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [eraseMin, dual_balanceR, dual_eraseMin (node sz l' y r'), dual, dual, dual, eraseMax]
state_before: α : Type u_1
size✝ sz : ℕ
l' : Ordnode α
y : α
r' : Ordnode α
x : α
r : Ordnode α
⊢ (node size✝ (node sz l' y r') x r).eraseMin.dual = (node size✝ (node sz l' y r') x r).dual.eraseMax
state_after: no goals
Theorem: GeneralizedContinuedFraction.squashSeq_nth_of_not_terminated
File: Mathlib/Algebra/ContinuedFractions/ConvergentsEquiv.lean

tactic: simp [*, squashSeq]
state_before: K : Type u_1
n : ℕ
g : GeneralizedContinuedFraction K
s : Stream'.Seq (Pair K)
inst✝ : DivisionRing K
gp_n gp_succ_n : Pair K
s_nth_eq : s.get? n = some gp_n
s_succ_nth_eq : s.get? (n + 1) = some gp_succ_n
⊢ (squashSeq s n).get? n = some { a := gp_n.a, b := gp_n.b + gp_succ_n.a / gp_succ_n.b }
state_after: no goals
Theorem: PowerSeries.exp_pow_sum
File: Mathlib/RingTheory/PowerSeries/WellKnown.lean

tactic: simp only [exp_pow_eq_rescale_exp, rescale]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ Finset.range n, exp A ^ k = mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ Finset.range n,
      { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        (exp A) =
    mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹

tactic: ext
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ Finset.range n,
      { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        (exp A) =
    mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹
state_after: case h
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n n✝ : ℕ
⊢ (coeff A n✝)
      (∑ x ∈ Finset.range n,
        { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
            map_add' := ⋯ }
          (exp A)) =
    (coeff A n✝) (mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹)

tactic: simp only [one_div, coeff_mk, cast_pow, coe_mk, MonoidHom.coe_mk, OneHom.coe_mk,
  coeff_exp, factorial, map_sum]
state_before: case h
A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n n✝ : ℕ
⊢ (coeff A n✝)
      (∑ x ∈ Finset.range n,
        { toFun := fun f => mk fun n => ↑x ^ n * (coeff A n) f, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
            map_add' := ⋯ }
          (exp A)) =
    (coeff A n✝) (mk fun p => ∑ k ∈ Finset.range n, ↑k ^ p * (algebraMap ℚ A) (↑p !)⁻¹)
state_after: no goals
Theorem: SimpleGraph.isUniform_one
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: intro s' hs' t' ht' hs ht
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
⊢ G.IsUniform 1 s t
state_after: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑s.card * 1 ≤ ↑s'.card
ht : ↑t.card * 1 ≤ ↑t'.card
⊢ |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < 1

tactic: rw [mul_one] at hs ht
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑s.card * 1 ≤ ↑s'.card
ht : ↑t.card * 1 ≤ ↑t'.card
⊢ |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < 1
state_after: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑s.card ≤ ↑s'.card
ht : ↑t.card ≤ ↑t'.card
⊢ |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < 1

tactic: rw [eq_of_subset_of_card_le hs' (Nat.cast_le.1 hs),
  eq_of_subset_of_card_le ht' (Nat.cast_le.1 ht), sub_self, abs_zero]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑s.card ≤ ↑s'.card
ht : ↑t.card ≤ ↑t'.card
⊢ |↑(G.edgeDensity s' t') - ↑(G.edgeDensity s t)| < 1
state_after: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑s.card ≤ ↑s'.card
ht : ↑t.card ≤ ↑t'.card
⊢ 0 < 1

tactic: exact zero_lt_one
state_before: α : Type u_1
𝕜 : Type u_2
inst✝¹ : LinearOrderedField 𝕜
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
s t : Finset α
a b : α
s' : Finset α
hs' : s' ⊆ s
t' : Finset α
ht' : t' ⊆ t
hs : ↑s.card ≤ ↑s'.card
ht : ↑t.card ≤ ↑t'.card
⊢ 0 < 1
state_after: no goals
Theorem: AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.to_iso
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

tactic: suffices IsIso (LocallyRingedSpace.forgetToSheafedSpace.map f) from
  isIso_of_reflects_iso _ LocallyRingedSpace.forgetToSheafedSpace
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : LocallyRingedSpace
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.val.base
⊢ IsIso f
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : LocallyRingedSpace
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.val.base
⊢ IsIso (forgetToSheafedSpace.map f)

tactic: exact SheafedSpace.IsOpenImmersion.to_iso f.1
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : LocallyRingedSpace
f : X ⟶ Y
H : IsOpenImmersion f
h' : Epi f.val.base
⊢ IsIso (forgetToSheafedSpace.map f)
state_after: no goals
Theorem: EReal.image_coe_Ioc
File: Mathlib/Data/Real/EReal.lean

tactic: refine (image_comp WithBot.some WithTop.some _).trans ?_
state_before: x y : ℝ
⊢ Real.toEReal '' Ioc x y = Ioc ↑x ↑y
state_after: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Ioc x y) = Ioc ↑x ↑y

tactic: rw [WithTop.image_coe_Ioc, WithBot.image_coe_Ioc]
state_before: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Ioc x y) = Ioc ↑x ↑y
state_after: x y : ℝ
⊢ Ioc ↑↑x ↑↑y = Ioc ↑x ↑y

tactic: rfl
state_before: x y : ℝ
⊢ Ioc ↑↑x ↑↑y = Ioc ↑x ↑y
state_after: no goals
Theorem: PNat.XgcdType.flip_v
File: Mathlib/Data/PNat/Xgcd.lean

tactic: dsimp [v]
state_before: u : XgcdType
⊢ u.flip.v = u.v.swap
state_after: u : XgcdType
⊢ (↑u.z * ↑u.b + u.y * ↑u.a, u.x * ↑u.b + ↑u.w * ↑u.a) = (u.y * ↑u.a + ↑u.z * ↑u.b, ↑u.w * ↑u.a + u.x * ↑u.b)

tactic: ext
state_before: u : XgcdType
⊢ (↑u.z * ↑u.b + u.y * ↑u.a, u.x * ↑u.b + ↑u.w * ↑u.a) = (u.y * ↑u.a + ↑u.z * ↑u.b, ↑u.w * ↑u.a + u.x * ↑u.b)
state_after: case a
u : XgcdType
⊢ (↑u.z * ↑u.b + u.y * ↑u.a, u.x * ↑u.b + ↑u.w * ↑u.a).1 = (u.y * ↑u.a + ↑u.z * ↑u.b, ↑u.w * ↑u.a + u.x * ↑u.b).1

case a
u : XgcdType
⊢ (↑u.z * ↑u.b + u.y * ↑u.a, u.x * ↑u.b + ↑u.w * ↑u.a).2 = (u.y * ↑u.a + ↑u.z * ↑u.b, ↑u.w * ↑u.a + u.x * ↑u.b).2

tactic: simp only
state_before: case a
u : XgcdType
⊢ (↑u.z * ↑u.b + u.y * ↑u.a, u.x * ↑u.b + ↑u.w * ↑u.a).1 = (u.y * ↑u.a + ↑u.z * ↑u.b, ↑u.w * ↑u.a + u.x * ↑u.b).1
state_after: case a
u : XgcdType
⊢ ↑u.z * ↑u.b + u.y * ↑u.a = u.y * ↑u.a + ↑u.z * ↑u.b

tactic: ring
state_before: case a
u : XgcdType
⊢ ↑u.z * ↑u.b + u.y * ↑u.a = u.y * ↑u.a + ↑u.z * ↑u.b
state_after: no goals

tactic: simp only
state_before: case a
u : XgcdType
⊢ (↑u.z * ↑u.b + u.y * ↑u.a, u.x * ↑u.b + ↑u.w * ↑u.a).2 = (u.y * ↑u.a + ↑u.z * ↑u.b, ↑u.w * ↑u.a + u.x * ↑u.b).2
state_after: case a
u : XgcdType
⊢ u.x * ↑u.b + ↑u.w * ↑u.a = ↑u.w * ↑u.a + u.x * ↑u.b

tactic: ring
state_before: case a
u : XgcdType
⊢ u.x * ↑u.b + ↑u.w * ↑u.a = ↑u.w * ↑u.a + u.x * ↑u.b
state_after: no goals
Theorem: CategoryTheory.Functor.Monoidal.whiskerRight_app_snd
File: Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean

tactic: simp
state_before: J : Type u_1
C : Type u_2
inst✝² : Category.{u_3, u_1} J
inst✝¹ : Category.{u_4, u_2} C
inst✝ : ChosenFiniteProducts C
F₁ F₁' : J ⥤ C
f : F₁ ⟶ F₁'
F₂ : J ⥤ C
j : J
⊢ snd (F₁.obj j) (F₂.obj j) ≫ (𝟙 F₂).app j = snd (F₁.obj j) (F₂.obj j)
state_after: no goals
Theorem: Polynomial.normUnit_content
File: Mathlib/RingTheory/Polynomial/Content.lean

tactic: by_cases hp0 : p.content = 0
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
⊢ normUnit p.content = 1
state_after: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : p.content = 0
⊢ normUnit p.content = 1

case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ normUnit p.content = 1

tactic: simp [hp0]
state_before: case pos
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : p.content = 0
⊢ normUnit p.content = 1
state_after: no goals

tactic: ext
state_before: case neg
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ normUnit p.content = 1
state_after: case neg.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ ↑(normUnit p.content) = ↑1

tactic: apply mul_left_cancel₀ hp0
state_before: case neg.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ ↑(normUnit p.content) = ↑1
state_after: case neg.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ p.content * ↑(normUnit p.content) = p.content * ↑1

tactic: erw [← normalize_apply, normalize_content, mul_one]
state_before: case neg.a
R : Type u_1
inst✝² : CommRing R
inst✝¹ : IsDomain R
inst✝ : NormalizedGCDMonoid R
p : R[X]
hp0 : ¬p.content = 0
⊢ p.content * ↑(normUnit p.content) = p.content * ↑1
state_after: no goals
Theorem: Subgroup.coe_eq_singleton
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [hg]
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 H : Subgroup G
x✝ : ∃ g, ↑H = {g}
g : G
hg : ↑H = {g}
⊢ Subsingleton ↑↑H
state_after: 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 H : Subgroup G
x✝ : ∃ g, ↑H = {g}
g : G
hg : ↑H = {g}
⊢ Subsingleton ↑{g}

tactic: infer_instance
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 H : Subgroup G
x✝ : ∃ g, ↑H = {g}
g : G
hg : ↑H = {g}
⊢ Subsingleton ↑{g}
state_after: no goals
Theorem: LinearLocallyFiniteOrder.le_of_lt_succFn
File: Mathlib/Order/SuccPred/LinearLocallyFinite.lean

tactic: rw [lt_isGLB_iff (succFn_spec i)] at hij
state_before: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : j < succFn i
⊢ j ≤ i
state_after: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : ∃ c ∈ lowerBounds (Set.Ioi i), j < c
⊢ j ≤ i

tactic: obtain ⟨k, hk_lb, hk⟩ := hij
state_before: ι : Type u_1
inst✝ : LinearOrder ι
j i : ι
hij : ∃ c ∈ lowerBounds (Set.Ioi i), j < c
⊢ j ≤ i
state_after: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : k ∈ lowerBounds (Set.Ioi i)
hk : j < k
⊢ j ≤ i

tactic: rw [mem_lowerBounds] at hk_lb
state_before: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : k ∈ lowerBounds (Set.Ioi i)
hk : j < k
⊢ j ≤ i
state_after: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : ∀ x ∈ Set.Ioi i, k ≤ x
hk : j < k
⊢ j ≤ i

tactic: exact not_lt.mp fun hi_lt_j ↦ not_le.mpr hk (hk_lb j hi_lt_j)
state_before: case intro.intro
ι : Type u_1
inst✝ : LinearOrder ι
j i k : ι
hk_lb : ∀ x ∈ Set.Ioi i, k ≤ x
hk : j < k
⊢ j ≤ i
state_after: no goals
Theorem: Nat.bit_cases_on_injective
File: Mathlib/Data/Nat/Bits.lean

tactic: intro H₁ H₂ h
state_before: m n : ℕ
C : ℕ → Sort u
⊢ Function.Injective fun H n => n.bitCasesOn H
state_after: m n : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
⊢ H₁ = H₂

tactic: ext b n
state_before: m n : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
⊢ H₁ = H₂
state_after: case h.h
m n✝ : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
b : Bool
n : ℕ
⊢ H₁ b n = H₂ b n

tactic: simpa only [bitCasesOn_bit] using congr_fun h (bit b n)
state_before: case h.h
m n✝ : ℕ
C : ℕ → Sort u
H₁ H₂ : (b : Bool) → (n : ℕ) → C (bit b n)
h : (fun H n => n.bitCasesOn H) H₁ = (fun H n => n.bitCasesOn H) H₂
b : Bool
n : ℕ
⊢ H₁ b n = H₂ b n
state_after: no goals
Theorem: CategoryTheory.LocalizerMorphism.guitartExact_of_isRightDerivabilityStructure'
File: Mathlib/CategoryTheory/Localization/DerivabilityStructure/Basic.lean

tactic: simpa only [Φ.isRightDerivabilityStructure_iff L₁ L₂ F e] using h
state_before: C₁ : Type u₁
C₂ : Type u₂
inst✝⁵ : Category.{v₁, u₁} C₁
inst✝⁴ : Category.{v₂, u₂} C₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
Φ : LocalizerMorphism W₁ W₂
D₁ : Type u_1
D₂ : Type u_2
inst✝³ : Category.{u_4, u_1} D₁
inst✝² : Category.{u_3, u_2} D₂
L₁ : C₁ ⥤ D₁
L₂ : C₂ ⥤ D₂
inst✝¹ : L₁.IsLocalization W₁
inst✝ : L₂.IsLocalization W₂
F : D₁ ⥤ D₂
h : Φ.IsRightDerivabilityStructure
e : Φ.functor ⋙ L₂ ≅ L₁ ⋙ F
⊢ TwoSquare.GuitartExact e.hom
state_after: no goals
Theorem: lub_Iio_eq_self_or_Iio_eq_Iic
File: Mathlib/Order/Bounds/Basic.lean

tactic: cases' eq_or_lt_of_le (lub_Iio_le i hj) with hj_eq_i hj_lt_i
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
⊢ j = i ∨ Iio i = Iic j
state_after: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_eq_i : j = i
⊢ j = i ∨ Iio i = Iic j

case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ j = i ∨ Iio i = Iic j

tactic: exact Or.inl hj_eq_i
state_before: case inl
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_eq_i : j = i
⊢ j = i ∨ Iio i = Iic j
state_after: no goals

tactic: right
state_before: case inr
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ j = i ∨ Iio i = Iic j
state_after: case inr.h
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ Iio i = Iic j

tactic: exact Set.ext fun k => ⟨fun hk_lt => hj.1 hk_lt, fun hk_le_j => lt_of_le_of_lt hk_le_j hj_lt_i⟩
state_before: case inr.h
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s t : Set α
a b : α
inst✝ : PartialOrder γ
j i : γ
hj : IsLUB (Iio i) j
hj_lt_i : j < i
⊢ Iio i = Iic j
state_after: no goals