1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: jacobiSym.mod_right
File: Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean

tactic: cases' Int.natAbs_eq a with ha ha <;> nth_rw 2 [ha] <;> nth_rw 1 [ha]
state_before: a : ℤ
b : ℕ
hb : Odd b
⊢ J(a | b) = J(a | b % (4 * a.natAbs))
state_after: case inl
a : ℤ
b : ℕ
hb : Odd b
ha : a = ↑a.natAbs
⊢ J(↑a.natAbs | b) = J(↑a.natAbs | b % (4 * a.natAbs))

case inr
a : ℤ
b : ℕ
hb : Odd b
ha : a = -↑a.natAbs
⊢ J(-↑a.natAbs | b) = J(-↑a.natAbs | b % (4 * a.natAbs))

tactic: exact mod_right' a.natAbs hb
state_before: case inl
a : ℤ
b : ℕ
hb : Odd b
ha : a = ↑a.natAbs
⊢ J(↑a.natAbs | b) = J(↑a.natAbs | b % (4 * a.natAbs))
state_after: no goals

tactic: have hb' : Odd (b % (4 * a.natAbs)) := hb.mod_even (Even.mul_right (by decide) _)
state_before: case inr
a : ℤ
b : ℕ
hb : Odd b
ha : a = -↑a.natAbs
⊢ J(-↑a.natAbs | b) = J(-↑a.natAbs | b % (4 * a.natAbs))
state_after: case inr
a : ℤ
b : ℕ
hb : Odd b
ha : a = -↑a.natAbs
hb' : Odd (b % (4 * a.natAbs))
⊢ J(-↑a.natAbs | b) = J(-↑a.natAbs | b % (4 * a.natAbs))

tactic: rw [jacobiSym.neg _ hb, jacobiSym.neg _ hb', mod_right' _ hb, χ₄_nat_mod_four,
  χ₄_nat_mod_four (b % (4 * _)), mod_mod_of_dvd b (dvd_mul_right 4 _)]
state_before: case inr
a : ℤ
b : ℕ
hb : Odd b
ha : a = -↑a.natAbs
hb' : Odd (b % (4 * a.natAbs))
⊢ J(-↑a.natAbs | b) = J(-↑a.natAbs | b % (4 * a.natAbs))
state_after: no goals

tactic: decide
state_before: a : ℤ
b : ℕ
hb : Odd b
ha : a = -↑a.natAbs
⊢ Even 4
state_after: no goals
Theorem: Set.intersecting_iff_eq_empty_of_subsingleton
File: Mathlib/Combinatorics/SetFamily/Intersecting.lean

tactic: refine
  subsingleton_of_subsingleton.intersecting.trans
    ⟨not_imp_comm.2 fun h => subsingleton_of_subsingleton.eq_singleton_of_mem ?_, ?_⟩
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
⊢ s.Intersecting ↔ s = ∅
state_after: case refine_1
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
h : ¬s = ∅
⊢ ⊥ ∈ s

case refine_2
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
⊢ s = ∅ → s ≠ {⊥}

tactic: obtain ⟨a, ha⟩ := nonempty_iff_ne_empty.2 h
state_before: case refine_1
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
h : ¬s = ∅
⊢ ⊥ ∈ s
state_after: case refine_1.intro
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a✝ b c : α
inst✝ : Subsingleton α
s : Set α
h : ¬s = ∅
a : α
ha : a ∈ s
⊢ ⊥ ∈ s

tactic: rwa [Subsingleton.elim ⊥ a]
state_before: case refine_1.intro
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a✝ b c : α
inst✝ : Subsingleton α
s : Set α
h : ¬s = ∅
a : α
ha : a ∈ s
⊢ ⊥ ∈ s
state_after: no goals

tactic: rintro rfl
state_before: case refine_2
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s✝ t : Set α
a b c : α
inst✝ : Subsingleton α
s : Set α
⊢ s = ∅ → s ≠ {⊥}
state_after: case refine_2
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s t : Set α
a b c : α
inst✝ : Subsingleton α
⊢ ∅ ≠ {⊥}

tactic: exact (Set.singleton_nonempty _).ne_empty.symm
state_before: case refine_2
α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderBot α
s t : Set α
a b c : α
inst✝ : Subsingleton α
⊢ ∅ ≠ {⊥}
state_after: no goals
Theorem: Finset.noncommProd_toFinset
File: Mathlib/Data/Finset/NoncommProd.lean

tactic: rw [← List.dedup_eq_self] at hl
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.Nodup
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.dedup = l
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod

tactic: simp [noncommProd, hl]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.dedup = l
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
state_after: no goals
Theorem: Matrix.diagonal_mulVec_single
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext i
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
⊢ diagonal v *ᵥ Pi.single j x = Pi.single j (v j * x)
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ (diagonal v *ᵥ Pi.single j x) i = Pi.single j (v j * x) i

tactic: rw [mulVec_diagonal]
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ (diagonal v *ᵥ Pi.single j x) i = Pi.single j (v j * x) i
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ v i * Pi.single j x i = Pi.single j (v j * x) i

tactic: exact Pi.apply_single (fun i x => v i * x) (fun i => mul_zero _) j x i
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonUnitalNonAssocSemiring α
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : NonUnitalNonAssocSemiring R
v : n → R
j : n
x : R
i : n
⊢ v i * Pi.single j x i = Pi.single j (v j * x) i
state_after: no goals
Theorem: Functor.Comp.comp_map
File: Mathlib/Control/Functor.lean

tactic: simp [Comp.map, Comp.mk, Functor.map_comp_map, functor_norm]
state_before: F : Type u → Type w
G : Type v → Type u
inst✝³ : Functor F
inst✝² : Functor G
inst✝¹ : LawfulFunctor F
inst✝ : LawfulFunctor G
α β γ : Type v
g' : α → β
h : β → γ
x : F (G α)
⊢ Comp.map (h ∘ g') (mk x) = Comp.map h (Comp.map g' (mk x))
state_after: no goals
Theorem: Polynomial.tendsto_atTop_iff_leadingCoeff_nonneg
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

tactic: refine ⟨fun h => ?_, fun h => tendsto_atTop_of_leadingCoeff_nonneg P h.1 h.2⟩
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
⊢ Tendsto (fun x => eval x P) atTop atTop ↔ 0 < P.degree ∧ 0 ≤ P.leadingCoeff
state_after: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
⊢ 0 < P.degree ∧ 0 ≤ P.leadingCoeff

tactic: have : Tendsto (fun x => P.leadingCoeff * x ^ P.natDegree) atTop atTop :=
  (isEquivalent_atTop_lead P).tendsto_atTop h
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
⊢ 0 < P.degree ∧ 0 ≤ P.leadingCoeff
state_after: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
this : Tendsto (fun x => P.leadingCoeff * x ^ P.natDegree) atTop atTop
⊢ 0 < P.degree ∧ 0 ≤ P.leadingCoeff

tactic: rw [tendsto_const_mul_pow_atTop_iff, ← pos_iff_ne_zero, natDegree_pos_iff_degree_pos] at this
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
this : Tendsto (fun x => P.leadingCoeff * x ^ P.natDegree) atTop atTop
⊢ 0 < P.degree ∧ 0 ≤ P.leadingCoeff
state_after: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
this : 0 < P.degree ∧ 0 < P.leadingCoeff
⊢ 0 < P.degree ∧ 0 ≤ P.leadingCoeff

tactic: exact ⟨this.1, this.2.le⟩
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
h : Tendsto (fun x => eval x P) atTop atTop
this : 0 < P.degree ∧ 0 < P.leadingCoeff
⊢ 0 < P.degree ∧ 0 ≤ P.leadingCoeff
state_after: no goals
Theorem: StrictConvexSpace.of_norm_add
File: Mathlib/Analysis/Convex/StrictConvexSpace.lean

tactic: refine StrictConvexSpace.of_pairwise_sphere_norm_ne_two fun x hx y hy => mt fun h₂ => ?_
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
⊢ StrictConvexSpace ℝ E
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : x ∈ sphere 0 1
y : E
hy : y ∈ sphere 0 1
h₂ : ‖x + y‖ = 2
⊢ x = y

tactic: rw [mem_sphere_zero_iff_norm] at hx hy
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : x ∈ sphere 0 1
y : E
hy : y ∈ sphere 0 1
h₂ : ‖x + y‖ = 2
⊢ x = y
state_after: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
h₂ : ‖x + y‖ = 2
⊢ x = y

tactic: exact (sameRay_iff_of_norm_eq (hx.trans hy.symm)).1 (h x y hx hy h₂)
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedLinearOrderedField 𝕜
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
h : ∀ (x y : E), ‖x‖ = 1 → ‖y‖ = 1 → ‖x + y‖ = 2 → SameRay ℝ x y
x : E
hx : ‖x‖ = 1
y : E
hy : ‖y‖ = 1
h₂ : ‖x + y‖ = 2
⊢ x = y
state_after: no goals
Theorem: SimpleGraph.isEmpty_of_chromaticNumber_eq_zero
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

tactic: have h' := G.colorable_chromaticNumber_of_fintype
state_before: V : Type u
G✝ : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G✝.Coloring α
G : SimpleGraph V
inst✝ : Finite V
h : G.chromaticNumber = 0
⊢ IsEmpty V
state_after: V : Type u
G✝ : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G✝.Coloring α
G : SimpleGraph V
inst✝ : Finite V
h : G.chromaticNumber = 0
h' : G.Colorable G.chromaticNumber.toNat
⊢ IsEmpty V

tactic: rw [h] at h'
state_before: V : Type u
G✝ : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G✝.Coloring α
G : SimpleGraph V
inst✝ : Finite V
h : G.chromaticNumber = 0
h' : G.Colorable G.chromaticNumber.toNat
⊢ IsEmpty V
state_after: V : Type u
G✝ : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G✝.Coloring α
G : SimpleGraph V
inst✝ : Finite V
h : G.chromaticNumber = 0
h' : G.Colorable (ENat.toNat 0)
⊢ IsEmpty V

tactic: exact G.isEmpty_of_colorable_zero h'
state_before: V : Type u
G✝ : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G✝.Coloring α
G : SimpleGraph V
inst✝ : Finite V
h : G.chromaticNumber = 0
h' : G.Colorable (ENat.toNat 0)
⊢ IsEmpty V
state_after: no goals
Theorem: Finset.insert_val'
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [dedup_cons, dedup_eq_self]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
⊢ (insert a s).val = (a ::ₘ s.val).dedup
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
⊢ (insert a s).val = ndinsert a s.val

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t u v : Finset α
a✝ b a : α
s : Finset α
⊢ (insert a s).val = ndinsert a s.val
state_after: no goals
Theorem: Matroid.dual_dep_iff_forall
File: Mathlib/Data/Matroid/Dual.lean

tactic: simp_rw [dep_iff, dual_indep_iff_exists', dual_ground, and_congr_left_iff, not_and,
  not_exists, not_and, not_disjoint_iff_nonempty_inter, Classical.imp_iff_right_iff,
  iff_true_intro Or.inl]
state_before: α : Type u_1
M : Matroid α
I B X : Set α
⊢ M✶.Dep I ↔ (∀ (B : Set α), M.Base B → (I ∩ B).Nonempty) ∧ I ⊆ M.E
state_after: no goals
Theorem: NonAssocRing.toNonAssocSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

tactic: intro _ _ h
state_before: R : Type u
⊢ Function.Injective (@toNonAssocSemiring R)
state_after: R : Type u
a₁✝ a₂✝ : NonAssocRing R
h : toNonAssocSemiring = toNonAssocSemiring
⊢ a₁✝ = a₂✝

tactic: ext x y
state_before: R : Type u
a₁✝ a₂✝ : NonAssocRing R
h : toNonAssocSemiring = toNonAssocSemiring
⊢ a₁✝ = a₂✝
state_after: case h_add.h.h
R : Type u
a₁✝ a₂✝ : NonAssocRing R
h : toNonAssocSemiring = toNonAssocSemiring
x y : R
⊢ x + y = x + y

case h_mul.h.h
R : Type u
a₁✝ a₂✝ : NonAssocRing R
h : toNonAssocSemiring = toNonAssocSemiring
x y : R
⊢ x * y = x * y
Theorem: ENNReal.lt_inv_iff_lt_inv
File: Mathlib/Data/ENNReal/Inv.lean

tactic: simpa only [inv_inv] using @ENNReal.inv_lt_inv a⁻¹ b
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a < b⁻¹ ↔ b < a⁻¹
state_after: no goals
Theorem: UpperSet.upperClosure_inf_sdiff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [inf_comm, sdiff_inf_upperClosure hts hst]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : Preorder α
s : UpperSet α
t : Set α
a : α
hts : t ⊆ ↑s
hst : ∀ b ∈ s, ∀ c ∈ t, b ≤ c → b ∈ t
⊢ upperClosure t ⊓ s.sdiff t = s
state_after: no goals
Theorem: Units.divp_sub
File: Mathlib/Algebra/Ring/Units.lean

tactic: simp only [divp, sub_mul, sub_right_inj]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ a /ₚ u - b = (a - b * ↑u) /ₚ u
state_after: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ b = b * ↑u * ↑u⁻¹

tactic: rw [mul_assoc, Units.mul_inv, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : Ring α
a✝ b✝ a b : α
u : αˣ
⊢ b = b * ↑u * ↑u⁻¹
state_after: no goals
Theorem: Filter.top_mul_of_one_le
File: Mathlib/Order/Filter/Pointwise.lean

tactic: refine top_le_iff.1 fun s => ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s : Set α
a : α
m n : ℕ
hf : 1 ≤ f
⊢ ⊤ * f = ⊤
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ s ∈ ⊤ * f → s ∈ ⊤

tactic: simp only [mem_mul, mem_top, exists_and_left, exists_eq_left]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ s ∈ ⊤ * f → s ∈ ⊤
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ (∃ t₂ ∈ f, univ * t₂ ⊆ s) → s = univ

tactic: rintro ⟨t, ht, hs⟩
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s : Set α
⊢ (∃ t₂ ∈ f, univ * t₂ ⊆ s) → s = univ
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s t : Set α
ht : t ∈ f
hs : univ * t ⊆ s
⊢ s = univ

tactic: rwa [univ_mul_of_one_mem (mem_one.1 <| hf ht), univ_subset_iff] at hs
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
ε : Type u_6
inst✝ : Monoid α
f g : Filter α
s✝ : Set α
a : α
m n : ℕ
hf : 1 ≤ f
s t : Set α
ht : t ∈ f
hs : univ * t ⊆ s
⊢ s = univ
state_after: no goals
Theorem: List.foldrIdx_start
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: induction xs generalizing f i s with
| nil => rfl
| cons h t ih =>
  dsimp [foldrIdx]
  simp only [@ih f]
  simp only [@ih (fun i => f (i + s))]
  simp [Nat.add_assoc, Nat.add_comm 1 s]
state_before: α : Type u_1
xs : List α
α✝ : Sort u_2
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ foldrIdx f i xs s = foldrIdx (fun i => f (i + s)) i xs
state_after: no goals

tactic: rfl
state_before: case nil
α : Type u_1
α✝ : Sort u_2
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ foldrIdx f i [] s = foldrIdx (fun i => f (i + s)) i []
state_after: no goals

tactic: dsimp [foldrIdx]
state_before: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ foldrIdx f i (h :: t) s = foldrIdx (fun i => f (i + s)) i (h :: t)
state_after: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ f s h (foldrIdx f i t (s + 1)) = f (0 + s) h (foldrIdx (fun i => f (i + s)) i t 1)

tactic: simp only [@ih f]
state_before: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ f s h (foldrIdx f i t (s + 1)) = f (0 + s) h (foldrIdx (fun i => f (i + s)) i t 1)
state_after: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ f s h (foldrIdx (fun i => f (i + (s + 1))) i t) = f (0 + s) h (foldrIdx (fun i => f (i + s)) i t 1)

tactic: simp only [@ih (fun i => f (i + s))]
state_before: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ f s h (foldrIdx (fun i => f (i + (s + 1))) i t) = f (0 + s) h (foldrIdx (fun i => f (i + s)) i t 1)
state_after: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ f s h (foldrIdx (fun i => f (i + (s + 1))) i t) = f (0 + s) h (foldrIdx (fun i => f (i + 1 + s)) i t)

tactic: simp [Nat.add_assoc, Nat.add_comm 1 s]
state_before: case cons
α : Type u_1
α✝ : Sort u_2
h : α
t : List α
ih : ∀ {f : Nat → α → α✝ → α✝} {i : α✝} {s : Nat}, foldrIdx f i t s = foldrIdx (fun i => f (i + s)) i t
f : Nat → α → α✝ → α✝
i : α✝
s : Nat
⊢ f s h (foldrIdx (fun i => f (i + (s + 1))) i t) = f (0 + s) h (foldrIdx (fun i => f (i + 1 + s)) i t)
state_after: no goals
Theorem: LinearIndependent.inl_union_inr
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: refine (hs.image_subtype ?_).union (ht.image_subtype ?_) ?_ <;> [simp; simp; skip]
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
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
t : Set M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
ht : LinearIndependent R fun (x : ↑t) => ↑x
⊢ LinearIndependent R fun (x : ↑(⇑(inl R M M') '' s ∪ ⇑(inr R M M') '' t)) => ↑x
state_after: case refine_3
ι : 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
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
t : Set M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
ht : LinearIndependent R fun (x : ↑t) => ↑x
⊢ Disjoint (span R (⇑(inl R M M') '' s)) (span R (⇑(inr R M M') '' t))

tactic: simp only [span_image _]
state_before: case refine_3
ι : 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
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
t : Set M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
ht : LinearIndependent R fun (x : ↑t) => ↑x
⊢ Disjoint (span R (⇑(inl R M M') '' s)) (span R (⇑(inr R M M') '' t))
state_after: case refine_3
ι : 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
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
t : Set M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
ht : LinearIndependent R fun (x : ↑t) => ↑x
⊢ Disjoint (Submodule.map (inl R M M') (span R s)) (Submodule.map (inr R M M') (span R t))

tactic: simp [disjoint_iff, prod_inf_prod]
state_before: case refine_3
ι : 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
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set M
t : Set M'
hs : LinearIndependent R fun (x : ↑s) => ↑x
ht : LinearIndependent R fun (x : ↑t) => ↑x
⊢ Disjoint (Submodule.map (inl R M M') (span R s)) (Submodule.map (inr R M M') (span R t))
state_after: no goals