ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CochainComplex.mappingConeCompHomotopyEquiv_comm₂
File: Mathlib/Algebra/Homology/HomotopyCategory/Triangulated.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
⊢ (mappingConeCompHomotopyEquiv f g).hom ≫ (triangle (mappingConeCompTriangle f g).mor₁).mor₃ =
    (mappingConeCompTriangle f g).mor₃
state_after: case h
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
n : ℤ
⊢ ((mappingConeCompHomotopyEquiv f g).hom ≫ (triangle (mappingConeCompTriangle f g).mor₁).mor₃).f n =
    (mappingConeCompTriangle f g).mor₃.f n
tactic: ext n
state_before: case h
C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
n : ℤ
⊢ ((mappingConeCompHomotopyEquiv f g).hom ≫ (triangle (mappingConeCompTriangle f g).mor₁).mor₃).f n =
    (mappingConeCompTriangle f g).mor₃.f n
state_after: no goals
tactic: simp [map, mappingConeCompHomotopyEquiv, MappingConeCompHomotopyEquiv.hom,
    lift_f _ _ _ _ _ (n+1) rfl, ext_from_iff _ (n+1) _ rfl]
Theorem: toIcoDiv_eq_sub
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIcoDiv hp a b = toIcoDiv hp 0 (b - a)
state_after: no goals
tactic: rw [toIcoDiv_sub_eq_toIcoDiv_add, zero_add]
Theorem: CategoryTheory.Square.opFunctor_obj
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₁₂ ≫ φ.unop.τ₂.op).unop =
    (φ.unop.τ₄.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₁₂).unop
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₁₃ ≫ φ.unop.τ₃.op).unop =
    (φ.unop.τ₄.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₁₃).unop
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₂₄ ≫ φ.unop.τ₁.op).unop =
    (φ.unop.τ₂.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₂₄).unop
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : (Square C)ᵒᵖ
φ : X✝ ⟶ Y✝
⊢ (((fun sq => (Opposite.unop sq).op) X✝).f₃₄ ≫ φ.unop.τ₁.op).unop =
    (φ.unop.τ₃.op ≫ ((fun sq => (Opposite.unop sq).op) Y✝).f₃₄).unop
state_after: no goals
tactic: simp
Theorem: List.length_inits
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.inits.length = l.length + 1
state_after: no goals
tactic: simp [inits_eq_tails]
Theorem: Language.kstar_eq_iSup_pow
File: Mathlib/Computability/Language.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x : List α
l : Language α
⊢ l∗ = ⨆ i, l ^ i
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x✝ : List α
l : Language α
x : List α
⊢ x ∈ l∗ ↔ x ∈ ⨆ i, l ^ i
tactic: ext x
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x✝ : List α
l : Language α
x : List α
⊢ x ∈ l∗ ↔ x ∈ ⨆ i, l ^ i
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x✝ : List α
l : Language α
x : List α
⊢ (∃ L, x = L.join ∧ ∀ y ∈ L, y ∈ l) ↔ ∃ i S, x = S.join ∧ S.length = i ∧ ∀ y ∈ S, y ∈ l
tactic: simp only [mem_kstar, mem_iSup, mem_pow]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x✝ : List α
l : Language α
x : List α
⊢ (∃ L, x = L.join ∧ ∀ y ∈ L, y ∈ l) ↔ ∃ i S, x = S.join ∧ S.length = i ∧ ∀ y ∈ S, y ∈ l
state_after: case h.mp
α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x✝ : List α
l : Language α
x : List α
⊢ (∃ L, x = L.join ∧ ∀ y ∈ L, y ∈ l) → ∃ i S, x = S.join ∧ S.length = i ∧ ∀ y ∈ S, y ∈ l

case h.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
l✝ m : Language α
a b x✝ : List α
l : Language α
x : List α
⊢ (∃ i S, x = S.join ∧ S.length = i ∧ ∀ y ∈ S, y ∈ l) → ∃ L, x = L.join ∧ ∀ y ∈ L, y ∈ l
tactic: constructor
Theorem: Int.natAbs_lt_iff_sq_lt
File: Mathlib/Data/Int/Lemmas.lean

Proof steps:
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ a.natAbs < b.natAbs ↔ a ^ 2 < b ^ 2
state_after: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ a.natAbs < b.natAbs ↔ a * a < b * b
tactic: rw [sq, sq]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
⊢ a.natAbs < b.natAbs ↔ a * a < b * b
state_after: no goals
tactic: exact natAbs_lt_iff_mul_self_lt
Theorem: Finset.Ico_filter_le
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ a b c : α
⊢ filter (fun x => c ≤ x) (Ico a b) = Ico (max a c) b
state_after: no goals
tactic: cases le_total a c with
  | inl h => rw [Ico_filter_le_of_left_le h, max_eq_right h]
  | inr h => rw [Ico_filter_le_of_le_left h, max_eq_left h]
Theorem: Finset.card_compl_add_card
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : DecidableEq α
inst✝ : Fintype α
s : Finset α
⊢ sᶜ.card + s.card = Fintype.card α
state_after: no goals
tactic: rw [add_comm, card_add_card_compl]
Theorem: AddCommMonoid.primaryComponent.exists_orderOf_eq_prime_nsmul
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝ : CommMonoid G
p : ℕ
hp : Fact (Nat.Prime p)
g : ↥(primaryComponent G p)
⊢ ∃ n, orderOf g = p ^ n
state_after: no goals
tactic: simpa [primaryComponent] using g.property
Theorem: CategoryTheory.Limits.HasBiproduct.of_hasProduct
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
J : Type
inst✝¹ : Finite J
f : J → C
inst✝ : HasProduct f
⊢ HasBiproduct f
state_after: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
J : Type
inst✝¹ : Finite J
f : J → C
inst✝ : HasProduct f
val✝ : Fintype J
⊢ HasBiproduct f
tactic: cases nonempty_fintype J
state_before: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
J : Type
inst✝¹ : Finite J
f : J → C
inst✝ : HasProduct f
val✝ : Fintype J
⊢ HasBiproduct f
state_after: no goals
tactic: exact HasBiproduct.mk
    { bicone := _
      isBilimit := biconeIsBilimitOfLimitConeOfIsLimit (limit.isLimit _) }
Theorem: Zsqrtd.gcd_eq_zero_iff
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℤ
a : ℤ√d
⊢ a.re.gcd a.im = 0 ↔ a = 0
state_after: no goals
tactic: simp only [Int.gcd_eq_zero_iff, Zsqrtd.ext_iff, eq_self_iff_true, zero_im, zero_re]
Theorem: Multiset.coe_mem
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
x : m.ToType
⊢ 0 < count x.fst m
state_after: α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
x : m.ToType
this : ↑x.snd < count x.fst m
⊢ 0 < count x.fst m
tactic: have := x.2.2
state_before: α : Type u_1
inst✝ : DecidableEq α
m : Multiset α
x : m.ToType
this : ↑x.snd < count x.fst m
⊢ 0 < count x.fst m
state_after: no goals
tactic: omega
Theorem: Finset.piecewise_erase_univ
File: Mathlib/Data/Finset/Piecewise.lean

Proof steps:
state_before: ι : Type u_1
π : ι → Sort u_2
s : Finset ι
f✝ g✝ : (i : ι) → π i
inst✝² : (j : ι) → Decidable (j ∈ s)
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
i : ι
f g : (i : ι) → π i
⊢ (univ.erase i).piecewise f g = update f i (g i)
state_after: no goals
tactic: rw [← compl_singleton, piecewise_compl, piecewise_singleton]
Theorem: Ordnode.Bounded.dual
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Preorder α
o₁ : WithBot α
o₂ : WithTop α
h : nil.Bounded o₁ o₂
⊢ nil.dual.Bounded o₂ o₁
state_after: no goals
tactic: cases o₁ <;> cases o₂ <;> trivial
Theorem: Units.mul_inv_eq_iff_eq_mul
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c✝ u : αˣ
a c : α
h : a * ↑b⁻¹ = c
⊢ a = c * ↑b
state_after: no goals
tactic: rw [← h, inv_mul_cancel_right]
state_before: α : Type u
inst✝ : Monoid α
a✝ b c✝ u : αˣ
a c : α
h : a = c * ↑b
⊢ a * ↑b⁻¹ = c
state_after: no goals
tactic: rw [h, mul_inv_cancel_right]
Theorem: IsTorsionFree.not_torsion
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝ : Group G
hN : Nontrivial G
tfG : IsTorsionFree G
⊢ ∃ g, ¬IsOfFinOrder g
state_after: case intro
G : Type u_1
H : Type u_2
inst✝ : Group G
hN : Nontrivial G
tfG : IsTorsionFree G
x : G
hx : x ≠ 1
⊢ ∃ g, ¬IsOfFinOrder g
tactic: obtain ⟨x, hx⟩ := (nontrivial_iff_exists_ne (1 : G)).mp hN
state_before: case intro
G : Type u_1
H : Type u_2
inst✝ : Group G
hN : Nontrivial G
tfG : IsTorsionFree G
x : G
hx : x ≠ 1
⊢ ∃ g, ¬IsOfFinOrder g
state_after: no goals
tactic: exact ⟨x, (tfG x) hx⟩
Theorem: Mathlib.Tactic.RingNF.mul_neg
File: Mathlib/Tactic/Ring/RingNF.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹ : CommSemiring R✝
n d : ℕ
R : Type u_2
inst✝ : Ring R
a b : R
⊢ a * -b = -(a * b)
state_after: no goals
tactic: simp
Theorem: DFinsupp.lsum_single
File: Mathlib/LinearAlgebra/DFinsupp.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
M : ι → Type u_4
N : Type u_5
inst✝⁸ : Semiring R
inst✝⁷ : (i : ι) → AddCommMonoid (M i)
inst✝⁶ : (i : ι) → Module R (M i)
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : DecidableEq ι
inst✝² : Semiring S
inst✝¹ : Module S N
inst✝ : SMulCommClass R S N
F : (i : ι) → M i →ₗ[R] N
i : ι
x : M i
⊢ ((lsum S) F) (single i x) = (F i) x
state_after: no goals
tactic: simp
Theorem: Rat.eq_num_of_isInt
File: Mathlib/Data/Rat/Defs.lean

Proof steps:
state_before: q✝ a b c q : ℚ
h : q.isInt = true
⊢ q = ↑q.num
state_after: q✝ a b c q : ℚ
h : q.den = 1
⊢ q = ↑q.num
tactic: rw [Rat.isInt, Nat.beq_eq_true_eq] at h
state_before: q✝ a b c q : ℚ
h : q.den = 1
⊢ q = ↑q.num
state_after: no goals
tactic: exact (Rat.coe_int_num_of_den_eq_one h).symm
Theorem: CategoryTheory.Dial.leftUnitor_naturality
File: Mathlib/CategoryTheory/Dialectica/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ (𝟙 (𝟙_ (Dial C)) ⊗ f) ≫ (λ_ Y).hom = (λ_ X).hom ≫ f
state_after: case hF
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), π(π₁ ≫ π₂, π₂) ≫ f.F) =
    π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), prod.map π₂ (𝟙 Y.tgt) ≫ f.F)
tactic: ext <;> simp
state_before: case hF
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), π(π₁ ≫ π₂, π₂) ≫ f.F) =
    π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), prod.map π₂ (𝟙 Y.tgt) ≫ f.F)
state_after: case hF.h₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), π(π₁ ≫ π₂, π₂) ≫ f.F) ≫ π₂ =
    π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), prod.map π₂ (𝟙 Y.tgt) ≫ f.F) ≫ π₂
tactic: ext
state_before: case hF.h₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), π(π₁ ≫ π₂, π₂) ≫ f.F) ≫ π₂ =
    π(terminal.from (((⊤_ C) ⨯ X.src) ⨯ Y.tgt), prod.map π₂ (𝟙 Y.tgt) ≫ f.F) ≫ π₂
state_after: case hF.h₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(π₁ ≫ π₂, π₂) ≫ f.F = prod.map π₂ (𝟙 Y.tgt) ≫ f.F
tactic: simp
state_before: case hF.h₂
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(π₁ ≫ π₂, π₂) ≫ f.F = prod.map π₂ (𝟙 Y.tgt) ≫ f.F
state_after: case hF.h₂.e_a
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(π₁ ≫ π₂, π₂) = prod.map π₂ (𝟙 Y.tgt)
tactic: congr 1
state_before: case hF.h₂.e_a
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasFiniteProducts C
inst✝ : HasPullbacks C
X Y : Dial C
f : X ⟶ Y
⊢ π(π₁ ≫ π₂, π₂) = prod.map π₂ (𝟙 Y.tgt)
state_after: no goals
tactic: ext <;> simp
Theorem: Nat.one_le_div_iff
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hb : 0 < b
⊢ 1 ≤ a / b ↔ b ≤ a
state_after: no goals
tactic: rw [le_div_iff_mul_le hb, Nat.one_mul]
Theorem: hasStrictDerivAt_exp_smul_const_of_mem_ball'
File: Mathlib/Analysis/SpecialFunctions/Exponential.lean

Proof steps:
state_before: 𝕂 : Type u_1
𝕊 : Type u_2
𝔸 : Type u_3
inst✝⁹ : NontriviallyNormedField 𝕂
inst✝⁸ : CharZero 𝕂
inst✝⁷ : NormedCommRing 𝕊
inst✝⁶ : NormedRing 𝔸
inst✝⁵ : NormedSpace 𝕂 𝕊
inst✝⁴ : NormedAlgebra 𝕂 𝔸
inst✝³ : Algebra 𝕊 𝔸
inst✝² : ContinuousSMul 𝕊 𝔸
inst✝¹ : IsScalarTower 𝕂 𝕊 𝔸
inst✝ : CompleteSpace 𝔸
x : 𝔸
t : 𝕂
htx : t • x ∈ EMetric.ball 0 (expSeries 𝕂 𝔸).radius
⊢ HasStrictDerivAt (fun u => exp 𝕂 (u • x)) (x * exp 𝕂 (t • x)) t
state_after: no goals
tactic: simpa using (hasStrictFDerivAt_exp_smul_const_of_mem_ball' 𝕂 x t htx).hasStrictDerivAt
Theorem: MeasureTheory.VectorMeasure.map_id
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(v.map id) i = ↑v i
state_after: no goals
tactic: rw [map_apply v measurable_id hi, Set.preimage_id]
Theorem: Equiv.Perm.not_solvable
File: Mathlib/GroupTheory/Solvable.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_3
hX : 5 ≤ Cardinal.mk X
⊢ ¬IsSolvable (Perm X)
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_3
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
⊢ False
tactic: intro h
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_3
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
⊢ False
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_3
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
key : Nonempty (Fin 5 ↪ X)
⊢ False
tactic: have key : Nonempty (Fin 5 ↪ X) := by
    rwa [← Cardinal.lift_mk_le, Cardinal.mk_fin, Cardinal.lift_natCast, Cardinal.lift_id]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
f : G →* G'
X : Type u_3
hX : 5 ≤ Cardinal.mk X
h : IsSolvable (Perm X)
key : Nonempty (Fin 5 ↪ X)
⊢ False
state_after: no goals
tactic: exact
    Equiv.Perm.fin_5_not_solvable
      (solvable_of_solvable_injective (Equiv.Perm.viaEmbeddingHom_injective (Nonempty.some key)))
Theorem: Rat.add_def'
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b : Rat
⊢ a + b = mkRat (a.num * ↑b.den + b.num * ↑a.den) (a.den * b.den)
state_after: no goals
tactic: rw [add_def, normalize_eq_mkRat]
Theorem: LinearIndependent.pair_iff'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

Proof steps:
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y✝ z x y : V
hx : x ≠ 0
⊢ LinearIndependent K ![x, y] ↔ ∀ (a : K), a • x ≠ y
state_after: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y✝ z x y : V
hx : x ≠ 0
⊢ (∀ (s t : K), s • x + t • y = 0 → s = 0 ∧ t = 0) ↔ ∀ (a : K), a • x ≠ y
tactic: rw [LinearIndependent.pair_iff]
state_before: ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y✝ z x y : V
hx : x ≠ 0
⊢ (∀ (s t : K), s • x + t • y = 0 → s = 0 ∧ t = 0) ↔ ∀ (a : K), a • x ≠ y
state_after: case mp
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y✝ z x y : V
hx : x ≠ 0
⊢ (∀ (s t : K), s • x + t • y = 0 → s = 0 ∧ t = 0) → ∀ (a : K), a • x ≠ y

case mpr
ι : Type u'
ι' : Type u_1
R : Type u_2
K : Type u_3
M : Type u_4
M' : Type u_5
M'' : Type u_6
V : Type u
V' : Type u_7
inst✝⁴ : DivisionRing K
inst✝³ : AddCommGroup V
inst✝² : AddCommGroup V'
inst✝¹ : Module K V
inst✝ : Module K V'
v : ι → V
s t : Set V
x✝ y✝ z x y : V
hx : x ≠ 0
⊢ (∀ (a : K), a • x ≠ y) → ∀ (s t : K), s • x + t • y = 0 → s = 0 ∧ t = 0
tactic: constructor
Theorem: Unitization.inl_star
File: Mathlib/Algebra/Algebra/Unitization.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝² : Star R
inst✝¹ : AddMonoid A
inst✝ : StarAddMonoid A
r : R
⊢ (inl (star r)).snd = (star (inl r)).snd
state_after: no goals
tactic: simp only [snd_star, star_zero, snd_inl]
Theorem: addRothNumber_singleton
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
n : ℕ
a : α
⊢ mulRothNumber {a} = 1
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
n : ℕ
a : α
⊢ ThreeGPFree ↑{a}
tactic: refine ThreeGPFree.mulRothNumber_eq ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
n : ℕ
a : α
⊢ ThreeGPFree ↑{a}
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
n : ℕ
a : α
⊢ ThreeGPFree {a}
tactic: rw [coe_singleton]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝³ : DecidableEq α
inst✝² : Monoid α
inst✝¹ : DecidableEq β
inst✝ : Monoid β
s t : Finset α
n : ℕ
a : α
⊢ ThreeGPFree {a}
state_after: no goals
tactic: exact threeGPFree_singleton a
Theorem: norm_mk_eq_zero
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
hS : IsClosed ↑S
m : M
h : ‖(mk' S) m‖ = 0
⊢ m ∈ S
state_after: no goals
tactic: rwa [quotient_norm_eq_zero_iff, hS.closure_eq] at h
Theorem: Submodule.not_mem_of_ortho
File: Mathlib/Algebra/Module/Submodule/Basic.lean

Proof steps:
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0
⊢ x ∉ N
state_after: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0
hx : x ∈ N
⊢ False
tactic: intro hx
state_before: G : Type u''
S : Type u'
R : Type u
M : Type v
ι : Type w
inst✝³ : Ring R
inst✝² : IsDomain R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
b : ι → M
x : M
N : Submodule R M
ortho : ∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0
hx : x ∈ N
⊢ False
state_after: no goals
tactic: simpa using ortho (-1) x hx
Theorem: Equiv.Perm.subtypeCongr.left_apply
File: Mathlib/Logic/Equiv/Basic.lean

Proof steps:
state_before: ε : Type u_1
p : ε → Prop
inst✝ : DecidablePred p
ep ep' : Perm { a // p a }
en en' : Perm { a // ¬p a }
a : ε
h : p a
⊢ (ep.subtypeCongr en) a = ↑(ep ⟨a, h⟩)
state_after: no goals
tactic: simp [Perm.subtypeCongr.apply, h]
Theorem: Basis.eval_ker
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
⊢ ker (Dual.eval R M) = ⊥
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
⊢ ∀ (m : M), (Dual.eval R M) m = 0 → m = 0
tactic: rw [ker_eq_bot']
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
⊢ ∀ (m : M), (Dual.eval R M) m = 0 → m = 0
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
m : M
hm : (Dual.eval R M) m = 0
⊢ m = 0
tactic: intro m hm
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
m : M
hm : (Dual.eval R M) m = 0
⊢ m = 0
state_after: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
m : M
hm : ∀ (x : Dual R M), x m = 0
⊢ m = 0
tactic: simp_rw [LinearMap.ext_iff, Dual.eval_apply, zero_apply] at hm
state_before: R : Type uR
M : Type uM
K : Type uK
V : Type uV
ι✝ : Type uι
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : DecidableEq ι✝
b✝ : Basis ι✝ R M
ι : Type u_1
b : Basis ι R M
m : M
hm : ∀ (x : Dual R M), x m = 0
⊢ m = 0
state_after: no goals
tactic: exact (Basis.forall_coord_eq_zero_iff _).mp fun i => hm (b.coord i)
Theorem: Function.Injective.exists_ne
File: Mathlib/Logic/Nontrivial/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : Nontrivial α
f : α → β
hf : Injective f
y : β
⊢ ∃ x, f x ≠ y
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝ : Nontrivial α
f : α → β
hf : Injective f
y : β
x₁ x₂ : α
hx : x₁ ≠ x₂
⊢ ∃ x, f x ≠ y
tactic: rcases exists_pair_ne α with ⟨x₁, x₂, hx⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝ : Nontrivial α
f : α → β
hf : Injective f
y : β
x₁ x₂ : α
hx : x₁ ≠ x₂
⊢ ∃ x, f x ≠ y
state_after: case pos
α : Type u_1
β : Type u_2
inst✝ : Nontrivial α
f : α → β
hf : Injective f
y : β
x₁ x₂ : α
hx : x₁ ≠ x₂
h : f x₂ = y
⊢ ∃ x, f x ≠ y

case neg
α : Type u_1
β : Type u_2
inst✝ : Nontrivial α
f : α → β
hf : Injective f
y : β
x₁ x₂ : α
hx : x₁ ≠ x₂
h : ¬f x₂ = y
⊢ ∃ x, f x ≠ y
tactic: by_cases h : f x₂ = y