1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finsupp.Lex.acc
File: Mathlib/Data/Finsupp/WellFounded.lean

tactic: rw [lex_eq_invImage_dfinsupp_lex]
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (Finsupp.Lex r s) x
state_after: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (InvImage (DFinsupp.Lex r fun x => s) toDFinsupp) x

tactic: classical
  refine InvImage.accessible toDFinsupp (DFinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ ?_)
  simpa only [toDFinsupp_support] using h
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (InvImage (DFinsupp.Lex r fun x => s) toDFinsupp) x
state_after: no goals

tactic: refine InvImage.accessible toDFinsupp (DFinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ ?_)
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ Acc (InvImage (DFinsupp.Lex r fun x => s) toDFinsupp) x
state_after: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ ∀ i ∈ x.toDFinsupp.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) i

tactic: simpa only [toDFinsupp_support] using h
state_before: α : Type u_1
N : Type u_2
inst✝ : Zero N
r : α → α → Prop
s : N → N → Prop
hbot : ∀ ⦃n : N⦄, ¬s n 0
hs : WellFounded s
x : α →₀ N
h : ∀ a ∈ x.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) a
⊢ ∀ i ∈ x.toDFinsupp.support, Acc (rᶜ ⊓ fun x x_1 => x ≠ x_1) i
state_after: no goals
Theorem: Nat.findGreatest_eq_zero_iff
File: Mathlib/Data/Nat/Defs.lean

tactic: simp [findGreatest_eq_iff]
state_before: a b c d m n✝ k : ℕ
p q P Q : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
⊢ findGreatest P k = 0 ↔ ∀ ⦃n : ℕ⦄, 0 < n → n ≤ k → ¬P n
state_after: no goals
Theorem: star_star_mul
File: Mathlib/Algebra/Star/Basic.lean

tactic: rw [star_mul, star_star]
state_before: R : Type u
inst✝¹ : Mul R
inst✝ : StarMul R
x y : R
⊢ star (star x * y) = star y * x
state_after: no goals
Theorem: Filter.isBounded_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsBounded, exists_true_iff_nonempty]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f g : Filter α
⊢ IsBounded r ⊥ ↔ Nonempty α
state_after: no goals
Theorem: ProbabilityTheory.kernel.compProdFun_eq_tsum
File: Mathlib/Probability/Kernel/Composition.lean

tactic: simp_rw [compProdFun_tsum_left κ η a s, compProdFun_tsum_right _ η a hs]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : ↥(kernel α β)
inst✝¹ : IsSFiniteKernel κ
η : ↥(kernel (α × β) γ)
inst✝ : IsSFiniteKernel η
a : α
hs : MeasurableSet s
⊢ compProdFun κ η a s = ∑' (n : ℕ) (m : ℕ), compProdFun (seq κ n) (seq η m) a s
state_after: no goals
Theorem: ContinuousLinearMap.hasStrictFDerivAt
File: Mathlib/Analysis/Calculus/FDeriv/Linear.lean

tactic: simp only [e.map_sub, sub_self]
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
x✝ : E
x : E × E
⊢ 0 = e x.1 - e x.2 - e (x.1 - x.2)
state_after: no goals
Theorem: Cardinal.bddAbove_range
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rintro a ⟨i, rfl⟩
state_before: α β ι : Type u
f : ι → Cardinal.{max u v}
⊢ ?m.57909 ∈ upperBounds (range f)
state_after: case intro
α β ι : Type u
f : ι → Cardinal.{max u v}
i : ι
⊢ f i ≤ ?m.57909

tactic: exact le_sum f i
state_before: case intro
α β ι : Type u
f : ι → Cardinal.{max u v}
i : ι
⊢ f i ≤ ?m.57909
state_after: no goals
Theorem: le_mul_inv_of_mul_le
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

tactic: simpa [h] using hab
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : c ≠ 0
hab : a * c ≤ b
⊢ a * c ≤ b * c⁻¹ * c
state_after: no goals
Theorem: CategoryTheory.Limits.Types.iUnion_descSet_singleton
File: Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean

tactic: rw [← descSet_univ hc lc, eq_comm, descSet_spec]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ ⋃ x, descSet hc {x} = Set.univ
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}

tactic: intro j x
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
⊢ ∀ (j : J) (x : K.obj j), lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}

tactic: erw [true_iff, Set.mem_iUnion]
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ lc.ι.app j { down := x } ∈ Set.univ ↔ c.ι.app j x ∈ ⋃ x, descSet hc {x}
state_after: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ ∃ i, c.ι.app j x ∈ descSet hc {i}

tactic: use lc.ι.app j ⟨x⟩
state_before: J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ ∃ i, c.ι.app j x ∈ descSet hc {i}
state_after: case h
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ c.ι.app j x ∈ descSet hc {lc.ι.app j { down := x }}

tactic: rw [mem_descSet_singleton]
state_before: case h
J : Type u_1
inst✝ : Category.{u_2, u_1} J
K : J ⥤ Type u
c : Cocone K
hc : IsColimit c
lc : Cocone (K ⋙ uliftFunctor.{v, u})
j : J
x : K.obj j
⊢ c.ι.app j x ∈ descSet hc {lc.ι.app j { down := x }}
state_after: no goals
Theorem: one_lt_pow_iff_of_nonneg
File: Mathlib/Algebra/Order/Ring/Basic.lean

tactic: simpa only [one_pow] using pow_lt_pow_iff_left (zero_le_one' R) ha hn
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝ : LinearOrderedSemiring R
a b : R
m n : ℕ
ha : 0 ≤ a
hn : n ≠ 0
⊢ 1 < a ^ n ↔ 1 < a
state_after: no goals
Theorem: minpoly.monic
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: delta minpoly
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ (minpoly A x).Monic
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ (if hx : IsIntegral A x then ⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx else 0).Monic

tactic: rw [dif_pos hx]
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ (if hx : IsIntegral A x then ⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx else 0).Monic
state_after: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ (⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx).Monic

tactic: exact (degree_lt_wf.min_mem _ hx).1
state_before: A : Type u_1
B : Type u_2
B' : Type u_3
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
hx : IsIntegral A x
⊢ (⋯.min (fun x_1 => x_1.Monic ∧ eval₂ (algebraMap A B) x x_1 = 0) hx).Monic
state_after: no goals
Theorem: Computability.decode_encodeNum
File: Mathlib/Computability/Encoding.lean

tactic: intro n
state_before: ⊢ ∀ (n : Num), decodeNum (encodeNum n) = n
state_after: n : Num
⊢ decodeNum (encodeNum n) = n

tactic: cases' n with n <;> unfold encodeNum decodeNum
state_before: n : Num
⊢ decodeNum (encodeNum n) = n
state_after: case zero

⊢ (if
        (match Num.zero with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else
      ↑(decodePosNum
          (match Num.zero with
          | Num.zero => []
          | Num.pos n => encodePosNum n))) =
    Num.zero

case pos
n : PosNum
⊢ (if
        (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else
      ↑(decodePosNum
          (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n))) =
    Num.pos n

tactic: rw [decode_encodePosNum n]
state_before: case pos
n : PosNum
⊢ (if
        (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else
      ↑(decodePosNum
          (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n))) =
    Num.pos n
state_after: case pos
n : PosNum
⊢ (if
        (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else ↑n) =
    Num.pos n

tactic: rw [PosNum.cast_to_num]
state_before: case pos
n : PosNum
⊢ (if
        (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else ↑n) =
    Num.pos n
state_after: case pos
n : PosNum
⊢ (if
        (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else Num.pos n) =
    Num.pos n

tactic: exact if_neg (encodePosNum_nonempty n)
state_before: case pos
n : PosNum
⊢ (if
        (match Num.pos n with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else Num.pos n) =
    Num.pos n
state_after: no goals

tactic: rfl
state_before: case zero

⊢ (if
        (match Num.zero with
          | Num.zero => []
          | Num.pos n => encodePosNum n) =
          [] then
      Num.zero
    else
      ↑(decodePosNum
          (match Num.zero with
          | Num.zero => []
          | Num.pos n => encodePosNum n))) =
    Num.zero
state_after: no goals
Theorem: RCLike.conj_eq_re_sub_im
File: Mathlib/Analysis/RCLike/Basic.lean

tactic: rw [map_add, map_mul, conj_I, conj_ofReal, conj_ofReal, mul_neg, sub_eq_add_neg]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z : K
⊢ (starRingEnd K) (↑(re z) + ↑(im z) * I) = ↑(re z) - ↑(im z) * I
state_after: no goals
Theorem: Sym2.mk_eq_mk_iff
File: Mathlib/Data/Sym/Sym2.lean

tactic: cases p
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α × α
⊢ Sym2.mk p = Sym2.mk q ↔ p = q ∨ p = q.swap
state_after: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
q : α × α
fst✝ snd✝ : α
⊢ s(fst✝, snd✝) = Sym2.mk q ↔ (fst✝, snd✝) = q ∨ (fst✝, snd✝) = q.swap

tactic: cases q
state_before: case mk
α : Type u_1
β : Type u_2
γ : Type u_3
q : α × α
fst✝ snd✝ : α
⊢ s(fst✝, snd✝) = Sym2.mk q ↔ (fst✝, snd✝) = q ∨ (fst✝, snd✝) = q.swap
state_after: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
fst✝¹ snd✝¹ fst✝ snd✝ : α
⊢ s(fst✝¹, snd✝¹) = s(fst✝, snd✝) ↔ (fst✝¹, snd✝¹) = (fst✝, snd✝) ∨ (fst✝¹, snd✝¹) = (fst✝, snd✝).swap

tactic: simp only [eq_iff, Prod.mk.inj_iff, Prod.swap_prod_mk]
state_before: case mk.mk
α : Type u_1
β : Type u_2
γ : Type u_3
fst✝¹ snd✝¹ fst✝ snd✝ : α
⊢ s(fst✝¹, snd✝¹) = s(fst✝, snd✝) ↔ (fst✝¹, snd✝¹) = (fst✝, snd✝) ∨ (fst✝¹, snd✝¹) = (fst✝, snd✝).swap
state_after: no goals
Theorem: ProbabilityTheory.meas_ge_le_variance_div_sq
File: Mathlib/Probability/Variance.lean

tactic: rw [ENNReal.ofReal_div_of_pos (sq_pos_of_ne_zero hc.ne.symm), hX.ofReal_variance_eq]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ ℙ {ω | c ≤ |X ω - ∫ (a : Ω), X a|} ≤ ENNReal.ofReal (variance X ℙ / c ^ 2)
state_after: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ ℙ {ω | c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ENNReal.ofReal (c ^ 2)

tactic: convert @meas_ge_le_evariance_div_sq _ _ _ hX.1 c.toNNReal (by simp [hc]) using 1
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ ℙ {ω | c ≤ |X ω - ∫ (a : Ω), X a|} ≤ evariance X ℙ / ENNReal.ofReal (c ^ 2)
state_after: case h.e'_3
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ ℙ {ω | c ≤ |X ω - ∫ (a : Ω), X a|} = ℙ {ω | ↑c.toNNReal ≤ |X ω - ∫ (a : Ω), X a|}

case h.e'_4
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ evariance X ℙ / ENNReal.ofReal (c ^ 2) = evariance X ℙ / ↑c.toNNReal ^ 2

tactic: simp [hc]
state_before: Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ c.toNNReal ≠ 0
state_after: no goals

tactic: simp only [Real.coe_toNNReal', max_le_iff, abs_nonneg, and_true_iff]
state_before: case h.e'_3
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ ℙ {ω | c ≤ |X ω - ∫ (a : Ω), X a|} = ℙ {ω | ↑c.toNNReal ≤ |X ω - ∫ (a : Ω), X a|}
state_after: no goals

tactic: rw [ENNReal.ofReal_pow hc.le]
state_before: case h.e'_4
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ evariance X ℙ / ENNReal.ofReal (c ^ 2) = evariance X ℙ / ↑c.toNNReal ^ 2
state_after: case h.e'_4
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ evariance X ℙ / ENNReal.ofReal c ^ 2 = evariance X ℙ / ↑c.toNNReal ^ 2

tactic: rfl
state_before: case h.e'_4
Ω : Type u_1
m : MeasurableSpace Ω
X✝ : Ω → ℝ
μ : Measure Ω
inst✝¹ : MeasureSpace Ω
inst✝ : IsFiniteMeasure ℙ
X : Ω → ℝ
hX : Memℒp X 2 ℙ
c : ℝ
hc : 0 < c
⊢ evariance X ℙ / ENNReal.ofReal c ^ 2 = evariance X ℙ / ↑c.toNNReal ^ 2
state_after: no goals
Theorem: range_vecMulLinear
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

tactic: letI := Classical.decEq m
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
⊢ LinearMap.range M.vecMulLinear = span R (Set.range M)
state_after: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
this : DecidableEq m := Classical.decEq m
⊢ LinearMap.range M.vecMulLinear = span R (Set.range M)

tactic: simp_rw [range_eq_map, ← iSup_range_stdBasis, Submodule.map_iSup, range_eq_map, ←
  Ideal.span_singleton_one, Ideal.span, Submodule.map_span, image_image, image_singleton,
  Matrix.vecMulLinear_apply, iSup_span, range_eq_iUnion, iUnion_singleton_eq_range,
  LinearMap.stdBasis, coe_single]
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
this : DecidableEq m := Classical.decEq m
⊢ LinearMap.range M.vecMulLinear = span R (Set.range M)
state_after: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
this : DecidableEq m := Classical.decEq m
⊢ span R (Set.range fun x => Pi.single x 1 ᵥ* M) = span R (Set.range M)

tactic: unfold vecMul
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
this : DecidableEq m := Classical.decEq m
⊢ span R (Set.range fun x => Pi.single x 1 ᵥ* M) = span R (Set.range M)
state_after: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
this : DecidableEq m := Classical.decEq m
⊢ span R
      (Set.range fun x x_1 =>
        let j := x_1;
        Pi.single x 1 ⬝ᵥ fun i => M i j) =
    span R (Set.range M)

tactic: simp_rw [single_dotProduct, one_mul]
state_before: R : Type u_1
inst✝² : Semiring R
l : Type u_2
m : Type u_3
n : Type u_4
inst✝¹ : Fintype m
inst✝ : DecidableEq m
M : Matrix m n R
this : DecidableEq m := Classical.decEq m
⊢ span R
      (Set.range fun x x_1 =>
        let j := x_1;
        Pi.single x 1 ⬝ᵥ fun i => M i j) =
    span R (Set.range M)
state_after: no goals
Theorem: OrderIso.complementedLattice_iff
File: Mathlib/Order/Hom/Basic.lean

tactic: intro
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
⊢ ComplementedLattice α → ComplementedLattice β
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
a✝ : ComplementedLattice α
⊢ ComplementedLattice β

tactic: exact f.complementedLattice
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
a✝ : ComplementedLattice α
⊢ ComplementedLattice β
state_after: no goals

tactic: intro
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
⊢ ComplementedLattice β → ComplementedLattice α
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
a✝ : ComplementedLattice β
⊢ ComplementedLattice α

tactic: exact f.symm.complementedLattice
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Lattice α
inst✝² : Lattice β
inst✝¹ : BoundedOrder α
inst✝ : BoundedOrder β
f : α ≃o β
a✝ : ComplementedLattice β
⊢ ComplementedLattice α
state_after: no goals
Theorem: CategoryTheory.tensorRightHomEquiv_naturality
File: Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean

tactic: simp [tensorRightHomEquiv]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
X Y Y' Z Z' : C
inst✝ : ExactPairing Y Y'
f : X ⊗ Y ⟶ Z
g : Z ⟶ Z'
⊢ (tensorRightHomEquiv X Y Y' Z') (f ≫ g) = (tensorRightHomEquiv X Y Y' Z) f ≫ g ▷ Y'
state_after: no goals
Theorem: Finset.sorted_zero_eq_min'_aux
File: Mathlib/Data/Finset/Sort.lean

tactic: apply le_antisymm
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
⊢ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ = s.min' H
state_after: case a
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
⊢ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ ≤ s.min' H

case a
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
⊢ s.min' H ≤ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩

tactic: obtain ⟨i, hi⟩ : ∃ i, l.get i = s.min' H := List.mem_iff_get.1 this
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
this : s.min' H ∈ l
⊢ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ ≤ s.min' H
state_after: case a.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
this : s.min' H ∈ l
i : Fin l.length
hi : l.get i = s.min' H
⊢ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ ≤ s.min' H

tactic: rw [← hi]
state_before: case a.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
this : s.min' H ∈ l
i : Fin l.length
hi : l.get i = s.min' H
⊢ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ ≤ s.min' H
state_after: case a.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
this : s.min' H ∈ l
i : Fin l.length
hi : l.get i = s.min' H
⊢ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩ ≤ l.get i

tactic: exact s.min'_le _ this
state_before: case a
α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
s : Finset α
h : 0 < (sort (fun x x_1 => x ≤ x_1) s).length
H : s.Nonempty
l : List α := sort (fun x x_1 => x ≤ x_1) s
this : l.get ⟨0, h⟩ ∈ s
⊢ s.min' H ≤ (sort (fun x x_1 => x ≤ x_1) s).get ⟨0, h⟩
state_after: no goals
Theorem: Nat.xgcdAux_fst
File: Mathlib/Data/Int/GCD.lean

tactic: simp
state_before: x y : ℕ
⊢ ∀ (n : ℕ) (s t s' t' : ℤ), (xgcdAux 0 s t n s' t').1 = gcd 0 n
state_after: no goals

tactic: simp only [h, xgcdAux_rec, IH]
state_before: x✝ y✝ x y : ℕ
h : 0 < x
IH : ∀ (s t s' t' : ℤ), ((y % x).xgcdAux s t x s' t').1 = (y % x).gcd x
s t s' t' : ℤ
⊢ (x.xgcdAux s t y s' t').1 = x.gcd y
state_after: x✝ y✝ x y : ℕ
h : 0 < x
IH : ∀ (s t s' t' : ℤ), ((y % x).xgcdAux s t x s' t').1 = (y % x).gcd x
s t s' t' : ℤ
⊢ (y % x).gcd x = x.gcd y

tactic: rw [← gcd_rec]
state_before: x✝ y✝ x y : ℕ
h : 0 < x
IH : ∀ (s t s' t' : ℤ), ((y % x).xgcdAux s t x s' t').1 = (y % x).gcd x
s t s' t' : ℤ
⊢ (y % x).gcd x = x.gcd y
state_after: no goals
Theorem: Complex.IsExpCmpFilter.abs_im_pow_eventuallyLE_exp_re
File: Mathlib/Analysis/SpecialFunctions/CompareExp.lean

tactic: simpa using (hl.isLittleO_im_pow_exp_re n).bound zero_lt_one
state_before: l : Filter ℂ
hl : IsExpCmpFilter l
n : ℕ
⊢ (fun z => |z.im| ^ n) ≤ᶠ[l] fun z => Real.exp z.re
state_after: no goals
Theorem: Equiv.sumCongr_trans
File: Mathlib/Logic/Equiv/Basic.lean

tactic: ext i
state_before: α₁ : Type u_1
β₁ : Type u_2
α₂ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
e : α₁ ≃ β₁
f : α₂ ≃ β₂
g : β₁ ≃ γ₁
h : β₂ ≃ γ₂
⊢ (e.sumCongr f).trans (g.sumCongr h) = (e.trans g).sumCongr (f.trans h)
state_after: case H
α₁ : Type u_1
β₁ : Type u_2
α₂ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
e : α₁ ≃ β₁
f : α₂ ≃ β₂
g : β₁ ≃ γ₁
h : β₂ ≃ γ₂
i : α₁ ⊕ α₂
⊢ ((e.sumCongr f).trans (g.sumCongr h)) i = ((e.trans g).sumCongr (f.trans h)) i

tactic: cases i <;> rfl
state_before: case H
α₁ : Type u_1
β₁ : Type u_2
α₂ : Type u_3
β₂ : Type u_4
γ₁ : Type u_5
γ₂ : Type u_6
e : α₁ ≃ β₁
f : α₂ ≃ β₂
g : β₁ ≃ γ₁
h : β₂ ≃ γ₂
i : α₁ ⊕ α₂
⊢ ((e.sumCongr f).trans (g.sumCongr h)) i = ((e.trans g).sumCongr (f.trans h)) i
state_after: no goals