1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Ideal.ideal_prod_eq
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: apply Ideal.ext
state_before: R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ I = (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)
state_after: case h
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ ∀ (x : R × S), x ∈ I ↔ x ∈ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)

tactic: rintro ⟨r, s⟩
state_before: case h
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
⊢ ∀ (x : R × S), x ∈ I ↔ x ∈ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)
state_after: case h.mk
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ (r, s) ∈ I ↔ (r, s) ∈ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)

tactic: rw [mem_prod, mem_map_iff_of_surjective (RingHom.fst R S) Prod.fst_surjective,
  mem_map_iff_of_surjective (RingHom.snd R S) Prod.snd_surjective]
state_before: case h.mk
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ (r, s) ∈ I ↔ (r, s) ∈ (map (RingHom.fst R S) I).prod (map (RingHom.snd R S) I)
state_after: case h.mk
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ (r, s) ∈ I ↔ (∃ x ∈ I, (RingHom.fst R S) x = r) ∧ ∃ x ∈ I, (RingHom.snd R S) x = s

tactic: refine ⟨fun h => ⟨⟨_, ⟨h, rfl⟩⟩, ⟨_, ⟨h, rfl⟩⟩⟩, ?_⟩
state_before: case h.mk
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ (r, s) ∈ I ↔ (∃ x ∈ I, (RingHom.fst R S) x = r) ∧ ∃ x ∈ I, (RingHom.snd R S) x = s
state_after: case h.mk
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ ((∃ x ∈ I, (RingHom.fst R S) x = r) ∧ ∃ x ∈ I, (RingHom.snd R S) x = s) → (r, s) ∈ I

tactic: rintro ⟨⟨⟨r, s'⟩, ⟨h₁, rfl⟩⟩, ⟨⟨r', s⟩, ⟨h₂, rfl⟩⟩⟩
state_before: case h.mk
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s : S
⊢ ((∃ x ∈ I, (RingHom.fst R S) x = r) ∧ ∃ x ∈ I, (RingHom.snd R S) x = s) → (r, s) ∈ I
state_after: case h.mk.intro.intro.mk.intro.intro.mk.intro
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s' : S
h₁ : (r, s') ∈ I
r' : R
s : S
h₂ : (r', s) ∈ I
⊢ ((RingHom.fst R S) (r, s'), (RingHom.snd R S) (r', s)) ∈ I

tactic: simpa using I.add_mem (I.mul_mem_left (1, 0) h₁) (I.mul_mem_left (0, 1) h₂)
state_before: case h.mk.intro.intro.mk.intro.intro.mk.intro
R : Type u
S : Type v
inst✝¹ : Semiring R
inst✝ : Semiring S
I✝ I' : Ideal R
J J' : Ideal S
I : Ideal (R × S)
r : R
s' : S
h₁ : (r, s') ∈ I
r' : R
s : S
h₂ : (r', s) ∈ I
⊢ ((RingHom.fst R S) (r, s'), (RingHom.snd R S) (r', s)) ∈ I
state_after: no goals
Theorem: Equiv.Perm.finRotate_bit1_mem_alternatingGroup
File: Mathlib/GroupTheory/SpecificGroups/Alternating.lean

tactic: rw [mem_alternatingGroup, bit1, sign_finRotate, pow_bit0', Int.units_mul_self, one_pow]
state_before: α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
n : ℕ
⊢ finRotate (bit1 n) ∈ alternatingGroup (Fin (bit1 n))
state_after: no goals
Theorem: div_le_div
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [div_le_div_iff (hd.trans_le hbd) hd]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a / b ≤ c / d
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a * d ≤ c * b

tactic: exact mul_le_mul hac hbd hd.le hc
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hc : 0 ≤ c
hac : a ≤ c
hd : 0 < d
hbd : d ≤ b
⊢ a * d ≤ c * b
state_after: no goals
Theorem: MeasureTheory.AEDisjoint.symm
File: Mathlib/MeasureTheory/Measure/AEDisjoint.lean

tactic: rwa [AEDisjoint, inter_comm]
state_before: ι : Type u_1
α : Type u_2
m : MeasurableSpace α
μ : Measure α
s t u v : Set α
h : AEDisjoint μ s t
⊢ AEDisjoint μ t s
state_after: no goals
Theorem: Finset.subtype_eq_empty
File: Mathlib/Data/Finset/Image.lean

tactic: simp [ext_iff, Subtype.forall, Subtype.coe_mk]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ Finset.subtype p s = ∅ ↔ ∀ (x : α), p x → x ∉ s
state_after: no goals
Theorem: Substring.Valid.data_take
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: simp [(h.take _).toString, h.toString]
state_before: x✝¹ : Substring
h✝ : x✝¹.Valid
x✝ : Nat
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝¹
⊢ (x✝¹.take x✝).toString.data = List.take x✝ x✝¹.toString.data
state_after: no goals
Theorem: Module.Baer.chain_linearPMap_of_chain_extensionOf
File: Mathlib/Algebra/Module/Injective.lean

tactic: rintro _ ⟨a, a_mem, rfl⟩ _ ⟨b, b_mem, rfl⟩ neq
state_before: R : Type u
inst✝⁶ : Ring R
Q : Type v
inst✝⁵ : AddCommGroup Q
inst✝⁴ : Module R Q
M : Type u_1
N : Type u_2
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
c : Set (ExtensionOf i f)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
⊢ IsChain (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) '' c)
state_after: case intro.intro.intro.intro
R : Type u
inst✝⁶ : Ring R
Q : Type v
inst✝⁵ : AddCommGroup Q
inst✝⁴ : Module R Q
M : Type u_1
N : Type u_2
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
c : Set (ExtensionOf i f)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
a : ExtensionOf i f
a_mem : a ∈ c
b : ExtensionOf i f
b_mem : b ∈ c
neq : (fun x => x.toLinearPMap) a ≠ (fun x => x.toLinearPMap) b
⊢ (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) a) ((fun x => x.toLinearPMap) b) ∨
    (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) b) ((fun x => x.toLinearPMap) a)

tactic: exact hchain a_mem b_mem (ne_of_apply_ne _ neq)
state_before: case intro.intro.intro.intro
R : Type u
inst✝⁶ : Ring R
Q : Type v
inst✝⁵ : AddCommGroup Q
inst✝⁴ : Module R Q
M : Type u_1
N : Type u_2
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
i : M →ₗ[R] N
f : M →ₗ[R] Q
c : Set (ExtensionOf i f)
hchain : IsChain (fun x x_1 => x ≤ x_1) c
a : ExtensionOf i f
a_mem : a ∈ c
b : ExtensionOf i f
b_mem : b ∈ c
neq : (fun x => x.toLinearPMap) a ≠ (fun x => x.toLinearPMap) b
⊢ (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) a) ((fun x => x.toLinearPMap) b) ∨
    (fun x x_1 => x ≤ x_1) ((fun x => x.toLinearPMap) b) ((fun x => x.toLinearPMap) a)
state_after: no goals
Theorem: min_eq_left
File: Mathlib/Init/Order/LinearOrder.lean

tactic: apply Eq.symm
state_before: α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ min a b = a
state_after: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ a = min a b

tactic: apply eq_min (le_refl _) h
state_before: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ a = min a b
state_after: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ ∀ {d : α}, d ≤ a → d ≤ b → d ≤ a

tactic: intros
state_before: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
⊢ ∀ {d : α}, d ≤ a → d ≤ b → d ≤ a
state_after: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
d✝ : α
a✝¹ : d✝ ≤ a
a✝ : d✝ ≤ b
⊢ d✝ ≤ a

tactic: assumption
state_before: case h
α : Type u
inst✝ : LinearOrder α
a b : α
h : a ≤ b
d✝ : α
a✝¹ : d✝ ≤ a
a✝ : d✝ ≤ b
⊢ d✝ ≤ a
state_after: no goals
Theorem: Set.PairwiseDisjoint.subset_of_biUnion_subset_biUnion
File: Mathlib/Data/Set/Pairwise/Lattice.lean

tactic: rintro i hi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
⊢ s ⊆ t
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
i : ι
hi : i ∈ s
⊢ i ∈ t

tactic: obtain ⟨a, hai⟩ := h₁ i hi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
i : ι
hi : i ∈ s
⊢ i ∈ t
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
i : ι
hi : i ∈ s
a : α
hai : a ∈ f i
⊢ i ∈ t

tactic: obtain ⟨j, hj, haj⟩ := mem_iUnion₂.1 (h <| mem_iUnion₂_of_mem hi hai)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
i : ι
hi : i ∈ s
a : α
hai : a ∈ f i
⊢ i ∈ t
state_after: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
i : ι
hi : i ∈ s
a : α
hai : a ∈ f i
j : ι
hj : j ∈ t
haj : a ∈ f j
⊢ i ∈ t

tactic: rwa [h₀.eq (subset_union_left hi) (subset_union_right hj)
    (not_disjoint_iff.2 ⟨a, hai, haj⟩)]
state_before: case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
κ : Sort u_6
r p q : α → α → Prop
f : ι → Set α
s t : Set ι
h₀ : (s ∪ t).PairwiseDisjoint f
h₁ : ∀ i ∈ s, (f i).Nonempty
h : ⋃ i ∈ s, f i ⊆ ⋃ i ∈ t, f i
i : ι
hi : i ∈ s
a : α
hai : a ∈ f i
j : ι
hj : j ∈ t
haj : a ∈ f j
⊢ i ∈ t
state_after: no goals
Theorem: MeasureTheory.Integrable.to_average
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rcases eq_or_ne μ 0 with (rfl | hne)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
⊢ Integrable f ((μ univ)⁻¹ • μ)
state_after: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f 0
⊢ Integrable f ((0 univ)⁻¹ • 0)

case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
hne : μ ≠ 0
⊢ Integrable f ((μ univ)⁻¹ • μ)

tactic: rwa [smul_zero]
state_before: case inl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f 0
⊢ Integrable f ((0 univ)⁻¹ • 0)
state_after: no goals

tactic: apply h.smul_measure
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
hne : μ ≠ 0
⊢ Integrable f ((μ univ)⁻¹ • μ)
state_after: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
hne : μ ≠ 0
⊢ (μ univ)⁻¹ ≠ ⊤

tactic: simpa
state_before: case inr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
h : Integrable f μ
hne : μ ≠ 0
⊢ (μ univ)⁻¹ ≠ ⊤
state_after: no goals
Theorem: Rat.divInt_mul_right
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: simp [← divInt_mul_left (d := d) a0, Int.mul_comm]
state_before: n d a : Int
a0 : a ≠ 0
⊢ n * a /. (d * a) = n /. d
state_after: no goals
Theorem: TopologicalSpace.IsSeparable.prod
File: Mathlib/Topology/Bases.lean

tactic: rcases hs with ⟨cs, cs_count, hcs⟩
state_before: α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
hs : IsSeparable s
ht : IsSeparable t
⊢ IsSeparable (s ×ˢ t)
state_after: case intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
ht : IsSeparable t
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
⊢ IsSeparable (s ×ˢ t)

tactic: rcases ht with ⟨ct, ct_count, hct⟩
state_before: case intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
ht : IsSeparable t
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
⊢ IsSeparable (s ×ˢ t)
state_after: case intro.intro.intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
ct : Set β
ct_count : ct.Countable
hct : t ⊆ closure ct
⊢ IsSeparable (s ×ˢ t)

tactic: refine ⟨cs ×ˢ ct, cs_count.prod ct_count, ?_⟩
state_before: case intro.intro.intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
ct : Set β
ct_count : ct.Countable
hct : t ⊆ closure ct
⊢ IsSeparable (s ×ˢ t)
state_after: case intro.intro.intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
ct : Set β
ct_count : ct.Countable
hct : t ⊆ closure ct
⊢ s ×ˢ t ⊆ closure (cs ×ˢ ct)

tactic: rw [closure_prod_eq]
state_before: case intro.intro.intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
ct : Set β
ct_count : ct.Countable
hct : t ⊆ closure ct
⊢ s ×ˢ t ⊆ closure (cs ×ˢ ct)
state_after: case intro.intro.intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
ct : Set β
ct_count : ct.Countable
hct : t ⊆ closure ct
⊢ s ×ˢ t ⊆ closure cs ×ˢ closure ct

tactic: gcongr
state_before: case intro.intro.intro.intro
α : Type u
β✝ : Type u_1
t✝ : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
β : Type u_2
inst✝ : TopologicalSpace β
s : Set α
t : Set β
cs : Set α
cs_count : cs.Countable
hcs : s ⊆ closure cs
ct : Set β
ct_count : ct.Countable
hct : t ⊆ closure ct
⊢ s ×ˢ t ⊆ closure cs ×ˢ closure ct
state_after: no goals
Theorem: Polynomial.degree_X_sub_C
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [sub_eq_add_neg, ← map_neg C a, degree_X_add_C]
state_before: R : Type u
S : Type v
a✝ b c d : R
n m : ℕ
inst✝¹ : Ring R
inst✝ : Nontrivial R
a : R
⊢ (X - C a).degree = 1
state_after: no goals
Theorem: Num.cmp_eq
File: Mathlib/Data/Num/Lemmas.lean

tactic: have := cmp_to_nat m n
state_before: α : Type u_1
m n : Num
⊢ m.cmp n = Ordering.eq ↔ m = n
state_after: α : Type u_1
m n : Num
this : Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ m.cmp n = Ordering.eq ↔ m = n

tactic: revert this
state_before: α : Type u_1
m n : Num
this : Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m)
⊢ m.cmp n = Ordering.eq ↔ m = n
state_after: α : Type u_1
m n : Num
⊢ Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m) → (m.cmp n = Ordering.eq ↔ m = n)

tactic: cases cmp m n <;> intro this <;> simp at this ⊢ <;> try { exact this } <;>
simp [show m ≠ n from fun e => by rw [e] at this; exact lt_irrefl _ this]
state_before: α : Type u_1
m n : Num
⊢ Ordering.casesOn (m.cmp n) (↑m < ↑n) (m = n) (↑n < ↑m) → (m.cmp n = Ordering.eq ↔ m = n)
state_after: no goals

tactic: exact this
state_before: case eq
α : Type u_1
m n : Num
this : m = n
⊢ m = n
state_after: no goals

tactic: rw [e] at this
state_before: α : Type u_1
m n : Num
this : ↑n < ↑m
e : m = n
⊢ False
state_after: α : Type u_1
m n : Num
this : ↑n < ↑n
e : m = n
⊢ False

tactic: exact lt_irrefl _ this
state_before: α : Type u_1
m n : Num
this : ↑n < ↑n
e : m = n
⊢ False
state_after: no goals
Theorem: FractionalIdeal.count_one
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: have h1 : (1 : FractionalIdeal R⁰ K) =
    spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑(1 : Ideal R) := by
  rw [(algebraMap R K).map_one, Ideal.one_eq_top, coeIdeal_top, mul_one, inv_one,
    spanSingleton_one]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
⊢ count K v 1 = 0
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
h1 : 1 = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑1
⊢ count K v 1 = 0

tactic: rw [count_well_defined K v one_ne_zero h1, Ideal.span_singleton_one, Ideal.one_eq_top, sub_self]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
h1 : 1 = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑1
⊢ count K v 1 = 0
state_after: no goals

tactic: rw [(algebraMap R K).map_one, Ideal.one_eq_top, coeIdeal_top, mul_one, inv_one,
  spanSingleton_one]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
⊢ 1 = spanSingleton R⁰ ((algebraMap R K) 1)⁻¹ * ↑1
state_after: no goals
Theorem: List.permutations_append
File: Mathlib/Data/List/Permutation.lean

tactic: simp [permutations, permutationsAux_append]
state_before: α : Type u_1
β : Type u_2
is ts : List α
⊢ (is ++ ts).permutations = map (fun x => x ++ ts) is.permutations ++ ts.permutationsAux is.reverse
state_after: no goals
Theorem: Fin.card_uIcc
File: Mathlib/Order/Interval/Finset/Fin.lean

tactic: rw [← Nat.card_uIcc, ← map_subtype_embedding_uIcc, card_map]
state_before: n : ℕ
a b : Fin n
⊢ (uIcc a b).card = (↑↑b - ↑↑a).natAbs + 1
state_after: no goals
Theorem: pow_mem
File: Mathlib/Algebra/Group/Submonoid/Basic.lean

tactic: rw [pow_zero]
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
⊢ x ^ 0 ∈ S
state_after: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
⊢ 1 ∈ S

tactic: exact OneMemClass.one_mem S
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
⊢ 1 ∈ S
state_after: no goals

tactic: rw [pow_succ]
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
n : ℕ
⊢ x ^ (n + 1) ∈ S
state_after: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
n : ℕ
⊢ x ^ n * x ∈ S

tactic: exact mul_mem (pow_mem hx n) hx
state_before: M✝ : Type u_1
N : Type u_2
A✝ : Type u_3
inst✝⁴ : MulOneClass M✝
s : Set M✝
inst✝³ : AddZeroClass A✝
t : Set A✝
M : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : SetLike A M
inst✝ : SubmonoidClass A M
S : A
x : M
hx : x ∈ S
n : ℕ
⊢ x ^ n * x ∈ S
state_after: no goals
Theorem: Polynomial.natDegree_mul_C_eq_of_mul_ne_zero
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

tactic: refine eq_natDegree_of_le_mem_support (natDegree_mul_C_le p a) ?_
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.leadingCoeff * a ≠ 0
⊢ (p * C a).natDegree = p.natDegree
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.leadingCoeff * a ≠ 0
⊢ p.natDegree ∈ (p * C a).support

tactic: refine mem_support_iff.mpr ?_
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.leadingCoeff * a ≠ 0
⊢ p.natDegree ∈ (p * C a).support
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.leadingCoeff * a ≠ 0
⊢ (p * C a).coeff p.natDegree ≠ 0

tactic: rwa [coeff_mul_C]
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p.leadingCoeff * a ≠ 0
⊢ (p * C a).coeff p.natDegree ≠ 0
state_after: no goals
Theorem: Nat.choose_le_succ_of_lt_half_left
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: refine Nat.le_of_mul_le_mul_right ?_ (Nat.sub_pos_of_lt (h.trans_le (n.div_le_self 2)))
state_before: r n : ℕ
h : r < n / 2
⊢ n.choose r ≤ n.choose (r + 1)
state_after: r n : ℕ
h : r < n / 2
⊢ n.choose r * (n - r) ≤ n.choose (r + 1) * (n - r)

tactic: rw [← choose_succ_right_eq]
state_before: r n : ℕ
h : r < n / 2
⊢ n.choose r * (n - r) ≤ n.choose (r + 1) * (n - r)
state_after: r n : ℕ
h : r < n / 2
⊢ n.choose (r + 1) * (r + 1) ≤ n.choose (r + 1) * (n - r)

tactic: apply Nat.mul_le_mul_left
state_before: r n : ℕ
h : r < n / 2
⊢ n.choose (r + 1) * (r + 1) ≤ n.choose (r + 1) * (n - r)
state_after: case h
r n : ℕ
h : r < n / 2
⊢ r + 1 ≤ n - r

tactic: rw [← Nat.lt_iff_add_one_le, Nat.lt_sub_iff_add_lt, ← Nat.mul_two]
state_before: case h
r n : ℕ
h : r < n / 2
⊢ r + 1 ≤ n - r
state_after: case h
r n : ℕ
h : r < n / 2
⊢ r * 2 < n

tactic: exact lt_of_lt_of_le (Nat.mul_lt_mul_of_pos_right h Nat.zero_lt_two) (n.div_mul_le_self 2)
state_before: case h
r n : ℕ
h : r < n / 2
⊢ r * 2 < n
state_after: no goals
Theorem: starConvex_singleton
File: Mathlib/Analysis/Convex/Star.lean

tactic: rintro y (rfl : y = x) a b _ _ hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x✝ y z : E
s : Set E
x : E
⊢ StarConvex 𝕜 x {x}
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s : Set E
y : E
a b : 𝕜
a✝¹ : 0 ≤ a
a✝ : 0 ≤ b
hab : a + b = 1
⊢ a • y + b • y ∈ {y}

tactic: exact Convex.combo_self hab _
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z : E
s : Set E
y : E
a b : 𝕜
a✝¹ : 0 ≤ a
a✝ : 0 ≤ b
hab : a + b = 1
⊢ a • y + b • y ∈ {y}
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.Pullback.pullbackFstιToV_fst
File: Mathlib/AlgebraicGeometry/Pullbacks.lean

tactic: simp [pullbackFstιToV, p1]
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
s : PullbackCone f g
i j : 𝒰.J
⊢ pullbackFstιToV 𝒰 f g i j ≫ pullback.fst = pullback.snd
state_after: no goals