1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Function.Exact.of_ladder_linearEquiv_of_exact
File: Mathlib/Algebra/Exact.lean

tactic: rw [← LinearEquiv.eq_comp_toLinearMap_symm] at h₁₂ h₂₃
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : AddCommMonoid N'
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid P'
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R N
inst✝² : Module R N'
inst✝¹ : Module R P
inst✝ : Module R P'
f : M →ₗ[R] N
g : N →ₗ[R] P
f₁₂ : M →ₗ[R] N
f₂₃ : N →ₗ[R] P
g₁₂ : M' →ₗ[R] N'
g₂₃ : N' →ₗ[R] P'
e₁ : M ≃ₗ[R] M'
e₂ : N ≃ₗ[R] N'
e₃ : P ≃ₗ[R] P'
h₁₂ : g₁₂ ∘ₗ ↑e₁ = ↑e₂ ∘ₗ f₁₂
h₂₃ : g₂₃ ∘ₗ ↑e₂ = ↑e₃ ∘ₗ f₂₃
H : Exact ⇑f₁₂ ⇑f₂₃
⊢ Exact ⇑g₁₂ ⇑g₂₃
state_after: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : AddCommMonoid N'
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid P'
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R N
inst✝² : Module R N'
inst✝¹ : Module R P
inst✝ : Module R P'
f : M →ₗ[R] N
g : N →ₗ[R] P
f₁₂ : M →ₗ[R] N
f₂₃ : N →ₗ[R] P
g₁₂ : M' →ₗ[R] N'
g₂₃ : N' →ₗ[R] P'
e₁ : M ≃ₗ[R] M'
e₂ : N ≃ₗ[R] N'
e₃ : P ≃ₗ[R] P'
h₁₂ : g₁₂ = (↑e₂ ∘ₗ f₁₂) ∘ₗ ↑e₁.symm
h₂₃ : g₂₃ = (↑e₃ ∘ₗ f₂₃) ∘ₗ ↑e₂.symm
H : Exact ⇑f₁₂ ⇑f₂₃
⊢ Exact ⇑g₁₂ ⇑g₂₃

tactic: rwa [h₁₂, h₂₃, comp_assoc, LinearEquiv.conj_exact_iff_exact,
  e₁.symm.surjective.comp_exact_iff_exact,
  e₃.injective.comp_exact_iff_exact]
state_before: R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝¹² : Semiring R
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : AddCommMonoid N
inst✝⁸ : AddCommMonoid N'
inst✝⁷ : AddCommMonoid P
inst✝⁶ : AddCommMonoid P'
inst✝⁵ : Module R M
inst✝⁴ : Module R M'
inst✝³ : Module R N
inst✝² : Module R N'
inst✝¹ : Module R P
inst✝ : Module R P'
f : M →ₗ[R] N
g : N →ₗ[R] P
f₁₂ : M →ₗ[R] N
f₂₃ : N →ₗ[R] P
g₁₂ : M' →ₗ[R] N'
g₂₃ : N' →ₗ[R] P'
e₁ : M ≃ₗ[R] M'
e₂ : N ≃ₗ[R] N'
e₃ : P ≃ₗ[R] P'
h₁₂ : g₁₂ = (↑e₂ ∘ₗ f₁₂) ∘ₗ ↑e₁.symm
h₂₃ : g₂₃ = (↑e₃ ∘ₗ f₂₃) ∘ₗ ↑e₂.symm
H : Exact ⇑f₁₂ ⇑f₂₃
⊢ Exact ⇑g₁₂ ⇑g₂₃
state_after: no goals
Theorem: Bool.forall_bool'
File: Mathlib/Data/Bool/Basic.lean

tactic: cases b <;> cases x <;> assumption
state_before: p : Bool → Prop
b : Bool
x✝ : p b ∧ p !b
x : Bool
h₁ : p b
h₂ : p !b
⊢ p x
state_after: no goals
Theorem: ProbabilityTheory.iSup_partitionFiltration
File: Mathlib/Probability/Process/PartitionFiltration.lean

tactic: rw [iSup_partitionFiltration_eq_generateFrom_range ht, ht_range]
state_before: α : Type u_1
m : MeasurableSpace α
t : ℕ → Set α
ht : ∀ (n : ℕ), MeasurableSet (t n)
ht_range : generateFrom (Set.range t) = m
⊢ ⨆ n, ↑(partitionFiltration ht) n = m
state_after: no goals
Theorem: Equiv.refl_trans
File: Mathlib/Logic/Equiv/Defs.lean

tactic: cases e
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ (Equiv.refl α).trans e = e
state_after: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ (Equiv.refl α).trans { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }

tactic: rfl
state_before: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ (Equiv.refl α).trans { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
state_after: no goals
Theorem: Set.ncard_pair
File: Mathlib/Data/Set/Card.lean

tactic: rw [ncard_insert_of_not_mem, ncard_singleton]
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b : α
h : a ≠ b
⊢ {a, b}.ncard = 2
state_after: α : Type u_1
β : Type u_2
s t : Set α
a b : α
h : a ≠ b
⊢ a ∉ {b}

tactic: simpa
state_before: α : Type u_1
β : Type u_2
s t : Set α
a b : α
h : a ≠ b
⊢ a ∉ {b}
state_after: no goals
Theorem: let_eq
File: Mathlib/Init/Logic.lean

tactic: simp [h₁, h₂]
state_before: a b c d : Prop
p : ?m.12410
α : Sort v
β : Sort u
a₁ a₂ : α
b₁ b₂ : α → β
h₁ : a₁ = a₂
h₂ : ∀ (x : α), b₁ x = b₂ x
⊢ (let x := a₁;
    b₁ x) =
    let x := a₂;
    b₂ x
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.IsInvertedBy.prod
File: Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean

tactic: rw [isIso_prod_iff]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
C₁ : Type u_1
C₂ : Type u_2
inst✝³ : Category.{u_5, u_1} C₁
inst✝² : Category.{u_6, u_2} C₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
E₁ : Type u_3
E₂ : Type u_4
inst✝¹ : Category.{u_7, u_3} E₁
inst✝ : Category.{u_8, u_4} E₂
F₁ : C₁ ⥤ E₁
F₂ : C₂ ⥤ E₂
h₁ : W₁.IsInvertedBy F₁
h₂ : W₂.IsInvertedBy F₂
x✝¹ x✝ : C₁ × C₂
f : x✝¹ ⟶ x✝
hf : W₁.prod W₂ f
⊢ IsIso ((F₁.prod F₂).map f)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
C₁ : Type u_1
C₂ : Type u_2
inst✝³ : Category.{u_5, u_1} C₁
inst✝² : Category.{u_6, u_2} C₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
E₁ : Type u_3
E₂ : Type u_4
inst✝¹ : Category.{u_7, u_3} E₁
inst✝ : Category.{u_8, u_4} E₂
F₁ : C₁ ⥤ E₁
F₂ : C₂ ⥤ E₂
h₁ : W₁.IsInvertedBy F₁
h₂ : W₂.IsInvertedBy F₂
x✝¹ x✝ : C₁ × C₂
f : x✝¹ ⟶ x✝
hf : W₁.prod W₂ f
⊢ IsIso ((F₁.prod F₂).map f).1 ∧ IsIso ((F₁.prod F₂).map f).2

tactic: exact ⟨h₁ _ hf.1, h₂ _ hf.2⟩
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
C₁ : Type u_1
C₂ : Type u_2
inst✝³ : Category.{u_5, u_1} C₁
inst✝² : Category.{u_6, u_2} C₂
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
E₁ : Type u_3
E₂ : Type u_4
inst✝¹ : Category.{u_7, u_3} E₁
inst✝ : Category.{u_8, u_4} E₂
F₁ : C₁ ⥤ E₁
F₂ : C₂ ⥤ E₂
h₁ : W₁.IsInvertedBy F₁
h₂ : W₂.IsInvertedBy F₂
x✝¹ x✝ : C₁ × C₂
f : x✝¹ ⟶ x✝
hf : W₁.prod W₂ f
⊢ IsIso ((F₁.prod F₂).map f).1 ∧ IsIso ((F₁.prod F₂).map f).2
state_after: no goals
Theorem: CategoryTheory.LaxMonoidalFunctor.right_unitality_inv
File: Mathlib/CategoryTheory/Monoidal/Functor.lean

tactic: rw [Iso.inv_comp_eq, F.right_unitality, Category.assoc, Category.assoc, ← F.toFunctor.map_comp,
  Iso.hom_inv_id, F.toFunctor.map_id, comp_id]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
inst✝² : MonoidalCategory C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
inst✝ : MonoidalCategory D
F : LaxMonoidalFunctor C D
X : C
⊢ (ρ_ (F.obj X)).inv ≫ F.obj X ◁ F.ε ≫ F.μ X (𝟙_ C) = F.map (ρ_ X).inv
state_after: no goals
Theorem: Finset.sup'_product_right
File: Mathlib/Data/Finset/Lattice.lean

tactic: rw [sup'_product_left, Finset.sup'_comm]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : s.Nonempty
f✝ : β → α
t : Finset γ
h : (s ×ˢ t).Nonempty
f : β × γ → α
⊢ (s ×ˢ t).sup' h f = t.sup' ⋯ fun i' => s.sup' ⋯ fun i => f (i, i')
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.cocycle_fst_fst_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp only [t'_fst_fst_fst, t'_fst_snd, t'_snd_snd]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j k : 𝒰.J
⊢ t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.fst ≫ pullback.fst ≫ pullback.fst =
    pullback.fst ≫ pullback.fst ≫ pullback.fst
state_after: no goals
Theorem: LinearMap.update_apply
File: Mathlib/LinearAlgebra/Pi.lean

tactic: by_cases h : j = i
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₃
φ : ι → Type i
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
f : (i : ι) → M₂ →ₗ[R] φ i
c : M₂
i j : ι
b : M₂ →ₗ[R] φ i
⊢ (update f i b j) c = update (fun i => (f i) c) i (b c) j
state_after: case pos
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₃
φ : ι → Type i
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
f : (i : ι) → M₂ →ₗ[R] φ i
c : M₂
i j : ι
b : M₂ →ₗ[R] φ i
h : j = i
⊢ (update f i b j) c = update (fun i => (f i) c) i (b c) j

case neg
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₃
φ : ι → Type i
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
f : (i : ι) → M₂ →ₗ[R] φ i
c : M₂
i j : ι
b : M₂ →ₗ[R] φ i
h : ¬j = i
⊢ (update f i b j) c = update (fun i => (f i) c) i (b c) j

tactic: rw [h, update_same, update_same]
state_before: case pos
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₃
φ : ι → Type i
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
f : (i : ι) → M₂ →ₗ[R] φ i
c : M₂
i j : ι
b : M₂ →ₗ[R] φ i
h : j = i
⊢ (update f i b j) c = update (fun i => (f i) c) i (b c) j
state_after: no goals

tactic: rw [update_noteq h, update_noteq h]
state_before: case neg
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M₃
φ : ι → Type i
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
f : (i : ι) → M₂ →ₗ[R] φ i
c : M₂
i j : ι
b : M₂ →ₗ[R] φ i
h : ¬j = i
⊢ (update f i b j) c = update (fun i => (f i) c) i (b c) j
state_after: no goals
Theorem: ArithmeticFunction.coe_mul_zeta_apply
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: rw [mul_apply]
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ (f * ↑ζ) x = ∑ i ∈ x.divisors, f i
state_after: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ ∑ x ∈ x.divisorsAntidiagonal, f x.1 * ↑ζ x.2 = ∑ i ∈ x.divisors, f i

tactic: trans ∑ i ∈ divisorsAntidiagonal x, f i.1
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ ∑ x ∈ x.divisorsAntidiagonal, f x.1 * ↑ζ x.2 = ∑ i ∈ x.divisors, f i
state_after: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ ∑ x ∈ x.divisorsAntidiagonal, f x.1 * ↑ζ x.2 = ∑ i ∈ x.divisorsAntidiagonal, f i.1

R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ ∑ i ∈ x.divisorsAntidiagonal, f i.1 = ∑ i ∈ x.divisors, f i

tactic: refine sum_congr rfl fun i hi => ?_
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ ∑ x ∈ x.divisorsAntidiagonal, f x.1 * ↑ζ x.2 = ∑ i ∈ x.divisorsAntidiagonal, f i.1
state_after: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
i : ℕ × ℕ
hi : i ∈ x.divisorsAntidiagonal
⊢ f i.1 * ↑ζ i.2 = f i.1

tactic: rcases mem_divisorsAntidiagonal.1 hi with ⟨rfl, h⟩
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
i : ℕ × ℕ
hi : i ∈ x.divisorsAntidiagonal
⊢ f i.1 * ↑ζ i.2 = f i.1
state_after: case intro
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
i : ℕ × ℕ
hi : i ∈ (i.1 * i.2).divisorsAntidiagonal
h : i.1 * i.2 ≠ 0
⊢ f i.1 * ↑ζ i.2 = f i.1

tactic: rw [natCoe_apply, zeta_apply_ne (right_ne_zero_of_mul h), cast_one, mul_one]
state_before: case intro
R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
i : ℕ × ℕ
hi : i ∈ (i.1 * i.2).divisorsAntidiagonal
h : i.1 * i.2 ≠ 0
⊢ f i.1 * ↑ζ i.2 = f i.1
state_after: no goals

tactic: rw [← map_div_right_divisors, sum_map, Function.Embedding.coeFn_mk]
state_before: R : Type u_1
inst✝ : Semiring R
f : ArithmeticFunction R
x : ℕ
⊢ ∑ i ∈ x.divisorsAntidiagonal, f i.1 = ∑ i ∈ x.divisors, f i
state_after: no goals
Theorem: List.drop_take_succ_join_eq_get
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: rw [drop_take_succ_join_eq_getElem _ _ i.2]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : Fin L.length
⊢ drop (take (↑i) (map length L)).sum (take (take (↑i + 1) (map length L)).sum L.join) = L.get i
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : Fin L.length
⊢ L[↑i] = L.get i

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
L : List (List α)
i : Fin L.length
⊢ L[↑i] = L.get i
state_after: no goals
Theorem: Submodule.coe_span_eq_self
File: Mathlib/LinearAlgebra/Span.lean

tactic: refine le_antisymm ?_ subset_span
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
⊢ ↑(span R ↑s) = ↑s
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
⊢ ↑(span R ↑s) ≤ ↑s

tactic: let s' : Submodule R M :=
  { carrier := s
    add_mem' := add_mem
    zero_mem' := zero_mem _
    smul_mem' := SMulMemClass.smul_mem }
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
⊢ ↑(span R ↑s) ≤ ↑s
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
s' : Submodule R M := { carrier := ↑s, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ }
⊢ ↑(span R ↑s) ≤ ↑s

tactic: exact span_le (p := s') |>.mpr le_rfl
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝¹⁰ : Semiring R
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
x : M
p p' : Submodule R M
inst✝⁷ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝⁶ : AddCommMonoid M₂
inst✝⁵ : Module R₂ M₂
F : Type u_8
inst✝⁴ : FunLike F M M₂
inst✝³ : SemilinearMapClass F σ₁₂ M M₂
s✝ t : Set M
inst✝² : SetLike S M
inst✝¹ : AddSubmonoidClass S M
inst✝ : SMulMemClass S R M
s : S
s' : Submodule R M := { carrier := ↑s, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ }
⊢ ↑(span R ↑s) ≤ ↑s
state_after: no goals
Theorem: Basis.coe_mkFinCons
File: Mathlib/LinearAlgebra/Basis.lean

tactic: unfold mkFinCons
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R ↥N
hli : ∀ (c : R), ∀ x ∈ N, c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ⇑(mkFinCons y b hli hsp) = Fin.cons y (Subtype.val ∘ ⇑b)
state_after: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R ↥N
hli : ∀ (c : R), ∀ x ∈ N, c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ⇑(let_fun span_b := ⋯;
      Basis.mk ⋯ ⋯) =
    Fin.cons y (Subtype.val ∘ ⇑b)

tactic: exact coe_mk (v := Fin.cons y (N.subtype ∘ b)) _ _
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
v : ι → M
inst✝⁸ : Ring R
inst✝⁷ : CommRing R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : AddCommGroup M'
inst✝⁴ : AddCommGroup M''
inst✝³ : Module R M
inst✝² : Module R₂ M
inst✝¹ : Module R M'
inst✝ : Module R M''
c d : R
x y✝ : M
b✝ : Basis ι R M
n : ℕ
N : Submodule R M
y : M
b : Basis (Fin n) R ↥N
hli : ∀ (c : R), ∀ x ∈ N, c • y + x = 0 → c = 0
hsp : ∀ (z : M), ∃ c, z + c • y ∈ N
⊢ ⇑(let_fun span_b := ⋯;
      Basis.mk ⋯ ⋯) =
    Fin.cons y (Subtype.val ∘ ⇑b)
state_after: no goals
Theorem: Function.minimalPeriod_eq_minimalPeriod_iff
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp_rw [isPeriodicPt_iff_minimalPeriod_dvd, dvd_right_iff_eq]
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y✝ : α
m n : ℕ
g : β → β
y : β
⊢ minimalPeriod f x = minimalPeriod g y ↔ ∀ (n : ℕ), IsPeriodicPt f n x ↔ IsPeriodicPt g n y
state_after: no goals
Theorem: SimpleGraph.disjoint_fromEdgeSet
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: conv_rhs => rw [← Set.diff_union_inter s {e : Sym2 V | e.IsDiag}]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ Disjoint G (fromEdgeSet s) ↔ Disjoint G.edgeSet s
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ Disjoint G (fromEdgeSet s) ↔ Disjoint G.edgeSet (s \ {e | e.IsDiag} ∪ s ∩ {e | e.IsDiag})

tactic: rw [← disjoint_edgeSet,  edgeSet_fromEdgeSet, Set.disjoint_union_right, and_iff_left]
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ Disjoint G (fromEdgeSet s) ↔ Disjoint G.edgeSet (s \ {e | e.IsDiag} ∪ s ∩ {e | e.IsDiag})
state_after: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ Disjoint G.edgeSet (s ∩ {e | e.IsDiag})

tactic: exact Set.disjoint_left.2 fun e he he' ↦ not_isDiag_of_mem_edgeSet _ he he'.2
state_before: ι : Sort u_1
V : Type u
G : SimpleGraph V
a b c u v w : V
e : Sym2 V
s : Set (Sym2 V)
⊢ Disjoint G.edgeSet (s ∩ {e | e.IsDiag})
state_after: no goals
Theorem: Complex.cos_eq_one_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← cos_zero, eq_comm, cos_eq_cos_iff]
state_before: x : ℂ
⊢ cos x = 1 ↔ ∃ k, ↑k * (2 * ↑π) = x
state_after: x : ℂ
⊢ (∃ k, x = 2 * ↑k * ↑π + 0 ∨ x = 2 * ↑k * ↑π - 0) ↔ ∃ k, ↑k * (2 * ↑π) = x

tactic: simp [mul_assoc, mul_left_comm, eq_comm]
state_before: x : ℂ
⊢ (∃ k, x = 2 * ↑k * ↑π + 0 ∨ x = 2 * ↑k * ↑π - 0) ↔ ∃ k, ↑k * (2 * ↑π) = x
state_after: no goals
Theorem: Set.pi_univ_Icc
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: simp [Pi.le_def, forall_and]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Preorder (α i)
x y✝ y : (i : ι) → α i
⊢ (y ∈ univ.pi fun i => Icc (x i) (y✝ i)) ↔ y ∈ Icc x y✝
state_after: no goals
Theorem: Subspace.forall_mem_dualAnnihilator_apply_eq_zero_iff
File: Mathlib/LinearAlgebra/Dual.lean

tactic: rw [← SetLike.ext_iff.mp dualAnnihilator_dualCoannihilator_eq v, mem_dualCoannihilator]
state_before: K : Type u
V : Type v
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
W : Subspace K V
v : V
⊢ (∀ φ ∈ dualAnnihilator W, φ v = 0) ↔ v ∈ W
state_after: no goals
Theorem: DFinsupp.update_eq_sub_add_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: rw [update_eq_erase_add_single f i b, erase_eq_sub_single f i]
state_before: ι : Type u
γ : Type w
β✝ : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β✝ i)
s : Finset ι
x : (i : ↑↑s) → β✝ ↑i
i✝ : ι
f✝ : Π₀ (i : ι), β✝ i
b✝ : β✝ i✝
j : ι
β : ι → Type u_1
inst✝ : (i : ι) → AddGroup (β i)
f : Π₀ (i : ι), β i
i : ι
b : β i
⊢ update i f b = f - single i (f i) + single i b
state_after: no goals
Theorem: Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: simpa only [arg_eq_pi_iff.2 ⟨hre, him⟩] using
  (continuousWithinAt_arg_of_re_neg_of_im_zero hre him).tendsto
state_before: a x z✝ z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ Tendsto arg (𝓝[{z | 0 ≤ z.im}] z) (𝓝 π)
state_after: no goals
Theorem: finprod_mem_dvd
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: by_cases ha : a ∈ mulSupport f
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
⊢ f a ∣ finprod f
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∈ mulSupport f
⊢ f a ∣ finprod f

case neg
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∉ mulSupport f
⊢ f a ∣ finprod f

tactic: rw [finprod_eq_prod_of_mulSupport_toFinset_subset f hf (Set.Subset.refl _)]
state_before: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∈ mulSupport f
⊢ f a ∣ finprod f
state_after: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∈ mulSupport f
⊢ f a ∣ ∏ i ∈ hf.toFinset, f i

tactic: exact Finset.dvd_prod_of_mem f ((Finite.mem_toFinset hf).mpr ha)
state_before: case pos
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∈ mulSupport f
⊢ f a ∣ ∏ i ∈ hf.toFinset, f i
state_after: no goals

tactic: rw [nmem_mulSupport.mp ha]
state_before: case neg
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∉ mulSupport f
⊢ f a ∣ finprod f
state_after: case neg
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∉ mulSupport f
⊢ 1 ∣ finprod f

tactic: exact one_dvd (finprod f)
state_before: case neg
α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a✝ b : α
s t : Set α
f : α → N
a : α
hf : (mulSupport f).Finite
ha : a ∉ mulSupport f
⊢ 1 ∣ finprod f
state_after: no goals