1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: List.mem_sublistsLen_self
File: Mathlib/Data/List/Sublists.lean

tactic: induction' h with l₁ l₂ a s IH l₁ l₂ a s IH
state_before: α : Type u
β : Type v
γ : Type w
l l' : List α
h : l' <+ l
⊢ l' ∈ sublistsLen l'.length l
state_after: case slnil
α : Type u
β : Type v
γ : Type w
l l' : List α
⊢ [] ∈ sublistsLen [].length []

case cons
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ l₁ ∈ sublistsLen l₁.length (a :: l₂)

case cons₂
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ a :: l₁ ∈ sublistsLen (a :: l₁).length (a :: l₂)

tactic: simp
state_before: case slnil
α : Type u
β : Type v
γ : Type w
l l' : List α
⊢ [] ∈ sublistsLen [].length []
state_after: no goals

tactic: cases' l₁ with b l₁
state_before: case cons
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ l₁ ∈ sublistsLen l₁.length (a :: l₂)
state_after: case cons.nil
α : Type u
β : Type v
γ : Type w
l l' l₂ : List α
a : α
s : [] <+ l₂
IH : [] ∈ sublistsLen [].length l₂
⊢ [] ∈ sublistsLen [].length (a :: l₂)

case cons.cons
α : Type u
β : Type v
γ : Type w
l l' l₂ : List α
a b : α
l₁ : List α
s : b :: l₁ <+ l₂
IH : b :: l₁ ∈ sublistsLen (b :: l₁).length l₂
⊢ b :: l₁ ∈ sublistsLen (b :: l₁).length (a :: l₂)

tactic: simp
state_before: case cons.nil
α : Type u
β : Type v
γ : Type w
l l' l₂ : List α
a : α
s : [] <+ l₂
IH : [] ∈ sublistsLen [].length l₂
⊢ [] ∈ sublistsLen [].length (a :: l₂)
state_after: no goals

tactic: rw [length, sublistsLen_succ_cons]
state_before: case cons.cons
α : Type u
β : Type v
γ : Type w
l l' l₂ : List α
a b : α
l₁ : List α
s : b :: l₁ <+ l₂
IH : b :: l₁ ∈ sublistsLen (b :: l₁).length l₂
⊢ b :: l₁ ∈ sublistsLen (b :: l₁).length (a :: l₂)
state_after: case cons.cons
α : Type u
β : Type v
γ : Type w
l l' l₂ : List α
a b : α
l₁ : List α
s : b :: l₁ <+ l₂
IH : b :: l₁ ∈ sublistsLen (b :: l₁).length l₂
⊢ b :: l₁ ∈ sublistsLen (l₁.length + 1) l₂ ++ map (cons a) (sublistsLen l₁.length l₂)

tactic: exact mem_append_left _ IH
state_before: case cons.cons
α : Type u
β : Type v
γ : Type w
l l' l₂ : List α
a b : α
l₁ : List α
s : b :: l₁ <+ l₂
IH : b :: l₁ ∈ sublistsLen (b :: l₁).length l₂
⊢ b :: l₁ ∈ sublistsLen (l₁.length + 1) l₂ ++ map (cons a) (sublistsLen l₁.length l₂)
state_after: no goals

tactic: rw [length, sublistsLen_succ_cons]
state_before: case cons₂
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ a :: l₁ ∈ sublistsLen (a :: l₁).length (a :: l₂)
state_after: case cons₂
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ a :: l₁ ∈ sublistsLen (l₁.length + 1) l₂ ++ map (cons a) (sublistsLen l₁.length l₂)

tactic: exact mem_append_right _ (mem_map.2 ⟨_, IH, rfl⟩)
state_before: case cons₂
α : Type u
β : Type v
γ : Type w
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen l₁.length l₂
⊢ a :: l₁ ∈ sublistsLen (l₁.length + 1) l₂ ++ map (cons a) (sublistsLen l₁.length l₂)
state_after: no goals
Theorem: le_map_inv_iff
File: Mathlib/Order/Hom/Basic.lean

tactic: convert (map_le_map_iff f (a := a) (b := EquivLike.inv f b)).symm
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : LE α
inst✝² : LE β
inst✝¹ : EquivLike F α β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ a ≤ EquivLike.inv f b ↔ f a ≤ b
state_after: case h.e'_2.h.e'_4
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : LE α
inst✝² : LE β
inst✝¹ : EquivLike F α β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ b = f (EquivLike.inv f b)

tactic: exact (EquivLike.right_inv _ _).symm
state_before: case h.e'_2.h.e'_4
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : LE α
inst✝² : LE β
inst✝¹ : EquivLike F α β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ b = f (EquivLike.inv f b)
state_after: no goals
Theorem: NNReal.coe_sInf
File: Mathlib/Data/NNReal/Basic.lean

tactic: rcases Set.eq_empty_or_nonempty s with rfl|hs
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
⊢ ↑(sInf s) = sInf (toReal '' s)
state_after: case inl
r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ ↑(sInf ∅) = sInf (toReal '' ∅)

case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ ↑(sInf s) = sInf (toReal '' s)

tactic: have A : sInf (Subtype.val '' s) ∈ Set.Ici 0 := by
  apply Real.sInf_nonneg
  rintro - ⟨y, -, rfl⟩
  exact y.2
state_before: case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ ↑(sInf s) = sInf (toReal '' s)
state_after: case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
A : sInf (Subtype.val '' s) ∈ Set.Ici 0
⊢ ↑(sInf s) = sInf (toReal '' s)

tactic: exact (@subset_sInf_of_within ℝ (Set.Ici (0 : ℝ)) _ _ (_) s hs (OrderBot.bddBelow s) A).symm
state_before: case inr
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
A : sInf (Subtype.val '' s) ∈ Set.Ici 0
⊢ ↑(sInf s) = sInf (toReal '' s)
state_after: no goals

tactic: simp only [Set.image_empty, Real.sInf_empty, coe_eq_zero]
state_before: case inl
r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ ↑(sInf ∅) = sInf (toReal '' ∅)
state_after: case inl
r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ sInf ∅ = 0

tactic: exact @subset_sInf_emptyset ℝ (Set.Ici (0 : ℝ)) _ _ (_)
state_before: case inl
r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ sInf ∅ = 0
state_after: no goals

tactic: apply Real.sInf_nonneg
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ sInf (Subtype.val '' s) ∈ Set.Ici 0
state_after: case hS
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ ∀ x ∈ Subtype.val '' s, 0 ≤ x

tactic: rintro - ⟨y, -, rfl⟩
state_before: case hS
r r₁ r₂ : ℝ≥0
x y : ℝ
s : Set ℝ≥0
hs : s.Nonempty
⊢ ∀ x ∈ Subtype.val '' s, 0 ≤ x
state_after: case hS.intro.intro
r r₁ r₂ : ℝ≥0
x y✝ : ℝ
s : Set ℝ≥0
hs : s.Nonempty
y : { r // 0 ≤ r }
⊢ 0 ≤ ↑y

tactic: exact y.2
state_before: case hS.intro.intro
r r₁ r₂ : ℝ≥0
x y✝ : ℝ
s : Set ℝ≥0
hs : s.Nonempty
y : { r // 0 ≤ r }
⊢ 0 ≤ ↑y
state_after: no goals
Theorem: Metric.ball_eq_ball'
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

tactic: ext
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ε : ℝ
x : α
⊢ UniformSpace.ball x {p | dist p.1 p.2 < ε} = ball x ε
state_after: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝¹ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ε : ℝ
x x✝ : α
⊢ x✝ ∈ UniformSpace.ball x {p | dist p.1 p.2 < ε} ↔ x✝ ∈ ball x ε

tactic: simp [dist_comm, UniformSpace.ball]
state_before: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x✝¹ y z : α
δ ε✝ ε₁ ε₂ : ℝ
s : Set α
ε : ℝ
x x✝ : α
⊢ x✝ ∈ UniformSpace.ball x {p | dist p.1 p.2 < ε} ↔ x✝ ∈ ball x ε
state_after: no goals
Theorem: InnerProductGeometry.angle_sub_lt_pi_div_two_of_inner_eq_zero
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [← neg_eq_zero, ← inner_neg_right] at h
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, y⟫_ℝ = 0
h0 : x ≠ 0
⊢ angle x (x - y) < π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0
⊢ angle x (x - y) < π / 2

tactic: rw [sub_eq_add_neg]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0
⊢ angle x (x - y) < π / 2
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0
⊢ angle x (x + -y) < π / 2

tactic: exact angle_add_lt_pi_div_two_of_inner_eq_zero h h0
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x y : V
h : ⟪x, -y⟫_ℝ = 0
h0 : x ≠ 0
⊢ angle x (x + -y) < π / 2
state_after: no goals
Theorem: NNReal.mul_lt_of_lt_div
File: Mathlib/Data/NNReal/Basic.lean

tactic: simp [hr] at h
state_before: a b r : ℝ≥0
h : a < b / r
hr : r = 0
⊢ False
state_after: no goals
Theorem: Finset.prod_pow_eq_pow_sum
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

tactic: simp
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset ι
f : ι → ℕ
a : β
⊢ ∏ i ∈ ∅, a ^ f i = a ^ ∑ i ∈ ∅, f i
state_after: no goals

tactic: simp [prod_cons, sum_cons, pow_add, *]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset ι
f : ι → ℕ
a : β
x✝³ : ι
x✝² : Finset ι
x✝¹ : x✝³ ∉ x✝²
x✝ : ∏ i ∈ x✝², a ^ f i = a ^ ∑ i ∈ x✝², f i
⊢ ∏ i ∈ cons x✝³ x✝² x✝¹, a ^ f i = a ^ ∑ i ∈ cons x✝³ x✝² x✝¹, f i
state_after: no goals
Theorem: IsPrimitiveRoot.subOneIntegralPowerBasis_gen
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

tactic: simp [subOneIntegralPowerBasis]
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ k} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ k)
⊢ hζ.subOneIntegralPowerBasis.gen = ⟨ζ - 1, ⋯⟩
state_after: no goals
Theorem: Matroid.comapOn_indep_iff
File: Mathlib/Data/Matroid/Map.lean

tactic: simp [comapOn, and_assoc]
state_before: α : Type u_1
β : Type u_2
f : α → β
E✝ I✝ s : Set α
M : Matroid α
N : Matroid β
E B I : Set α
⊢ (N.comapOn E f).Indep I ↔ N.Indep (f '' I) ∧ InjOn f I ∧ I ⊆ E
state_after: no goals
Theorem: List.nodup_sublists
File: Mathlib/Data/List/Sublists.lean

tactic: simpa using h.to_ne
state_before: α : Type u
β : Type v
γ : Type w
l : List α
h✝ : l.Nodup
l₁ l₂ : List α
h : Lex (fun x x_1 => x ≠ x_1) l₁.reverse l₂.reverse
⊢ l₁ ≠ l₂
state_after: no goals
Theorem: WeierstrassCurve.Affine.nonsingular_of_Δ_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

tactic: rwa [variableChange_Δ, inv_one, Units.val_one, one_pow, one_mul]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
h : W.Equation x y
hΔ : Δ W ≠ 0
⊢ Δ (variableChange W { u := 1, r := x, s := 0, t := y }).toAffine ≠ 0
state_after: no goals
Theorem: Filter.frequently_lt_of_lt_limsup
File: Mathlib/Order/LiminfLimsup.lean

tactic: contrapose! h
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : b < limsup u f
⊢ ∃ᶠ (x : α) in f, b < u x
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ¬∃ᶠ (x : α) in f, b < u x
⊢ limsup u f ≤ b

tactic: apply limsSup_le_of_le hu
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ¬∃ᶠ (x : α) in f, b < u x
⊢ limsup u f ≤ b
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ¬∃ᶠ (x : α) in f, b < u x
⊢ ∀ᶠ (n : β) in map u f, n ≤ b

tactic: simpa using h
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : ConditionallyCompleteLinearOrder β
f : Filter α
u : α → β
b : β
hu : autoParam (IsCoboundedUnder (fun x x_1 => x ≤ x_1) f u) _auto✝
h : ¬∃ᶠ (x : α) in f, b < u x
⊢ ∀ᶠ (n : β) in map u f, n ≤ b
state_after: no goals
Theorem: Padic.AddValuation.map_mul
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simp only [addValuationDef]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
⊢ (x * y).addValuationDef = x.addValuationDef + y.addValuationDef
state_after: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation

tactic: by_cases hx : x = 0
state_before: p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation

case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : ¬x = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation

tactic: rw [hx, if_pos (Eq.refl _), zero_mul, if_pos (Eq.refl _), WithTop.top_add]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : x = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation
state_after: no goals

tactic: by_cases hy : y = 0
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : ¬x = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation
state_after: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : ¬x = 0
hy : y = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation

case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : ¬x = 0
hy : ¬y = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation

tactic: rw [hy, if_pos (Eq.refl _), mul_zero, if_pos (Eq.refl _), WithTop.add_top]
state_before: case pos
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : ¬x = 0
hy : y = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation
state_after: no goals

tactic: rw [if_neg hx, if_neg hy, if_neg (mul_ne_zero hx hy), ← WithTop.coe_add, WithTop.coe_eq_coe,
  valuation_map_mul hx hy]
state_before: case neg
p : ℕ
hp : Fact (Nat.Prime p)
x y : ℚ_[p]
hx : ¬x = 0
hy : ¬y = 0
⊢ (if x * y = 0 then ⊤ else ↑(x * y).valuation) =
    (if x = 0 then ⊤ else ↑x.valuation) + if y = 0 then ⊤ else ↑y.valuation
state_after: no goals
Theorem: Int.abs_ediv_le_abs
File: Mathlib/Algebra/Order/Group/Int.lean

tactic: rw [Int.ediv_neg, abs_neg]
state_before: this : ∀ (a : ℤ) (n : ℕ), |a / ↑n| ≤ |a|
a b : ℤ
n : ℕ
⊢ |a / -↑n| ≤ |a|
state_after: this : ∀ (a : ℤ) (n : ℕ), |a / ↑n| ≤ |a|
a b : ℤ
n : ℕ
⊢ |a / ↑n| ≤ |a|

tactic: apply this
state_before: this : ∀ (a : ℤ) (n : ℕ), |a / ↑n| ≤ |a|
a b : ℤ
n : ℕ
⊢ |a / ↑n| ≤ |a|
state_after: no goals

tactic: rw [abs_eq_natAbs, abs_eq_natAbs]
state_before: a : ℤ
n : ℕ
⊢ |a / ↑n| ≤ |a|
state_after: a : ℤ
n : ℕ
⊢ ↑(a / ↑n).natAbs ≤ ↑a.natAbs

tactic: exact
  ofNat_le_ofNat_of_le
    (match a, n with
    | (m : ℕ), n => Nat.div_le_self _ _
    | -[m+1], 0 => Nat.zero_le _
    | -[m+1], n + 1 => Nat.succ_le_succ (Nat.div_le_self _ _))
state_before: a : ℤ
n : ℕ
⊢ ↑(a / ↑n).natAbs ≤ ↑a.natAbs
state_after: no goals
Theorem: Finset.affineCombinationLineMapWeights_apply_right
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: simp [affineCombinationLineMapWeights, h.symm]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_4
s : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
inst✝ : DecidableEq ι
i j : ι
h : i ≠ j
c : k
⊢ affineCombinationLineMapWeights i j c j = c
state_after: no goals
Theorem: Ordinal.iSup_lt_lift
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [← ord_lt_ord, iSup_ord (Cardinal.bddAbove_range.{u, v} _)]
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
⊢ iSup f < c
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
⊢ ⨆ i, (f i).ord < c.ord

tactic: refine sup_lt_ord_lift hι fun i => ?_
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
⊢ ⨆ i, (f i).ord < c.ord
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
i : ι
⊢ (f i).ord < c.ord

tactic: rw [ord_lt_ord]
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
i : ι
⊢ (f i).ord < c.ord
state_after: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
i : ι
⊢ f i < c

tactic: apply hf
state_before: α : Type u_1
r : α → α → Prop
ι : Type u
f : ι → Cardinal.{max u v}
c : Cardinal.{max u v}
hι : Cardinal.lift.{v, u} #ι < c.ord.cof
hf : ∀ (i : ι), f i < c
i : ι
⊢ f i < c
state_after: no goals
Theorem: Matroid.mapEquiv_indep_iff
File: Mathlib/Data/Matroid/Map.lean

tactic: rw [mapEquiv_eq_map, map_indep_iff]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set β
⊢ (M.mapEquiv f).Indep I ↔ M.Indep (⇑f.symm '' I)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) ↔ M.Indep (⇑f.symm '' I)

tactic: exact ⟨by rintro ⟨I, hI, rfl⟩; simpa, fun h ↦ ⟨_, h, by simp⟩⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) ↔ M.Indep (⇑f.symm '' I)
state_after: no goals

tactic: rintro ⟨I, hI, rfl⟩
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set β
⊢ (∃ I₀, M.Indep I₀ ∧ I = ⇑f '' I₀) → M.Indep (⇑f.symm '' I)
state_after: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set α
hI : M.Indep I
⊢ M.Indep (⇑f.symm '' (⇑f '' I))

tactic: simpa
state_before: case intro.intro
α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set α
hI : M.Indep I
⊢ M.Indep (⇑f.symm '' (⇑f '' I))
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I✝ s : Set α
M : Matroid α
N : Matroid β
f : α ≃ β
I : Set β
h : M.Indep (⇑f.symm '' I)
⊢ I = ⇑f '' (⇑f.symm '' I)
state_after: no goals
Theorem: Algebra.TensorProduct.comm_symm
File: Mathlib/RingTheory/TensorProduct/Basic.lean

tactic: ext
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝²⁰ : CommSemiring R
inst✝¹⁹ : CommSemiring S
inst✝¹⁸ : Algebra R S
inst✝¹⁷ : Semiring A
inst✝¹⁶ : Algebra R A
inst✝¹⁵ : Algebra S A
inst✝¹⁴ : IsScalarTower R S A
inst✝¹³ : Semiring B
inst✝¹² : Algebra R B
inst✝¹¹ : Algebra S B
inst✝¹⁰ : IsScalarTower R S B
inst✝⁹ : Semiring C
inst✝⁸ : Algebra R C
inst✝⁷ : Algebra S C
inst✝⁶ : IsScalarTower R S C
inst✝⁵ : Semiring D
inst✝⁴ : Algebra R D
inst✝³ : Semiring E
inst✝² : Algebra R E
inst✝¹ : Semiring F
inst✝ : Algebra R F
⊢ (TensorProduct.comm R A B).symm = TensorProduct.comm R B A
state_after: case h
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝²⁰ : CommSemiring R
inst✝¹⁹ : CommSemiring S
inst✝¹⁸ : Algebra R S
inst✝¹⁷ : Semiring A
inst✝¹⁶ : Algebra R A
inst✝¹⁵ : Algebra S A
inst✝¹⁴ : IsScalarTower R S A
inst✝¹³ : Semiring B
inst✝¹² : Algebra R B
inst✝¹¹ : Algebra S B
inst✝¹⁰ : IsScalarTower R S B
inst✝⁹ : Semiring C
inst✝⁸ : Algebra R C
inst✝⁷ : Algebra S C
inst✝⁶ : IsScalarTower R S C
inst✝⁵ : Semiring D
inst✝⁴ : Algebra R D
inst✝³ : Semiring E
inst✝² : Algebra R E
inst✝¹ : Semiring F
inst✝ : Algebra R F
a✝ : B ⊗[R] A
⊢ (TensorProduct.comm R A B).symm a✝ = (TensorProduct.comm R B A) a✝

tactic: rfl
state_before: case h
R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝²⁰ : CommSemiring R
inst✝¹⁹ : CommSemiring S
inst✝¹⁸ : Algebra R S
inst✝¹⁷ : Semiring A
inst✝¹⁶ : Algebra R A
inst✝¹⁵ : Algebra S A
inst✝¹⁴ : IsScalarTower R S A
inst✝¹³ : Semiring B
inst✝¹² : Algebra R B
inst✝¹¹ : Algebra S B
inst✝¹⁰ : IsScalarTower R S B
inst✝⁹ : Semiring C
inst✝⁸ : Algebra R C
inst✝⁷ : Algebra S C
inst✝⁶ : IsScalarTower R S C
inst✝⁵ : Semiring D
inst✝⁴ : Algebra R D
inst✝³ : Semiring E
inst✝² : Algebra R E
inst✝¹ : Semiring F
inst✝ : Algebra R F
a✝ : B ⊗[R] A
⊢ (TensorProduct.comm R A B).symm a✝ = (TensorProduct.comm R B A) a✝
state_after: no goals
Theorem: Prime.left_dvd_or_dvd_right_of_dvd_mul
File: Mathlib/Algebra/Associated.lean

tactic: rintro ⟨c, hc⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b : α
⊢ a ∣ p * b → p ∣ a ∨ a ∣ b
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b c : α
hc : p * b = a * c
⊢ p ∣ a ∨ a ∣ b

tactic: rcases hp.2.2 a c (hc ▸ dvd_mul_right _ _) with (h | ⟨x, rfl⟩)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b c : α
hc : p * b = a * c
⊢ p ∣ a ∨ a ∣ b
state_after: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b c : α
hc : p * b = a * c
h : p ∣ a
⊢ p ∣ a ∨ a ∣ b

case intro.inr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b x : α
hc : p * b = a * (p * x)
⊢ p ∣ a ∨ a ∣ b

tactic: exact Or.inl h
state_before: case intro.inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b c : α
hc : p * b = a * c
h : p ∣ a
⊢ p ∣ a ∨ a ∣ b
state_after: no goals

tactic: rw [mul_left_comm, mul_right_inj' hp.ne_zero] at hc
state_before: case intro.inr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b x : α
hc : p * b = a * (p * x)
⊢ p ∣ a ∨ a ∣ b
state_after: case intro.inr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b x : α
hc : b = a * x
⊢ p ∣ a ∨ a ∣ b

tactic: exact Or.inr (hc.symm ▸ dvd_mul_right _ _)
state_before: case intro.inr.intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
p : α
hp : Prime p
a b x : α
hc : b = a * x
⊢ p ∣ a ∨ a ∣ b
state_after: no goals
Theorem: MeasureTheory.Content.is_mul_left_invariant_outerMeasure
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: convert μ.outerMeasure_preimage (Homeomorph.mulLeft g) (fun K => h g) A
state_before: G : Type w
inst✝³ : TopologicalSpace G
μ : Content G
inst✝² : R1Space G
inst✝¹ : Group G
inst✝ : TopologicalGroup G
h : ∀ (g : G) {K : Compacts G}, (fun s => ↑(μ.toFun s)) (Compacts.map (fun b => g * b) ⋯ K) = (fun s => ↑(μ.toFun s)) K
g : G
A : Set G
⊢ μ.outerMeasure ((fun x => g * x) ⁻¹' A) = μ.outerMeasure A
state_after: no goals
Theorem: CochainComplex.HomComplex.Cocycle.mem_iff
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

tactic: subst hnm
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
hnm : n + 1 = m
z : Cochain F G n
⊢ z ∈ cocycle F G n ↔ δ n m z = 0
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n : ℤ
z : Cochain F G n
⊢ z ∈ cocycle F G n ↔ δ n (n + 1) z = 0

tactic: rfl
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n : ℤ
z : Cochain F G n
⊢ z ∈ cocycle F G n ↔ δ n (n + 1) z = 0
state_after: no goals