1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: FirstOrder.Language.Substructure.fg_iff_exists_fin_generating_family
File: Mathlib/ModelTheory/FinitelyGenerated.lean

tactic: rw [fg_def]
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ N.FG ↔ ∃ n s, (closure L).toFun (range s) = N
state_after: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Finite ∧ (closure L).toFun S = N) ↔ ∃ n s, (closure L).toFun (range s) = N

tactic: constructor
state_before: L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Finite ∧ (closure L).toFun S = N) ↔ ∃ n s, (closure L).toFun (range s) = N
state_after: case mp
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Finite ∧ (closure L).toFun S = N) → ∃ n s, (closure L).toFun (range s) = N

case mpr
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ n s, (closure L).toFun (range s) = N) → ∃ S, S.Finite ∧ (closure L).toFun S = N

tactic: rintro ⟨S, Sfin, hS⟩
state_before: case mp
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ S, S.Finite ∧ (closure L).toFun S = N) → ∃ n s, (closure L).toFun (range s) = N
state_after: case mp.intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
S : Set M
Sfin : S.Finite
hS : (closure L).toFun S = N
⊢ ∃ n s, (closure L).toFun (range s) = N

tactic: obtain ⟨n, f, rfl⟩ := Sfin.fin_embedding
state_before: case mp.intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
S : Set M
Sfin : S.Finite
hS : (closure L).toFun S = N
⊢ ∃ n s, (closure L).toFun (range s) = N
state_after: case mp.intro.intro.intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
n : ℕ
f : Fin n ↪ M
Sfin : (range ⇑f).Finite
hS : (closure L).toFun (range ⇑f) = N
⊢ ∃ n s, (closure L).toFun (range s) = N

tactic: exact ⟨n, f, hS⟩
state_before: case mp.intro.intro.intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
n : ℕ
f : Fin n ↪ M
Sfin : (range ⇑f).Finite
hS : (closure L).toFun (range ⇑f) = N
⊢ ∃ n s, (closure L).toFun (range s) = N
state_after: no goals

tactic: rintro ⟨n, s, hs⟩
state_before: case mpr
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
⊢ (∃ n s, (closure L).toFun (range s) = N) → ∃ S, S.Finite ∧ (closure L).toFun S = N
state_after: case mpr.intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
n : ℕ
s : Fin n → M
hs : (closure L).toFun (range s) = N
⊢ ∃ S, S.Finite ∧ (closure L).toFun S = N

tactic: exact ⟨range s, finite_range s, hs⟩
state_before: case mpr.intro.intro
L : Language
M : Type u_1
inst✝ : L.Structure M
N : L.Substructure M
n : ℕ
s : Fin n → M
hs : (closure L).toFun (range s) = N
⊢ ∃ S, S.Finite ∧ (closure L).toFun S = N
state_after: no goals
Theorem: nhds_nhdsAdjoint_same
File: Mathlib/Topology/Order.lean

tactic: let _ := nhdsAdjoint a f
state_before: α : Type u
β : Type v
a : α
f : Filter α
⊢ 𝓝 a = pure a ⊔ f
state_after: α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a = pure a ⊔ f

tactic: apply le_antisymm
state_before: α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a = pure a ⊔ f
state_after: case a
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a ≤ pure a ⊔ f

case a
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ pure a ⊔ f ≤ 𝓝 a

tactic: rintro t ⟨hat : a ∈ t, htf : t ∈ f⟩
state_before: case a
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ 𝓝 a ≤ pure a ⊔ f
state_after: case a.intro
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
t : Set α
hat : a ∈ t
htf : t ∈ f
⊢ t ∈ 𝓝 a

tactic: exact IsOpen.mem_nhds (fun _ ↦ htf) hat
state_before: case a.intro
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
t : Set α
hat : a ∈ t
htf : t ∈ f
⊢ t ∈ 𝓝 a
state_after: no goals

tactic: exact sup_le (pure_le_nhds _) ((gc_nhds a).le_u_l f)
state_before: case a
α : Type u
β : Type v
a : α
f : Filter α
x✝ : TopologicalSpace α := nhdsAdjoint a f
⊢ pure a ⊔ f ≤ 𝓝 a
state_after: no goals
Theorem: Metric.eventually_isCompact_closedBall
File: Mathlib/Topology/MetricSpace/Pseudo/Lemmas.lean

tactic: rcases exists_compact_mem_nhds x with ⟨s, s_compact, hs⟩
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, IsCompact (closedBall x r)
state_after: case intro.intro
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, IsCompact (closedBall x r)

tactic: filter_upwards [eventually_closedBall_subset hs] with r hr
state_before: case intro.intro
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
⊢ ∀ᶠ (r : ℝ) in 𝓝 0, IsCompact (closedBall x r)
state_after: case h
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
r : ℝ
hr : closedBall x r ⊆ s
⊢ IsCompact (closedBall x r)

tactic: exact IsCompact.of_isClosed_subset s_compact isClosed_ball hr
state_before: case h
ι : Type u_1
α : Type u_2
inst✝¹ : PseudoMetricSpace α
x✝ y z : α
ε ε₁ ε₂ : ℝ
s✝ : Set α
inst✝ : WeaklyLocallyCompactSpace α
x : α
s : Set α
s_compact : IsCompact s
hs : s ∈ 𝓝 x
r : ℝ
hr : closedBall x r ⊆ s
⊢ IsCompact (closedBall x r)
state_after: no goals
Theorem: Complex.cpow_ofReal
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases eq_or_ne x 0 with rfl | hx
state_before: x : ℂ
y : ℝ
⊢ x ^ ↑y = ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)
state_after: case inl
y : ℝ
⊢ 0 ^ ↑y = ↑(abs 0 ^ y) * (↑(Real.cos (arg 0 * y)) + ↑(Real.sin (arg 0 * y)) * I)

case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ x ^ ↑y = ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)

tactic: simp [ofReal_cpow le_rfl]
state_before: case inl
y : ℝ
⊢ 0 ^ ↑y = ↑(abs 0 ^ y) * (↑(Real.cos (arg 0 * y)) + ↑(Real.sin (arg 0 * y)) * I)
state_after: no goals

tactic: rw [cpow_def_of_ne_zero hx, exp_eq_exp_re_mul_sin_add_cos, mul_comm (log x)]
state_before: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ x ^ ↑y = ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)
state_after: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ cexp ↑(↑y * log x).re * (cos ↑(↑y * log x).im + sin ↑(↑y * log x).im * I) =
    ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)

tactic: norm_cast
state_before: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ cexp ↑(↑y * log x).re * (cos ↑(↑y * log x).im + sin ↑(↑y * log x).im * I) =
    ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)
state_after: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ ↑(rexp (↑y * log x).re) * (↑(Real.cos (↑y * log x).im) + ↑(Real.sin (↑y * log x).im) * I) =
    ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)

tactic: rw [re_ofReal_mul, im_ofReal_mul, log_re, log_im, mul_comm y, mul_comm y, Real.exp_mul,
  Real.exp_log]
state_before: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ ↑(rexp (↑y * log x).re) * (↑(Real.cos (↑y * log x).im) + ↑(Real.sin (↑y * log x).im) * I) =
    ↑(abs x ^ y) * (↑(Real.cos (x.arg * y)) + ↑(Real.sin (x.arg * y)) * I)
state_after: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ 0 < abs x

tactic: rwa [abs.pos_iff]
state_before: case inr
x : ℂ
y : ℝ
hx : x ≠ 0
⊢ 0 < abs x
state_after: no goals
Theorem: Multiset.Ico_inter_Ico
File: Mathlib/Order/Interval/Multiset.lean

tactic: rw [Ico, Ico, Ico, ← Finset.inter_val, Finset.Ico_inter_Ico]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a b c d : α
⊢ Ico a b ∩ Ico c d = Ico (max a c) (min b d)
state_after: no goals
Theorem: HomologicalComplex₂.ι_totalDesc
File: Mathlib/Algebra/Homology/TotalComplex.lean

tactic: simp [totalDesc, ιTotal]
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
A : C
i₁₂ : I₁₂
f : (i₁ : I₁) → (i₂ : I₂) → c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂ → ((K.X i₁).X i₂ ⟶ A)
i₁ : I₁
i₂ : I₂
hi : c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂
⊢ K.ιTotal c₁₂ i₁ i₂ i₁₂ hi ≫ K.totalDesc f = f i₁ i₂ hi
state_after: no goals
Theorem: continuousWithinAt_union
File: Mathlib/Topology/ContinuousOn.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_union, tendsto_sup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s t : Set α
x : α
⊢ ContinuousWithinAt f (s ∪ t) x ↔ ContinuousWithinAt f s x ∧ ContinuousWithinAt f t x
state_after: no goals
Theorem: Cardinal.aleph0_le_aleph
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [aleph, aleph0_le_aleph']
state_before: o : Ordinal.{u_1}
⊢ ℵ₀ ≤ aleph o
state_after: o : Ordinal.{u_1}
⊢ ω ≤ ω + o

tactic: apply Ordinal.le_add_right
state_before: o : Ordinal.{u_1}
⊢ ω ≤ ω + o
state_after: no goals
Theorem: Cardinal.exists_finset_le_card
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: obtain hα|hα := finite_or_infinite α
state_before: α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
⊢ ∃ s, n ≤ s.card
state_after: case inl
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Finite α
⊢ ∃ s, n ≤ s.card

case inr
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Infinite α
⊢ ∃ s, n ≤ s.card

tactic: let hα := Fintype.ofFinite α
state_before: case inl
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Finite α
⊢ ∃ s, n ≤ s.card
state_after: case inl
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα✝ : Finite α
hα : Fintype α := Fintype.ofFinite α
⊢ ∃ s, n ≤ s.card

tactic: use Finset.univ
state_before: case inl
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα✝ : Finite α
hα : Fintype α := Fintype.ofFinite α
⊢ ∃ s, n ≤ s.card
state_after: case h
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα✝ : Finite α
hα : Fintype α := Fintype.ofFinite α
⊢ n ≤ Finset.univ.card

tactic: simpa only [mk_fintype, Nat.cast_le] using h
state_before: case h
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα✝ : Finite α
hα : Fintype α := Fintype.ofFinite α
⊢ n ≤ Finset.univ.card
state_after: no goals

tactic: obtain ⟨s, hs⟩ := Infinite.exists_subset_card_eq α n
state_before: case inr
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Infinite α
⊢ ∃ s, n ≤ s.card
state_after: case inr.intro
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Infinite α
s : Finset α
hs : s.card = n
⊢ ∃ s, n ≤ s.card

tactic: exact ⟨s, hs.ge⟩
state_before: case inr.intro
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Infinite α
s : Finset α
hs : s.card = n
⊢ ∃ s, n ≤ s.card
state_after: no goals
Theorem: IsPrimitiveRoot.geom_sum_eq_zero
File: Mathlib/RingTheory/RootsOfUnity/Basic.lean

tactic: refine eq_zero_of_ne_zero_of_mul_left_eq_zero (sub_ne_zero_of_ne (hζ.ne_one hk).symm) ?_
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
hζ : IsPrimitiveRoot ζ k
hk : 1 < k
⊢ ∑ i ∈ range k, ζ ^ i = 0
state_after: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
hζ : IsPrimitiveRoot ζ k
hk : 1 < k
⊢ (1 - ζ) * ∑ i ∈ range k, ζ ^ i = 0

tactic: rw [mul_neg_geom_sum, hζ.pow_eq_one, sub_self]
state_before: M : Type u_1
N : Type u_2
G : Type u_3
R : Type u_4
S : Type u_5
F : Type u_6
inst✝⁴ : CommMonoid M
inst✝³ : CommMonoid N
inst✝² : DivisionCommMonoid G
k l : ℕ
inst✝¹ : CommRing R
ζ✝ : Rˣ
h : IsPrimitiveRoot ζ✝ k
inst✝ : IsDomain R
ζ : R
hζ : IsPrimitiveRoot ζ k
hk : 1 < k
⊢ (1 - ζ) * ∑ i ∈ range k, ζ ^ i = 0
state_after: no goals
Theorem: latticeClosure_singleton
File: Mathlib/Order/SupClosed.lean

tactic: simp
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝ : Lattice α
s t : Set α
a : α
⊢ latticeClosure {a} = {a}
state_after: no goals
Theorem: Finset.uIcc_subset_uIcc
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [mem_uIcc] at h₁ h₂
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₁ ∈ [[a₂, b₂]]
h₂ : b₁ ∈ [[a₂, b₂]]
⊢ [[a₁, b₁]] ⊆ [[a₂, b₂]]
state_after: ι : Type u_1
α : Type u_2
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₂ ⊓ b₂ ≤ a₁ ∧ a₁ ≤ a₂ ⊔ b₂
h₂ : a₂ ⊓ b₂ ≤ b₁ ∧ b₁ ≤ a₂ ⊔ b₂
⊢ [[a₁, b₁]] ⊆ [[a₂, b₂]]

tactic: exact Icc_subset_Icc (_root_.le_inf h₁.1 h₂.1) (_root_.sup_le h₁.2 h₂.2)
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : Lattice α
inst✝ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
h₁ : a₂ ⊓ b₂ ≤ a₁ ∧ a₁ ≤ a₂ ⊔ b₂
h₂ : a₂ ⊓ b₂ ≤ b₁ ∧ b₁ ≤ a₂ ⊔ b₂
⊢ [[a₁, b₁]] ⊆ [[a₂, b₂]]
state_after: no goals
Theorem: t2Space_iff_disjoint_nhds
File: Mathlib/Topology/Separation.lean

tactic: refine (t2Space_iff X).trans (forall₃_congr fun x y _ => ?_)
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
⊢ T2Space X ↔ Pairwise fun x y => Disjoint (𝓝 x) (𝓝 y)
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
x y : X
x✝ : x ≠ y
⊢ (fun x y => ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v) x y ↔ (fun x y => Disjoint (𝓝 x) (𝓝 y)) x y

tactic: simp only [(nhds_basis_opens x).disjoint_iff (nhds_basis_opens y), exists_prop, ← exists_and_left,
  and_assoc, and_comm, and_left_comm]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : FirstCountableTopology X
x y : X
x✝ : x ≠ y
⊢ (fun x y => ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v) x y ↔ (fun x y => Disjoint (𝓝 x) (𝓝 y)) x y
state_after: no goals
Theorem: CoxeterSystem.exists_reduced_word
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: have := Nat.find_spec (cs.exists_word_with_prod w)
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
this : ∃ ω, ω.length = Nat.find ⋯ ∧ cs.wordProd ω = w
⊢ ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω

tactic: tauto
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
this : ∃ ω, ω.length = Nat.find ⋯ ∧ cs.wordProd ω = w
⊢ ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω
state_after: no goals
Theorem: LinearMap.comp_zero
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

tactic: rw [comp_apply, zero_apply, zero_apply, g.map_zero]
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹⁵ : Semiring R₁
inst✝¹⁴ : Semiring R₂
inst✝¹³ : Semiring R₃
inst✝¹² : AddCommMonoid M
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommGroup N₁
inst✝⁸ : AddCommGroup N₂
inst✝⁷ : AddCommGroup N₃
inst✝⁶ : Module R₁ M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
inst✝³ : Module R₁ N₁
inst✝² : Module R₂ N₂
inst✝¹ : Module R₃ N₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
g : M₂ →ₛₗ[σ₂₃] M₃
c : M
⊢ (g.comp 0) c = 0 c
state_after: no goals
Theorem: Function.apply_update
File: Mathlib/Logic/Function/Basic.lean

tactic: by_cases h:j = i
state_before: α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
j : ι
⊢ f j (update g i v j) = update (fun k => f k (g k)) i (f i v) j
state_after: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
j : ι
h : j = i
⊢ f j (update g i v j) = update (fun k => f k (g k)) i (f i v) j

case neg
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
j : ι
h : ¬j = i
⊢ f j (update g i v j) = update (fun k => f k (g k)) i (f i v) j

tactic: subst j
state_before: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
j : ι
h : j = i
⊢ f j (update g i v j) = update (fun k => f k (g k)) i (f i v) j
state_after: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
⊢ f i (update g i v i) = update (fun k => f k (g k)) i (f i v) i

tactic: simp
state_before: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
⊢ f i (update g i v i) = update (fun k => f k (g k)) i (f i v) i
state_after: no goals

tactic: simp [h]
state_before: case neg
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
f : (i : ι) → α i → β i
g : (i : ι) → α i
i : ι
v : α i
j : ι
h : ¬j = i
⊢ f j (update g i v j) = update (fun k => f k (g k)) i (f i v) j
state_after: no goals
Theorem: PNat.card_fintype_Ico
File: Mathlib/Data/PNat/Interval.lean

tactic: rw [← card_Ico, Fintype.card_ofFinset]
state_before: a b : ℕ+
⊢ Fintype.card ↑(Set.Ico a b) = ↑b - ↑a
state_after: no goals
Theorem: LieAlgebra.Orthogonal.jd_transform
File: Mathlib/Algebra/Lie/Classical.lean

tactic: have h : (PD l R)ᵀ * JD l R = Matrix.fromBlocks 1 1 1 (-1) := by
  simp [PD, JD, Matrix.fromBlocks_transpose, Matrix.fromBlocks_multiply]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
⊢ (PD l R)ᵀ * JD l R * PD l R = 2 • S l R
state_after: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
h : (PD l R)ᵀ * JD l R = fromBlocks 1 1 1 (-1)
⊢ (PD l R)ᵀ * JD l R * PD l R = 2 • S l R

tactic: rw [h, PD, s_as_blocks, Matrix.fromBlocks_multiply, Matrix.fromBlocks_smul]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
h : (PD l R)ᵀ * JD l R = fromBlocks 1 1 1 (-1)
⊢ (PD l R)ᵀ * JD l R * PD l R = 2 • S l R
state_after: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
h : (PD l R)ᵀ * JD l R = fromBlocks 1 1 1 (-1)
⊢ fromBlocks (1 * 1 + 1 * 1) (1 * -1 + 1 * 1) (1 * 1 + -1 * 1) (1 * -1 + -1 * 1) =
    fromBlocks (2 • 1) (2 • 0) (2 • 0) (2 • -1)

tactic: simp [two_smul]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
h : (PD l R)ᵀ * JD l R = fromBlocks 1 1 1 (-1)
⊢ fromBlocks (1 * 1 + 1 * 1) (1 * -1 + 1 * 1) (1 * 1 + -1 * 1) (1 * -1 + -1 * 1) =
    fromBlocks (2 • 1) (2 • 0) (2 • 0) (2 • -1)
state_after: no goals

tactic: simp [PD, JD, Matrix.fromBlocks_transpose, Matrix.fromBlocks_multiply]
state_before: n : Type u_1
p : Type u_2
q : Type u_3
l : Type u_4
R : Type u₂
inst✝⁷ : DecidableEq n
inst✝⁶ : DecidableEq p
inst✝⁵ : DecidableEq q
inst✝⁴ : DecidableEq l
inst✝³ : CommRing R
inst✝² : Fintype p
inst✝¹ : Fintype q
inst✝ : Fintype l
⊢ (PD l R)ᵀ * JD l R = fromBlocks 1 1 1 (-1)
state_after: no goals
Theorem: LieSubmodule.mem_iInf
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← SetLike.mem_coe, iInf_coe, Set.mem_iInter]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
ι : Sort u_1
p : ι → LieSubmodule R L M
x : M
⊢ x ∈ ⨅ i, p i ↔ ∀ (i : ι), x ∈ p i
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
ι : Sort u_1
p : ι → LieSubmodule R L M
x : M
⊢ (∀ (i : ι), x ∈ ↑(p i)) ↔ ∀ (i : ι), x ∈ p i

tactic: rfl
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
ι : Sort u_1
p : ι → LieSubmodule R L M
x : M
⊢ (∀ (i : ι), x ∈ ↑(p i)) ↔ ∀ (i : ι), x ∈ p i
state_after: no goals
Theorem: LinearEquiv.toSpanNonzeroSingleton_apply
File: Mathlib/LinearAlgebra/Span.lean

tactic: 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✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : NoZeroSMulDivisors R M
x : M
h : x ≠ 0
t : R
⊢ (toSpanNonzeroSingleton R M x h) t = ⟨t • x, ⋯⟩
state_after: no goals