tasksource/leandojo huggingface dataset:
Theorem: Finset.affineCombination_eq_of_weightedVSub_eq_zero_of_eq_neg_one
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [← @vsub_eq_zero_iff_eq V, ← hw,
  ← s.affineCombination_sdiff_sub (singleton_subset_iff.2 his), sdiff_singleton_eq_erase,
  ← filter_ne']
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.357197
s₂ : Finset ι₂
w : ι → k
p : ι → P
hw : ↑(weightedVSub s p) w = 0
i : ι
inst✝ : DecidablePred fun x => x ≠ i
his : i ∈ s
hwi : w i = -1
⊢ ↑(affineCombination k (filter (fun x => x ≠ i) s) p) w = p i

tactic: congr
state_before: k : Type u_3
V : Type u_1
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.357197
s₂ : Finset ι₂
w : ι → k
p : ι → P
hw : ↑(weightedVSub s p) w = 0
i : ι
inst✝ : DecidablePred fun x => x ≠ i
his : i ∈ s
hwi : w i = -1
⊢ ↑(affineCombination k (filter (fun x => x ≠ i) s) p) w -ᵥ p i =
    ↑(affineCombination k (filter (fun a => a ≠ i) s) p) w -ᵥ ↑(affineCombination k {i} p) (-w)

tactic: refine' (affineCombination_of_eq_one_of_eq_zero _ _ _ (mem_singleton_self _) _ _).symm
state_before: case e_a
k : Type u_3
V : Type u_1
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.357197
s₂ : Finset ι₂
w : ι → k
p : ι → P
hw : ↑(weightedVSub s p) w = 0
i : ι
inst✝ : DecidablePred fun x => x ≠ i
his : i ∈ s
hwi : w i = -1
⊢ p i = ↑(affineCombination k {i} p) (-w)

tactic: simp [hwi]
state_before: case e_a.refine'_1
k : Type u_3
V : Type u_1
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.357197
s₂ : Finset ι₂
w : ι → k
p : ι → P
hw : ↑(weightedVSub s p) w = 0
i : ι
inst✝ : DecidablePred fun x => x ≠ i
his : i ∈ s
hwi : w i = -1
⊢ (-w) i = 1

tactic: simp
state_before: case e_a.refine'_2
k : Type u_3
V : Type u_1
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.357197
s₂ : Finset ι₂
w : ι → k
p : ι → P
hw : ↑(weightedVSub s p) w = 0
i : ι
inst✝ : DecidablePred fun x => x ≠ i
his : i ∈ s
hwi : w i = -1
⊢ ∀ (i2 : ι), i2 ∈ {i} → i2 ≠ i → (-w) i2 = 0
Theorem: AddMonoidAlgebra.divOf_add
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

tactic: refine Finsupp.ext fun _ => ?_
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
a b : G
⊢ x /ᵒᶠ (a + b) = x /ᵒᶠ a /ᵒᶠ b

tactic: simp only [AddMonoidAlgebra.divOf_apply, add_assoc]
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
a b x✝ : G
⊢ ↑(x /ᵒᶠ (a + b)) x✝ = ↑(x /ᵒᶠ a /ᵒᶠ b) x✝
Theorem: Turing.PartrecToTM2.codeSupp_cons
File: Mathlib/Computability/TMToPartrec.lean

tactic: simp [codeSupp, codeSupp', contSupp, Finset.union_assoc]
state_before: f fs : Code
k : Cont'
⊢ codeSupp (Code.cons f fs) k = trStmts₁ (trNormal (Code.cons f fs) k) ∪ codeSupp f (Cont'.cons₁ fs k)
Theorem: LinearEquiv.continuous_symm
File: Mathlib/Analysis/NormedSpace/Banach.lean

tactic: rw [continuous_def]
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
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
e : E ≃ₗ[𝕜] F
h : Continuous ↑e
⊢ Continuous ↑(symm e)

tactic: intro s hs
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
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
e : E ≃ₗ[𝕜] F
h : Continuous ↑e
⊢ ∀ (s : Set E), IsOpen s → IsOpen (↑(symm e) ⁻¹' s)

tactic: rw [← e.image_eq_preimage]
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
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
e : E ≃ₗ[𝕜] F
h : Continuous ↑e
s : Set E
hs : IsOpen s
⊢ IsOpen (↑(symm e) ⁻¹' s)

tactic: rw [← e.coe_coe] at h⊢
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
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
e : E ≃ₗ[𝕜] F
h : Continuous ↑e
s : Set E
hs : IsOpen s
⊢ IsOpen (↑e '' s)

tactic: exact ContinuousLinearMap.isOpenMap (𝕜 := 𝕜) ⟨↑e, h⟩ e.surjective s hs
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
f : E →L[𝕜] F
inst✝¹ : CompleteSpace F
inst✝ : CompleteSpace E
e : E ≃ₗ[𝕜] F
h : Continuous ↑↑e
s : Set E
hs : IsOpen s
⊢ IsOpen (↑↑e '' s)
Theorem: Finset.mem_shadow_iff_exists_mem_card_add_one
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: refine' mem_shadow_iff_insert_mem.trans ⟨_, _⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ s ∈ (∂ ) 𝒜 ↔ ∃ t, t ∈ 𝒜 ∧ s ⊆ t ∧ card t = card s + 1

tactic: rintro ⟨a, ha, hs⟩
state_before: case refine'_1
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ (∃ a x, insert a s ∈ 𝒜) → ∃ t, t ∈ 𝒜 ∧ s ⊆ t ∧ card t = card s + 1

tactic: exact ⟨insert a s, hs, subset_insert _ _, card_insert_of_not_mem ha⟩
state_before: case refine'_1.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a✝ : α
k r : ℕ
a : α
ha : ¬a ∈ s
hs : insert a s ∈ 𝒜
⊢ ∃ t, t ∈ 𝒜 ∧ s ⊆ t ∧ card t = card s + 1

tactic: rintro ⟨t, ht, hst, h⟩
state_before: case refine'_2
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ (∃ t, t ∈ 𝒜 ∧ s ⊆ t ∧ card t = card s + 1) → ∃ a x, insert a s ∈ 𝒜

tactic: obtain ⟨a, ha⟩ : ∃ a, t \ s = {a} :=
  card_eq_one.1 (by rw [card_sdiff hst, h, add_tsub_cancel_left])
state_before: case refine'_2.intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
h : card t = card s + 1
⊢ ∃ a x, insert a s ∈ 𝒜

tactic: exact
  ⟨a, fun hat => not_mem_sdiff_of_mem_right hat ((ha.ge : _ ⊆ _) <| mem_singleton_self a), by
    rwa [insert_eq a s, ← ha, sdiff_union_of_subset hst]⟩
state_before: case refine'_2.intro.intro.intro.intro
α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a✝ : α
k r : ℕ
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
h : card t = card s + 1
a : α
ha : t \ s = {a}
⊢ ∃ a x, insert a s ∈ 𝒜

tactic: rw [card_sdiff hst, h, add_tsub_cancel_left]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a : α
k r : ℕ
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
h : card t = card s + 1
⊢ card (t \ s) = 1

tactic: rwa [insert_eq a s, ← ha, sdiff_union_of_subset hst]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜 : Finset (Finset α)
s t✝ : Finset α
a✝ : α
k r : ℕ
t : Finset α
ht : t ∈ 𝒜
hst : s ⊆ t
h : card t = card s + 1
a : α
ha : t \ s = {a}
⊢ insert a s ∈ 𝒜
Theorem: Seminorm.smul_inf
File: Mathlib/Analysis/Seminorm.lean

tactic: ext
state_before: R : Type u_1
R' : Type ?u.658025
𝕜 : Type u_2
𝕜₂ : Type ?u.658031
𝕜₃ : Type ?u.658034
𝕝 : Type ?u.658037
E : Type u_3
E₂ : Type ?u.658043
E₃ : Type ?u.658046
F : Type ?u.658049
G : Type ?u.658052
ι : Type ?u.658055
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x : E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
r : R
p q : Seminorm 𝕜 E
⊢ r • (p ⊓ q) = r • p ⊓ r • q

tactic: simp_rw [smul_apply, inf_apply, smul_apply, ← smul_one_smul ℝ≥0 r (_ : ℝ), NNReal.smul_def,
  smul_eq_mul, Real.mul_iInf_of_nonneg (NNReal.coe_nonneg _), mul_add]
state_before: case h
R : Type u_1
R' : Type ?u.658025
𝕜 : Type u_2
𝕜₂ : Type ?u.658031
𝕜₃ : Type ?u.658034
𝕝 : Type ?u.658037
E : Type u_3
E₂ : Type ?u.658043
E₃ : Type ?u.658046
F : Type ?u.658049
G : Type ?u.658052
ι : Type ?u.658055
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x : E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
r : R
p q : Seminorm 𝕜 E
x✝ : E
⊢ ↑(r • (p ⊓ q)) x✝ = ↑(r • p ⊓ r • q) x✝
Theorem: Con.sup_def
File: Mathlib/GroupTheory/Congruence.lean

tactic: rw [sup_eq_conGen]
state_before: M : Type u_1
N : Type ?u.29654
P : Type ?u.29657
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ c ⊔ d = conGen (r ⊔ r)

tactic: rfl
state_before: M : Type u_1
N : Type ?u.29654
P : Type ?u.29657
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
c✝ c d : Con M
⊢ (conGen fun x y => ↑c x y ∨ ↑d x y) = conGen (r ⊔ r)
Theorem: FormalMultilinearSeries.apply_eq_pow_smul_coeff
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: simp
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p : FormalMultilinearSeries 𝕜 𝕜 E
f : 𝕜 → E
n : ℕ
z z₀ : 𝕜
y : Fin n → 𝕜
⊢ (↑(p n) fun x => z) = z ^ n • coeff p n
Theorem: Functor.Comp.pure_seq_eq_map
File: Mathlib/Control/Applicative.lean

tactic: simp [Applicative.pure_seq_eq_map', functor_norm]
state_before: F : Type u → Type w
G : Type v → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type v
f : α → β
x : Comp F G α
⊢ run (Seq.seq (pure f) fun x_1 => x) = run (f <$> x)
Theorem: Polynomial.coeff_add
File: Mathlib/Data/Polynomial/Coeff.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p✝ q✝ r p q : R[X]
n : ℕ
⊢ coeff (p + q) n = coeff p n + coeff q n

tactic: rcases q with ⟨⟩
state_before: case ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q✝ r q : R[X]
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := toFinsupp✝ } + q) n = coeff { toFinsupp := toFinsupp✝ } n + coeff q n

tactic: simp_rw [← ofFinsupp_add, coeff]
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ coeff ({ toFinsupp := toFinsupp✝¹ } + { toFinsupp := toFinsupp✝ }) n =
    coeff { toFinsupp := toFinsupp✝¹ } n + coeff { toFinsupp := toFinsupp✝ } n

tactic: exact Finsupp.add_apply _ _ _
state_before: case ofFinsupp.ofFinsupp
R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
toFinsupp✝¹ toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ ↑(toFinsupp✝¹ + toFinsupp✝) n = ↑toFinsupp✝¹ n + ↑toFinsupp✝ n
Theorem: AffineSubspace.pointwise_vadd_direction
File: Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean

tactic: rw [pointwise_vadd_eq_map, map_direction]
state_before: k : Type u_1
inst✝⁹ : Ring k
V : Type u_2
P : Type u_3
V₁ : Type ?u.23420
P₁ : Type ?u.23423
V₂ : Type ?u.23426
P₂ : Type ?u.23429
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
v : V
s : AffineSubspace k P
⊢ direction (v +ᵥ s) = direction s

tactic: exact Submodule.map_id _
state_before: k : Type u_1
inst✝⁹ : Ring k
V : Type u_2
P : Type u_3
V₁ : Type ?u.23420
P₁ : Type ?u.23423
V₂ : Type ?u.23426
P₂ : Type ?u.23429
inst✝⁸ : AddCommGroup V
inst✝⁷ : Module k V
inst✝⁶ : AffineSpace V P
inst✝⁵ : AddCommGroup V₁
inst✝⁴ : Module k V₁
inst✝³ : AffineSpace V₁ P₁
inst✝² : AddCommGroup V₂
inst✝¹ : Module k V₂
inst✝ : AffineSpace V₂ P₂
v : V
s : AffineSubspace k P
⊢ Submodule.map (↑(AffineEquiv.constVAdd k P v)).linear (direction s) = direction s
Theorem: CategoryTheory.Limits.biprod.inr_map
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

tactic: rw [biprod.map_eq_map']
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inr ≫ map f g = g ≫ inr

tactic: exact IsColimit.ι_map (BinaryBiproduct.isColimit W X) _ _ ⟨WalkingPair.right⟩
state_before: J : Type w
C : Type u
inst✝³ : Category C
inst✝² : HasZeroMorphisms C
P Q W X Y Z : C
inst✝¹ : HasBinaryBiproduct W X
inst✝ : HasBinaryBiproduct Y Z
f : W ⟶ Y
g : X ⟶ Z
⊢ inr ≫ map' f g = g ≫ inr
Theorem: Matrix.rank_vecMulVec
File: Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean

tactic: rw [Matrix.vecMulVec_eq, Matrix.toLin'_mul]
state_before: R : Type u
M : Type v
N : Type w
K m n : Type u
inst✝³ : CommRing K
inst✝² : StrongRankCondition K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
⊢ LinearMap.rank (↑toLin' (vecMulVec w v)) ≤ 1

tactic: refine' le_trans (LinearMap.rank_comp_le_left _ _) _
state_before: R : Type u
M : Type v
N : Type w
K m n : Type u
inst✝³ : CommRing K
inst✝² : StrongRankCondition K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
⊢ LinearMap.rank (LinearMap.comp (↑toLin' (col w)) (↑toLin' (row v))) ≤ 1

tactic: refine' (LinearMap.rank_le_domain _).trans_eq _
state_before: R : Type u
M : Type v
N : Type w
K m n : Type u
inst✝³ : CommRing K
inst✝² : StrongRankCondition K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
⊢ LinearMap.rank (↑toLin' (col w)) ≤ 1

tactic: rw [rank_fun', Fintype.card_unit, Nat.cast_one]
state_before: R : Type u
M : Type v
N : Type w
K m n : Type u
inst✝³ : CommRing K
inst✝² : StrongRankCondition K
inst✝¹ : Fintype n
inst✝ : DecidableEq n
w : m → K
v : n → K
⊢ Module.rank K (Unit → K) = 1
Theorem: Ideal.IsHomogeneous.iSup
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp_rw [iff_exists] at h⊢
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.122146
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
h : ∀ (i : κ), IsHomogeneous 𝒜 (f i)
⊢ IsHomogeneous 𝒜 (⨆ (i : κ), f i)

tactic: choose s hs using h
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.122146
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
h : ∀ (i : κ), ∃ S, f i = span (Subtype.val '' S)
⊢ ∃ S, (⨆ (i : κ), f i) = span (Subtype.val '' S)

tactic: refine' ⟨⋃ i, s i, _⟩
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.122146
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
s : κ → Set { x // x ∈ homogeneousSubmonoid 𝒜 }
hs : ∀ (i : κ), f i = span (Subtype.val '' s i)
⊢ ∃ S, (⨆ (i : κ), f i) = span (Subtype.val '' S)

tactic: simp_rw [Set.image_iUnion, Ideal.span_iUnion]
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.122146
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
s : κ → Set { x // x ∈ homogeneousSubmonoid 𝒜 }
hs : ∀ (i : κ), f i = span (Subtype.val '' s i)
⊢ (⨆ (i : κ), f i) = span (Subtype.val '' ⋃ (i : κ), s i)

tactic: congr
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.122146
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
s : κ → Set { x // x ∈ homogeneousSubmonoid 𝒜 }
hs : ∀ (i : κ), f i = span (Subtype.val '' s i)
⊢ (⨆ (i : κ), f i) = ⨆ (i : κ), span (Subtype.val '' s i)

tactic: exact funext hs
state_before: case e_s
ι : Type u_3
σ : Type u_4
R : Type ?u.122146
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
s : κ → Set { x // x ∈ homogeneousSubmonoid 𝒜 }
hs : ∀ (i : κ), f i = span (Subtype.val '' s i)
⊢ (fun i => f i) = fun i => span (Subtype.val '' s i)
Theorem: List.indexOf_cons_self
File: Mathlib/Data/List/Basic.lean

tactic: rw [indexOf, findIdx_cons, beq_self_eq_true, cond]
state_before: ι : Type ?u.77495
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ indexOf a (a :: l) = 0
Theorem: CategoryTheory.Functor.map_isPullback
File: Mathlib/CategoryTheory/Limits/Shapes/CommSq.lean

tactic: refine'
  IsPullback.of_isLimit' (F.map_commSq s.toCommSq)
    (IsLimit.equivOfNatIsoOfIso (cospanCompIso F h i) _ _ (WalkingCospan.ext _ _ _)
      (isLimitOfPreserves F s.isLimit))
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : PreservesLimit (cospan h i) F
s : IsPullback f g h i
⊢ IsPullback (F.map f) (F.map g) (F.map h) (F.map i)

tactic: . simp
state_before: case refine'_3
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : PreservesLimit (cospan h i) F
s : IsPullback f g h i
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).π.app WalkingCospan.right =
    (Iso.refl ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).pt).hom ≫
      (CommSq.cone (_ : CommSq (F.map f) (F.map g) (F.map h) (F.map i))).π.app WalkingCospan.right

tactic: rfl
state_before: case refine'_1
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : PreservesLimit (cospan h i) F
s : IsPullback f g h i
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).pt ≅
    (CommSq.cone (_ : CommSq (F.map f) (F.map g) (F.map h) (F.map i))).pt

tactic: simp
state_before: case refine'_2
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : PreservesLimit (cospan h i) F
s : IsPullback f g h i
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).π.app WalkingCospan.left =
    (Iso.refl ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).pt).hom ≫
      (CommSq.cone (_ : CommSq (F.map f) (F.map g) (F.map h) (F.map i))).π.app WalkingCospan.left

tactic: simp
state_before: case refine'_3
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
W X Y Z : C
f : W ⟶ X
g : W ⟶ Y
h : X ⟶ Z
i : Y ⟶ Z
inst✝ : PreservesLimit (cospan h i) F
s : IsPullback f g h i
⊢ ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).π.app WalkingCospan.right =
    (Iso.refl ((Cones.postcompose (cospanCompIso F h i).hom).obj (F.mapCone (IsPullback.cone s))).pt).hom ≫
      (CommSq.cone (_ : CommSq (F.map f) (F.map g) (F.map h) (F.map i))).π.app WalkingCospan.right
Theorem: Stream'.WSeq.exists_of_mem_map
File: Mathlib/Data/Seq/WSeq.lean

tactic: let ⟨o, om, oe⟩ := Seq.exists_of_mem_map h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : IsSeq g
h : b ∈ map f { val := g, property := al }
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: cases' o with a
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : IsSeq g
h : b ∈ map f { val := g, property := al }
o : Option α
om : o ∈ { val := g, property := al }
oe : Option.map f o = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: injection oe with h'
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : IsSeq g
h : b ∈ map f { val := g, property := al }
a : α
om : some a ∈ { val := g, property := al }
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: exact ⟨a, om, h'⟩
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : IsSeq g
h : b ∈ map f { val := g, property := al }
a : α
om : some a ∈ { val := g, property := al }
h' : f a = b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b

tactic: injection oe
state_before: case none
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : IsSeq g
h : b ∈ map f { val := g, property := al }
om : none ∈ { val := g, property := al }
oe : Option.map f none = some b
⊢ ∃ a, a ∈ { val := g, property := al } ∧ f a = b
Theorem: Option.casesOn'_none_coe
File: Mathlib/Data/Option/Basic.lean

tactic: cases o <;> rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.18548
δ : Type ?u.18551
f : Option α → β
o : Option α
⊢ casesOn' o (f none) (f ∘ fun a => some a) = f o
Theorem: Fintype.card_subtype_compl
File: Mathlib/Data/Fintype/Card.lean

tactic: intro
state_before: case H
α : Type u_1
β : Type ?u.58202
γ : Type ?u.58205
inst✝² : Fintype α
p : α → Prop
inst✝¹ : Fintype { x // p x }
inst✝ : Fintype { x // ¬p x }
⊢ ∀ (x : α), x ∈ Set.toFinset (pᶜ) ↔ ¬p x

tactic: simp only [Set.mem_toFinset, Set.mem_compl_iff]
state_before: case H
α : Type u_1
β : Type ?u.58202
γ : Type ?u.58205
inst✝² : Fintype α
p : α → Prop
inst✝¹ : Fintype { x // p x }
inst✝ : Fintype { x // ¬p x }
x✝ : α
⊢ x✝ ∈ Set.toFinset (pᶜ) ↔ ¬p x✝

tactic: rfl
state_before: case H
α : Type u_1
β : Type ?u.58202
γ : Type ?u.58205
inst✝² : Fintype α
p : α → Prop
inst✝¹ : Fintype { x // p x }
inst✝ : Fintype { x // ¬p x }
x✝ : α
⊢ ¬x✝ ∈ p ↔ ¬p x✝
Theorem: Module.End_algebraMap_isUnit_inv_apply_eq_iff
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: apply_fun ⇑h.unit.val using ((Module.End_isUnit_iff _).mp h).injective
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
h : IsUnit (↑(algebraMap R (End R M)) x)
m m' : M
H : m = x • m'
⊢ ↑↑(IsUnit.unit h)⁻¹ (x • m') = m'

tactic: erw [End_isUnit_apply_inv_apply_of_isUnit]
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
h : IsUnit (↑(algebraMap R (End R M)) x)
m m' : M
H : m = x • m'
⊢ ↑↑(IsUnit.unit h) (↑↑(IsUnit.unit h)⁻¹ (x • m')) = ↑↑(IsUnit.unit h) m'

tactic: rfl
state_before: R : Type u
M : Type v
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
x : R
h : IsUnit (↑(algebraMap R (End R M)) x)
m m' : M
H : m = x • m'
⊢ x • m' = ↑↑(IsUnit.unit h) m'
Theorem: LinearMap.ofIsCompl_smul
File: Mathlib/LinearAlgebra/Projection.lean

tactic: simp
state_before: R✝ : Type ?u.297453
inst✝¹⁴ : Ring R✝
E✝ : Type ?u.297459
inst✝¹³ : AddCommGroup E✝
inst✝¹² : Module R✝ E✝
F✝ : Type ?u.298018
inst✝¹¹ : AddCommGroup F✝
inst✝¹⁰ : Module R✝ F✝
G : Type ?u.298534
inst✝⁹ : AddCommGroup G
inst✝⁸ : Module R✝ G
p✝ q✝ : Submodule R✝ E✝
S : Type ?u.299497
inst✝⁷ : Semiring S
M : Type ?u.299503
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module S M
m : Submodule S M
R : Type u_1
inst✝⁴ : CommRing R
E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module R E
F : Type u_3
inst✝¹ : AddCommGroup F
inst✝ : Module R F
p q : Submodule R E
h : IsCompl p q
φ : { x // x ∈ p } →ₗ[R] F
ψ : { x // x ∈ q } →ₗ[R] F
c : R
⊢ ∀ (u : { x // x ∈ p }), ↑(c • φ) u = ↑(c • ofIsCompl h φ ψ) ↑u

tactic: simp
state_before: R✝ : Type ?u.297453
inst✝¹⁴ : Ring R✝
E✝ : Type ?u.297459
inst✝¹³ : AddCommGroup E✝
inst✝¹² : Module R✝ E✝
F✝ : Type ?u.298018
inst✝¹¹ : AddCommGroup F✝
inst✝¹⁰ : Module R✝ F✝
G : Type ?u.298534
inst✝⁹ : AddCommGroup G
inst✝⁸ : Module R✝ G
p✝ q✝ : Submodule R✝ E✝
S : Type ?u.299497
inst✝⁷ : Semiring S
M : Type ?u.299503
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module S M
m : Submodule S M
R : Type u_1
inst✝⁴ : CommRing R
E : Type u_2
inst✝³ : AddCommGroup E
inst✝² : Module R E
F : Type u_3
inst✝¹ : AddCommGroup F
inst✝ : Module R F
p q : Submodule R E
h : IsCompl p q
φ : { x // x ∈ p } →ₗ[R] F
ψ : { x // x ∈ q } →ₗ[R] F
c : R
⊢ ∀ (u : { x // x ∈ q }), ↑(c • ψ) u = ↑(c • ofIsCompl h φ ψ) ↑u