1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.RightHomologyData.homologyIso_hom_comp_rightHomologyIso_inv
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

tactic: dsimp only [homologyIso]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S.HasHomology
h : S.RightHomologyData
inst✝ : S.HasHomology
⊢ h.homologyIso.hom ≫ h.rightHomologyIso.inv = S.rightHomologyIso.inv
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S.HasHomology
h : S.RightHomologyData
inst✝ : S.HasHomology
⊢ (S.rightHomologyIso.symm ≪≫ h.rightHomologyIso).hom ≫ h.rightHomologyIso.inv = S.rightHomologyIso.inv

tactic: simp only [Iso.trans_hom, Iso.symm_hom, assoc, Iso.hom_inv_id, comp_id]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝¹ : S.HasHomology
h : S.RightHomologyData
inst✝ : S.HasHomology
⊢ (S.rightHomologyIso.symm ≪≫ h.rightHomologyIso).hom ≫ h.rightHomologyIso.inv = S.rightHomologyIso.inv
state_after: no goals
Theorem: pow_right_injective
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: obtain ha₁ | ha₁ := ha₁.lt_or_lt
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha₀ : 0 < a
ha₁ : a ≠ 1
⊢ Injective fun x => a ^ x
state_after: case inl
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha₀ : 0 < a
ha₁✝ : a ≠ 1
ha₁ : a < 1
⊢ Injective fun x => a ^ x

case inr
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha₀ : 0 < a
ha₁✝ : a ≠ 1
ha₁ : 1 < a
⊢ Injective fun x => a ^ x

tactic: exact (pow_right_strictAnti ha₀ ha₁).injective
state_before: case inl
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha₀ : 0 < a
ha₁✝ : a ≠ 1
ha₁ : a < 1
⊢ Injective fun x => a ^ x
state_after: no goals

tactic: exact (pow_right_strictMono ha₁).injective
state_before: case inr
α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha₀ : 0 < a
ha₁✝ : a ≠ 1
ha₁ : 1 < a
⊢ Injective fun x => a ^ x
state_after: no goals
Theorem: Composition.eq_ones_iff
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: constructor
state_before: n : ℕ
c✝ c : Composition n
⊢ c = ones n ↔ ∀ i ∈ c.blocks, i = 1
state_after: case mp
n : ℕ
c✝ c : Composition n
⊢ c = ones n → ∀ i ∈ c.blocks, i = 1

case mpr
n : ℕ
c✝ c : Composition n
⊢ (∀ i ∈ c.blocks, i = 1) → c = ones n

tactic: rintro rfl
state_before: case mp
n : ℕ
c✝ c : Composition n
⊢ c = ones n → ∀ i ∈ c.blocks, i = 1
state_after: case mp
n : ℕ
c : Composition n
⊢ ∀ i ∈ (ones n).blocks, i = 1

tactic: exact fun i => eq_of_mem_replicate
state_before: case mp
n : ℕ
c : Composition n
⊢ ∀ i ∈ (ones n).blocks, i = 1
state_after: no goals

tactic: intro H
state_before: case mpr
n : ℕ
c✝ c : Composition n
⊢ (∀ i ∈ c.blocks, i = 1) → c = ones n
state_after: case mpr
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
⊢ c = ones n

tactic: ext1
state_before: case mpr
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
⊢ c = ones n
state_after: case mpr.blocks
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
⊢ c.blocks = (ones n).blocks

tactic: have A : c.blocks = replicate c.blocks.length 1 := eq_replicate_of_mem H
state_before: case mpr.blocks
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
⊢ c.blocks = (ones n).blocks
state_after: case mpr.blocks
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
⊢ c.blocks = (ones n).blocks

tactic: have : c.blocks.length = n := by
  conv_rhs => rw [← c.blocks_sum, A]
  simp
state_before: case mpr.blocks
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
⊢ c.blocks = (ones n).blocks
state_after: case mpr.blocks
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
this : c.blocks.length = n
⊢ c.blocks = (ones n).blocks

tactic: rw [A, this, ones_blocks]
state_before: case mpr.blocks
n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
this : c.blocks.length = n
⊢ c.blocks = (ones n).blocks
state_after: no goals

tactic: conv_rhs => rw [← c.blocks_sum, A]
state_before: n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
⊢ c.blocks.length = n
state_after: n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
⊢ c.blocks.length = (replicate c.blocks.length 1).sum

tactic: simp
state_before: n : ℕ
c✝ c : Composition n
H : ∀ i ∈ c.blocks, i = 1
A : c.blocks = replicate c.blocks.length 1
⊢ c.blocks.length = (replicate c.blocks.length 1).sum
state_after: no goals
Theorem: Real.exp_arsinh
File: Mathlib/Analysis/SpecialFunctions/Arsinh.lean

tactic: apply exp_log
state_before: x✝ y x : ℝ
⊢ rexp (arsinh x) = x + √(1 + x ^ 2)
state_after: case hx
x✝ y x : ℝ
⊢ 0 < x + √(1 + x ^ 2)

tactic: rw [← neg_lt_iff_pos_add']
state_before: case hx
x✝ y x : ℝ
⊢ 0 < x + √(1 + x ^ 2)
state_after: case hx
x✝ y x : ℝ
⊢ -x < √(1 + x ^ 2)

tactic: apply lt_sqrt_of_sq_lt
state_before: case hx
x✝ y x : ℝ
⊢ -x < √(1 + x ^ 2)
state_after: case hx.h
x✝ y x : ℝ
⊢ (-x) ^ 2 < 1 + x ^ 2

tactic: simp
state_before: case hx.h
x✝ y x : ℝ
⊢ (-x) ^ 2 < 1 + x ^ 2
state_after: no goals
Theorem: Batteries.RBNode.insert_setBlack
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

tactic: unfold insert
state_before: α : Type u_1
cmp : α → α → Ordering
v : α
t : RBNode α
⊢ (insert cmp t v).setBlack = (ins cmp v t).setBlack
state_after: α : Type u_1
cmp : α → α → Ordering
v : α
t : RBNode α
⊢ (match t.isRed with
      | red => (ins cmp v t).setBlack
      | black => ins cmp v t).setBlack =
    (ins cmp v t).setBlack

tactic: split <;> simp [setBlack_idem]
state_before: α : Type u_1
cmp : α → α → Ordering
v : α
t : RBNode α
⊢ (match t.isRed with
      | red => (ins cmp v t).setBlack
      | black => ins cmp v t).setBlack =
    (ins cmp v t).setBlack
state_after: no goals
Theorem: SetTheory.PGame.numeric_def
File: Mathlib/SetTheory/Surreal/Basic.lean

tactic: cases x
state_before: x : PGame
⊢ x.Numeric ↔
    (∀ (i : x.LeftMoves) (j : x.RightMoves), x.moveLeft i < x.moveRight j) ∧
      (∀ (i : x.LeftMoves), (x.moveLeft i).Numeric) ∧ ∀ (j : x.RightMoves), (x.moveRight j).Numeric
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝).Numeric ↔
    (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves) (j : (mk α✝ β✝ a✝¹ a✝).RightMoves),
        (mk α✝ β✝ a✝¹ a✝).moveLeft i < (mk α✝ β✝ a✝¹ a✝).moveRight j) ∧
      (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves), ((mk α✝ β✝ a✝¹ a✝).moveLeft i).Numeric) ∧
        ∀ (j : (mk α✝ β✝ a✝¹ a✝).RightMoves), ((mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric

tactic: rfl
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
⊢ (mk α✝ β✝ a✝¹ a✝).Numeric ↔
    (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves) (j : (mk α✝ β✝ a✝¹ a✝).RightMoves),
        (mk α✝ β✝ a✝¹ a✝).moveLeft i < (mk α✝ β✝ a✝¹ a✝).moveRight j) ∧
      (∀ (i : (mk α✝ β✝ a✝¹ a✝).LeftMoves), ((mk α✝ β✝ a✝¹ a✝).moveLeft i).Numeric) ∧
        ∀ (j : (mk α✝ β✝ a✝¹ a✝).RightMoves), ((mk α✝ β✝ a✝¹ a✝).moveRight j).Numeric
state_after: no goals
Theorem: DFinsupp.sum_inner
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp (config := { contextual := true }) only [DFinsupp.sum, _root_.sum_inner, smul_eq_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁷ : _root_.RCLike 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
ι : Type u_4
inst✝² : DecidableEq ι
α : ι → Type u_5
inst✝¹ : (i : ι) → AddZeroClass (α i)
inst✝ : (i : ι) → (x : α i) → Decidable (x ≠ 0)
f : (i : ι) → α i → E
l : Π₀ (i : ι), α i
x : E
⊢ ⟪l.sum f, x⟫_𝕜 = l.sum fun i a => ⟪f i a, x⟫_𝕜
state_after: no goals
Theorem: List.sublist_suffix_of_union
File: Mathlib/Data/List/Lattice.lean

tactic: rfl
state_before: α : Type u_1
l l₁ l₂✝ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l₂ : List α
⊢ [] <+ []
state_after: no goals

tactic: simp only [e, cons_union, insert_of_mem h]
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ l₂ t : List α
s : t <+ l₁
e : t ++ l₂ = l₁ ∪ l₂
h : a ∈ l₁ ∪ l₂
⊢ t ++ l₂ = a :: l₁ ∪ l₂
state_after: no goals

tactic: simp only [cons_append, cons_union, e, insert_of_not_mem h]
state_before: α : Type u_1
l l₁✝ l₂✝ : List α
p : α → Prop
a✝ : α
inst✝ : DecidableEq α
a : α
l₁ l₂ t : List α
s : t <+ l₁
e : t ++ l₂ = l₁ ∪ l₂
h : ¬a ∈ l₁ ∪ l₂
⊢ a :: t ++ l₂ = a :: l₁ ∪ l₂
state_after: no goals
Theorem: Disjoint.le_symmDiff_sup_symmDiff_left
File: Mathlib/Order/SymmDiff.lean

tactic: trans c \ (a ⊓ b)
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c ≤ a ∆ c ⊔ b ∆ c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c ≤ c \ (a ⊓ b)

ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c \ (a ⊓ b) ≤ a ∆ c ⊔ b ∆ c

tactic: rw [h.eq_bot, sdiff_bot]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c ≤ c \ (a ⊓ b)
state_after: no goals

tactic: rw [sdiff_inf]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c \ (a ⊓ b) ≤ a ∆ c ⊔ b ∆ c
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c \ a ⊔ c \ b ≤ a ∆ c ⊔ b ∆ c

tactic: exact sup_le_sup le_sup_right le_sup_right
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : BooleanAlgebra α
a b c d : α
h : Disjoint a b
⊢ c \ a ⊔ c \ b ≤ a ∆ c ⊔ b ∆ c
state_after: no goals
Theorem: Span.finsupp_total_repr
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [Span.repr_def]
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
w : Set M
x : ↥(span R w)
⊢ (Finsupp.total (↑w) M R Subtype.val) (repr R w x) = ↑x
state_after: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
w : Set M
x : ↥(span R w)
⊢ (Finsupp.total (↑w) M R Subtype.val) ⋯.choose = ↑x

tactic: exact ((Finsupp.mem_span_iff_total _ _ _).mp x.2).choose_spec
state_before: R : Type u_1
M : Type u_2
N : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid N
inst✝ : Module R N
w : Set M
x : ↥(span R w)
⊢ (Finsupp.total (↑w) M R Subtype.val) ⋯.choose = ↑x
state_after: no goals
Theorem: Matrix.exp_conj
File: Mathlib/Analysis/NormedSpace/MatrixExponential.lean

tactic: simpa only [Matrix.coe_units_inv] using exp_units_conj 𝕂 u A
state_before: 𝕂 : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
n' : m → Type u_5
𝔸 : Type u_6
inst✝⁹ : RCLike 𝕂
inst✝⁸ : Fintype m
inst✝⁷ : DecidableEq m
inst✝⁶ : Fintype n
inst✝⁵ : DecidableEq n
inst✝⁴ : (i : m) → Fintype (n' i)
inst✝³ : (i : m) → DecidableEq (n' i)
inst✝² : NormedCommRing 𝔸
inst✝¹ : NormedAlgebra 𝕂 𝔸
inst✝ : CompleteSpace 𝔸
U A : Matrix m m 𝔸
hy : IsUnit U
u : (Matrix m m 𝔸)ˣ
hu : ↑u = U
⊢ exp 𝕂 (↑u * A * (↑u)⁻¹) = ↑u * exp 𝕂 A * (↑u)⁻¹
state_after: no goals
Theorem: Finset.Nat.antidiagonal_succ'
File: Mathlib/Data/Finset/NatAntidiagonal.lean

tactic: simp
state_before: n : ℕ
⊢ (n + 1, 0) ∉ map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)
state_after: no goals

tactic: apply eq_of_veq
state_before: n : ℕ
⊢ antidiagonal (n + 1) =
    cons (n + 1, 0)
      (map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)) ⋯
state_after: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (cons (n + 1, 0)
        (map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)) ⋯).val

tactic: rw [cons_val, map_val]
state_before: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (cons (n + 1, 0)
        (map ((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }) (antidiagonal n)) ⋯).val
state_after: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (n + 1, 0) ::ₘ
      Multiset.map (⇑((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }))
        (antidiagonal n).val

tactic: exact Multiset.Nat.antidiagonal_succ'
state_before: case a
n : ℕ
⊢ (antidiagonal (n + 1)).val =
    (n + 1, 0) ::ₘ
      Multiset.map (⇑((Embedding.refl ℕ).prodMap { toFun := Nat.succ, inj' := Nat.succ_injective }))
        (antidiagonal n).val
state_after: no goals
Theorem: AddCircle.ergodic_nsmul
File: Mathlib/Dynamics/Ergodic/AddCircle.lean

tactic: simp [hn]
state_before: T : ℝ
hT : Fact (0 < T)
n : ℕ
hn : 1 < n
⊢ 1 < |↑n|
state_after: no goals
Theorem: Finset.sup_le_iff
File: Mathlib/Data/Finset/Lattice.lean

tactic: apply Iff.trans Multiset.sup_le
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ s.sup f ≤ a ↔ ∀ b ∈ s, f b ≤ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ b ∈ Multiset.map f s.val, b ≤ a) ↔ ∀ b ∈ s, f b ≤ a

tactic: simp only [Multiset.mem_map, and_imp, exists_imp]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ b ∈ Multiset.map f s.val, b ≤ a) ↔ ∀ b ∈ s, f b ≤ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ (b : α), ∀ x ∈ s.val, f x = b → b ≤ a) ↔ ∀ b ∈ s, f b ≤ a

tactic: exact ⟨fun k b hb => k _ _ hb rfl, fun k a' b hb h => h ▸ k _ hb⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f g : β → α
a✝ a : α
⊢ (∀ (b : α), ∀ x ∈ s.val, f x = b → b ≤ a) ↔ ∀ b ∈ s, f b ≤ a
state_after: no goals
Theorem: LieModule.injOn_weightSpace
File: Mathlib/Algebra/Lie/Weights/Basic.lean

tactic: rintro χ₁ _ χ₂ hχ₂ (hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂)
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
⊢ InjOn (fun χ => weightSpace M χ) {χ | weightSpace M χ ≠ ⊥}
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₂ : χ₂ ∈ {χ | weightSpace M χ ≠ ⊥}
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
⊢ χ₁ = χ₂

tactic: contrapose! hχ₂
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₂ : χ₂ ∈ {χ | weightSpace M χ ≠ ⊥}
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
⊢ χ₁ = χ₂
state_after: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
hχ₂ : χ₁ ≠ χ₂
⊢ χ₂ ∉ {χ | weightSpace M χ ≠ ⊥}

tactic: simpa [hχ₁₂] using disjoint_weightSpace R L M hχ₂
state_before: K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : NoZeroSMulDivisors R M
χ₁ : L → R
a✝ : χ₁ ∈ {χ | weightSpace M χ ≠ ⊥}
χ₂ : L → R
hχ₁₂ : weightSpace M χ₁ = weightSpace M χ₂
hχ₂ : χ₁ ≠ χ₂
⊢ χ₂ ∉ {χ | weightSpace M χ ≠ ⊥}
state_after: no goals
Theorem: AlternatingMap.map_basis_eq_zero_iff
File: Mathlib/LinearAlgebra/Determinant.lean

tactic: cases nonempty_fintype ι
state_before: R : Type u_1
inst✝⁷ : CommRing R
M : Type u_2
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type u_3
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type u_4
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_5
inst✝ : Finite ι
e : Basis ι R M
f : M [⋀^ι]→ₗ[R] R
h : f ⇑e = 0
⊢ f = 0
state_after: case intro
R : Type u_1
inst✝⁷ : CommRing R
M : Type u_2
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type u_3
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type u_4
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_5
inst✝ : Finite ι
e : Basis ι R M
f : M [⋀^ι]→ₗ[R] R
h : f ⇑e = 0
val✝ : Fintype ι
⊢ f = 0

tactic: letI := Classical.decEq ι
state_before: case intro
R : Type u_1
inst✝⁷ : CommRing R
M : Type u_2
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type u_3
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type u_4
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_5
inst✝ : Finite ι
e : Basis ι R M
f : M [⋀^ι]→ₗ[R] R
h : f ⇑e = 0
val✝ : Fintype ι
⊢ f = 0
state_after: case intro
R : Type u_1
inst✝⁷ : CommRing R
M : Type u_2
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type u_3
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type u_4
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_5
inst✝ : Finite ι
e : Basis ι R M
f : M [⋀^ι]→ₗ[R] R
h : f ⇑e = 0
val✝ : Fintype ι
this : DecidableEq ι := Classical.decEq ι
⊢ f = 0

tactic: simpa [h] using f.eq_smul_basis_det e
state_before: case intro
R : Type u_1
inst✝⁷ : CommRing R
M : Type u_2
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
M' : Type u_3
inst✝⁴ : AddCommGroup M'
inst✝³ : Module R M'
ι✝ : Type u_4
inst✝² : DecidableEq ι✝
inst✝¹ : Fintype ι✝
e✝ : Basis ι✝ R M
ι : Type u_5
inst✝ : Finite ι
e : Basis ι R M
f : M [⋀^ι]→ₗ[R] R
h : f ⇑e = 0
val✝ : Fintype ι
this : DecidableEq ι := Classical.decEq ι
⊢ f = 0
state_after: no goals
Theorem: ZNum.add_le_add_left
File: Mathlib/Data/Num/Lemmas.lean

tactic: intro a b h c
state_before: α : Type u_1
⊢ ∀ (a b : ZNum), a ≤ b → ∀ (c : ZNum), c + a ≤ c + b
state_after: α : Type u_1
a b : ZNum
h : a ≤ b
c : ZNum
⊢ c + a ≤ c + b

tactic: revert h
state_before: α : Type u_1
a b : ZNum
h : a ≤ b
c : ZNum
⊢ c + a ≤ c + b
state_after: α : Type u_1
a b c : ZNum
⊢ a ≤ b → c + a ≤ c + b

tactic: transfer_rw
state_before: α : Type u_1
a b c : ZNum
⊢ a ≤ b → c + a ≤ c + b
state_after: α : Type u_1
a b c : ZNum
⊢ ↑a ≤ ↑b → ↑c + ↑a ≤ ↑c + ↑b

tactic: exact fun h => _root_.add_le_add_left h c
state_before: α : Type u_1
a b c : ZNum
⊢ ↑a ≤ ↑b → ↑c + ↑a ≤ ↑c + ↑b
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.add_of_Y_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [add, if_pos <| equiv_of_X_eq_of_Y_eq hPz hQz hx hy, dblXYZ_of_Y_eq hQz hx hy hy']
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
hy : P y * Q z ^ 3 = Q y * P z ^ 3
hy' : P y * Q z ^ 3 = W.negY Q * P z ^ 3
⊢ W.add P Q = W.dblU P • ![1, 1, 0]
state_after: no goals
Theorem: OnePoint.not_mem_range_coe_iff
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: rw [← mem_compl_iff, compl_range_coe, mem_singleton_iff]
state_before: X : Type u_1
x : OnePoint X
⊢ x ∉ range some ↔ x = ∞
state_after: no goals
Theorem: PartialEquiv.IsImage.inter_eq_of_inter_eq_of_eqOn
File: Mathlib/Logic/Equiv/PartialEquiv.lean

tactic: rw [← h.image_eq, ← h'.image_eq, ← hs, heq.image_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
e : PartialEquiv α β
e'✝ : PartialEquiv β γ
s : Set α
t : Set β
x : α
y : β
e' : PartialEquiv α β
h : e.IsImage s t
h' : e'.IsImage s t
hs : e.source ∩ s = e'.source ∩ s
heq : EqOn (↑e) (↑e') (e.source ∩ s)
⊢ e.target ∩ t = e'.target ∩ t
state_after: no goals
Theorem: HolderWith.nndist_le_of_le
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: rw [← ENNReal.coe_le_coe, ← edist_nndist, ENNReal.coe_mul, ←
  ENNReal.coe_rpow_of_nonneg _ r.coe_nonneg]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ nndist (f x) (f y) ≤ C * d ^ ↑r
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ edist (f x) (f y) ≤ ↑C * ↑d ^ ↑r

tactic: apply hf.edist_le_of_le
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ edist (f x) (f y) ≤ ↑C * ↑d ^ ↑r
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ edist x y ≤ ↑d

tactic: rwa [edist_nndist, ENNReal.coe_le_coe]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ edist x y ≤ ↑d
state_after: no goals
Theorem: finrank_ulift
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

tactic: simp_rw [finrank, rank_ulift, toNat_lift]
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁷ : Ring R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M₁
⊢ finrank R (ULift.{u_2, v} M) = finrank R M
state_after: no goals