1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: FirstOrder.Language.Term.realize_functions_apply₂
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Functions.apply₂, Term.realize]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ realize v (f.apply₂ t₁ t₂) = funMap f ![realize v t₁, realize v t₂]
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ (funMap f fun i => realize v (![t₁, t₂] i)) = funMap f ![realize v t₁, realize v t₂]

tactic: refine congr rfl (funext (Fin.cases ?_ ?_))
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ (funMap f fun i => realize v (![t₁, t₂] i)) = funMap f ![realize v t₁, realize v t₂]
state_after: case refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ realize v (![t₁, t₂] 0) = ![realize v t₁, realize v t₂] 0

case refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ ∀ (i : Fin 1), realize v (![t₁, t₂] i.succ) = ![realize v t₁, realize v t₂] i.succ

tactic: simp only [Matrix.cons_val_zero]
state_before: case refine_1
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ realize v (![t₁, t₂] 0) = ![realize v t₁, realize v t₂] 0
state_after: no goals

tactic: simp only [Matrix.cons_val_succ, Matrix.cons_val_fin_one, forall_const]
state_before: case refine_2
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
f : L.Functions 2
t₁ t₂ : L.Term α
v : α → M
⊢ ∀ (i : Fin 1), realize v (![t₁, t₂] i.succ) = ![realize v t₁, realize v t₂] i.succ
state_after: no goals
Theorem: Part.fix_def'
File: Mathlib/Control/Fix.lean

tactic: dsimp [Part.fix]
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ Part.fix f x = none
state_after: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ (assert (∃ i, (Fix.approx f i x).Dom) fun h => ⋯.fix (fixAux f) Upto.zero x) = none

tactic: rw [assert_neg h']
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) → (a : α) → Part (β a)
x : α
h' : ¬∃ i, (Fix.approx f i x).Dom
⊢ (assert (∃ i, (Fix.approx f i x).Dom) fun h => ⋯.fix (fixAux f) Upto.zero x) = none
state_after: no goals
Theorem: Prop.isCompl_iff
File: Mathlib/Order/PropInstances.lean

tactic: rw [_root_.isCompl_iff, Prop.disjoint_iff, Prop.codisjoint_iff, not_iff]
state_before: P Q : Prop
⊢ IsCompl P Q ↔ ¬(P ↔ Q)
state_after: P Q : Prop
⊢ ¬(P ∧ Q) ∧ (P ∨ Q) ↔ (¬P ↔ Q)

tactic: by_cases P <;> by_cases Q <;> simp [*]
state_before: P Q : Prop
⊢ ¬(P ∧ Q) ∧ (P ∨ Q) ↔ (¬P ↔ Q)
state_after: no goals
Theorem: PNat.Coprime.factor_eq_gcd_left_right
File: Mathlib/Data/PNat/Prime.lean

tactic: rw [gcd_comm]
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = m.gcd (a * b)
state_after: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m

tactic: apply Coprime.factor_eq_gcd_left cop am bn
state_before: a b m n : ℕ+
cop : m.Coprime n
am : a ∣ m
bn : b ∣ n
⊢ a = (a * b).gcd m
state_after: no goals
Theorem: LieSubmodule.map_id
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: ext
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
⊢ map LieModuleHom.id N = N
state_after: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m✝ : M
⊢ m✝ ∈ map LieModuleHom.id N ↔ m✝ ∈ N

tactic: simp
state_before: case h
R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : M →ₗ⁅R,L⁆ M'
N N₂ : LieSubmodule R L M
N' : LieSubmodule R L M'
m✝ : M
⊢ m✝ ∈ map LieModuleHom.id N ↔ m✝ ∈ N
state_after: no goals
Theorem: AdicCompletion.map_comp
File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

tactic: ext
state_before: R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f : M →ₗ[R] N
g : N →ₗ[R] P
⊢ map I g ∘ₗ map I f = map I (g ∘ₗ f)
state_after: case h.h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f : M →ₗ[R] N
g : N →ₗ[R] P
a✝ : AdicCauchySequence I M
n✝ : ℕ
⊢ ↑((map I g ∘ₗ map I f) ((mk I M) a✝)) n✝ = ↑((map I (g ∘ₗ f)) ((mk I M) a✝)) n✝

tactic: simp
state_before: case h.h
R : Type u_1
inst✝⁸ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
N : Type u_3
inst✝⁵ : AddCommGroup N
inst✝⁴ : Module R N
P : Type u_4
inst✝³ : AddCommGroup P
inst✝² : Module R P
T : Type u_5
inst✝¹ : AddCommGroup T
inst✝ : Module (AdicCompletion I R) T
f : M →ₗ[R] N
g : N →ₗ[R] P
a✝ : AdicCauchySequence I M
n✝ : ℕ
⊢ ↑((map I g ∘ₗ map I f) ((mk I M) a✝)) n✝ = ↑((map I (g ∘ₗ f)) ((mk I M) a✝)) n✝
state_after: no goals
Theorem: LinearMap.BilinForm.nondegenerate_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/BilinearForm.lean

tactic: rw [← Matrix.nondegenerate_iff_det_ne_zero, nondegenerate_toMatrix_iff]
state_before: R : Type u_1
M : Type u_2
inst✝¹⁹ : CommSemiring R
inst✝¹⁸ : AddCommMonoid M
inst✝¹⁷ : Module R M
R₁ : Type u_3
M₁ : Type u_4
inst✝¹⁶ : CommRing R₁
inst✝¹⁵ : AddCommGroup M₁
inst✝¹⁴ : Module R₁ M₁
R₂ : Type u_5
M₂ : Type u_6
inst✝¹³ : CommSemiring R₂
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : Module R₂ M₂
R₃ : Type u_7
M₃ : Type u_8
inst✝¹⁰ : CommRing R₃
inst✝⁹ : AddCommGroup M₃
inst✝⁸ : Module R₃ M₃
V : Type u_9
K : Type u_10
inst✝⁷ : Field K
inst✝⁶ : AddCommGroup V
inst✝⁵ : Module K V
B✝ : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
A : Type u_11
inst✝⁴ : CommRing A
inst✝³ : IsDomain A
inst✝² : Module A M₃
B₃ : BilinForm A M₃
ι : Type u_12
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
B : BilinForm A M₃
b : Basis ι A M₃
⊢ B.Nondegenerate ↔ ((BilinForm.toMatrix b) B).det ≠ 0
state_after: no goals
Theorem: MeasureTheory.measure_mul_laverage
File: Mathlib/MeasureTheory/Integral/Average.lean

tactic: rcases eq_or_ne μ 0 with hμ | hμ
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → ℝ≥0∞
inst✝ : IsFiniteMeasure μ
f : α → ℝ≥0∞
⊢ μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ
state_after: case inl
α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → ℝ≥0∞
inst✝ : IsFiniteMeasure μ
f : α → ℝ≥0∞
hμ : μ = 0
⊢ μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ

case inr
α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → ℝ≥0∞
inst✝ : IsFiniteMeasure μ
f : α → ℝ≥0∞
hμ : μ ≠ 0
⊢ μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ

tactic: rw [hμ, lintegral_zero_measure, laverage_zero_measure, mul_zero]
state_before: case inl
α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → ℝ≥0∞
inst✝ : IsFiniteMeasure μ
f : α → ℝ≥0∞
hμ : μ = 0
⊢ μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ
state_after: no goals

tactic: rw [laverage_eq, ENNReal.mul_div_cancel' (measure_univ_ne_zero.2 hμ) (measure_ne_top _ _)]
state_before: case inr
α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace ℝ F
inst✝¹ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g : α → ℝ≥0∞
inst✝ : IsFiniteMeasure μ
f : α → ℝ≥0∞
hμ : μ ≠ 0
⊢ μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ
state_after: no goals
Theorem: Polynomial.degree_mul_X
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: simp [monic_X.degree_mul]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
n : ℕ
⊢ (p * X).degree = p.degree + 1
state_after: no goals
Theorem: Equiv.Perm.support_one
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: rw [support_eq_empty_iff]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f g : Perm α
⊢ support 1 = ∅
state_after: no goals
Theorem: Finset.smul_univ
File: Mathlib/Data/Finset/Pointwise.lean

tactic: push_cast
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑(s • univ) = ↑univ
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑s • Set.univ = Set.univ

tactic: exact Set.smul_univ hs
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑s • Set.univ = Set.univ
state_after: no goals
Theorem: Prod.lt_of_lt_of_le
File: Mathlib/Order/Basic.lean

tactic: simp [lt_iff, *]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝¹ : Preorder α
inst✝ : Preorder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h₁ : x.1 < y.1
h₂ : x.2 ≤ y.2
⊢ x < y
state_after: no goals
Theorem: Finset.image_subset_iff
File: Mathlib/Data/Finset/Image.lean

tactic: norm_cast
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq β
f g : α → β
s : Finset α
t : Finset β
a : α
b c : β
⊢ image f s ⊆ t ↔ f '' ↑s ⊆ ↑t
state_after: no goals
Theorem: ProbabilityTheory.IdentDistrib.essSup_eq
File: Mathlib/Probability/IdentDistrib.lean

tactic: have I : ∀ a, μ {x : α | a < f x} = ν {x : β | a < g x} := fun a =>
  h.measure_mem_eq measurableSet_Ioi
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝³ : ConditionallyCompleteLinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : OrderClosedTopology γ
h : IdentDistrib f g μ ν
⊢ essSup f μ = essSup g ν
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝³ : ConditionallyCompleteLinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : OrderClosedTopology γ
h : IdentDistrib f g μ ν
I : ∀ (a : γ), μ {x | a < f x} = ν {x | a < g x}
⊢ essSup f μ = essSup g ν

tactic: simp_rw [essSup_eq_sInf, I]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace β
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : MeasurableSpace δ
μ : Measure α
ν : Measure β
f : α → γ
g : β → γ
inst✝³ : ConditionallyCompleteLinearOrder γ
inst✝² : TopologicalSpace γ
inst✝¹ : OpensMeasurableSpace γ
inst✝ : OrderClosedTopology γ
h : IdentDistrib f g μ ν
I : ∀ (a : γ), μ {x | a < f x} = ν {x | a < g x}
⊢ essSup f μ = essSup g ν
state_after: no goals
Theorem: Finset.forall_mem_eraseNone
File: Mathlib/Data/Finset/Option.lean

tactic: simp [Option.forall]
state_before: α : Type u_1
β : Type u_2
s : Finset (Option α)
p : Option α → Prop
⊢ (∀ a ∈ eraseNone s, p (some a)) ↔ ∀ (a : α), some a ∈ s → p (some a)
state_after: no goals
Theorem: List.toFinset_filter
File: Mathlib/Data/Finset/Basic.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
s : List α
p : α → Bool
⊢ (filter p s).toFinset = Finset.filter (fun x => p x = true) s.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
s : List α
p : α → Bool
a✝ : α
⊢ a✝ ∈ (filter p s).toFinset ↔ a✝ ∈ Finset.filter (fun x => p x = true) s.toFinset

tactic: simp [List.mem_filter]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
l l' : List α
a : α
s : List α
p : α → Bool
a✝ : α
⊢ a✝ ∈ (filter p s).toFinset ↔ a✝ ∈ Finset.filter (fun x => p x = true) s.toFinset
state_after: no goals
Theorem: ZMod.addOrderOf_coe
File: Mathlib/Data/ZMod/Basic.lean

tactic: cases' a with a
state_before: a n : ℕ
n0 : n ≠ 0
⊢ addOrderOf ↑a = n / n.gcd a
state_after: case zero
n : ℕ
n0 : n ≠ 0
⊢ addOrderOf ↑0 = n / n.gcd 0

case succ
n : ℕ
n0 : n ≠ 0
a : ℕ
⊢ addOrderOf ↑(a + 1) = n / n.gcd (a + 1)

tactic: rw [← Nat.smul_one_eq_cast, addOrderOf_nsmul' _ a.succ_ne_zero, ZMod.addOrderOf_one]
state_before: case succ
n : ℕ
n0 : n ≠ 0
a : ℕ
⊢ addOrderOf ↑(a + 1) = n / n.gcd (a + 1)
state_after: no goals

tactic: simp only [Nat.zero_eq, Nat.cast_zero, addOrderOf_zero, Nat.gcd_zero_right,
  Nat.pos_of_ne_zero n0, Nat.div_self]
state_before: case zero
n : ℕ
n0 : n ≠ 0
⊢ addOrderOf ↑0 = n / n.gcd 0
state_after: no goals
Theorem: MvPolynomial.eval₂_mul
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: apply MvPolynomial.induction_on q
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ {p : MvPolynomial σ R}, eval₂ f g (p * q) = eval₂ f g p * eval₂ f g q
state_after: case h_C
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (a : R) {p : MvPolynomial σ R}, eval₂ f g (p * C a) = eval₂ f g p * eval₂ f g (C a)

case h_add
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (p q : MvPolynomial σ R),
    (∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * p) = eval₂ f g p_1 * eval₂ f g p) →
      (∀ {p : MvPolynomial σ R}, eval₂ f g (p * q) = eval₂ f g p * eval₂ f g q) →
        ∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * (p + q)) = eval₂ f g p_1 * eval₂ f g (p + q)

case h_X
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * p) = eval₂ f g p_1 * eval₂ f g p) →
      ∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * (p * X n)) = eval₂ f g p_1 * eval₂ f g (p * X n)

tactic: simp [eval₂_C, eval₂_mul_C]
state_before: case h_C
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (a : R) {p : MvPolynomial σ R}, eval₂ f g (p * C a) = eval₂ f g p * eval₂ f g (C a)
state_after: no goals

tactic: simp (config := { contextual := true }) [mul_add, eval₂_add]
state_before: case h_add
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (p q : MvPolynomial σ R),
    (∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * p) = eval₂ f g p_1 * eval₂ f g p) →
      (∀ {p : MvPolynomial σ R}, eval₂ f g (p * q) = eval₂ f g p * eval₂ f g q) →
        ∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * (p + q)) = eval₂ f g p_1 * eval₂ f g (p + q)
state_after: no goals

tactic: simp (config := { contextual := true }) [X, eval₂_monomial, eval₂_mul_monomial, ← mul_assoc]
state_before: case h_X
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
f : R →+* S₁
g : σ → S₁
⊢ ∀ (p : MvPolynomial σ R) (n : σ),
    (∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * p) = eval₂ f g p_1 * eval₂ f g p) →
      ∀ {p_1 : MvPolynomial σ R}, eval₂ f g (p_1 * (p * X n)) = eval₂ f g p_1 * eval₂ f g (p * X n)
state_after: no goals
Theorem: Set.singleton_unop
File: Mathlib/Data/Set/Opposite.lean

tactic: ext
state_before: α : Type u_1
x : αᵒᵖ
⊢ {x}.unop = {x.unop}
state_after: case h
α : Type u_1
x : αᵒᵖ
x✝ : α
⊢ x✝ ∈ {x}.unop ↔ x✝ ∈ {x.unop}

tactic: constructor
state_before: case h
α : Type u_1
x : αᵒᵖ
x✝ : α
⊢ x✝ ∈ {x}.unop ↔ x✝ ∈ {x.unop}
state_after: case h.mp
α : Type u_1
x : αᵒᵖ
x✝ : α
⊢ x✝ ∈ {x}.unop → x✝ ∈ {x.unop}

case h.mpr
α : Type u_1
x : αᵒᵖ
x✝ : α
⊢ x✝ ∈ {x.unop} → x✝ ∈ {x}.unop

tactic: apply op_injective
state_before: case h.mp
α : Type u_1
x : αᵒᵖ
x✝ : α
⊢ x✝ ∈ {x}.unop → x✝ ∈ {x.unop}
state_after: no goals

tactic: apply unop_injective
state_before: case h.mpr
α : Type u_1
x : αᵒᵖ
x✝ : α
⊢ x✝ ∈ {x.unop} → x✝ ∈ {x}.unop
state_after: no goals
Theorem: List.length_le_sum_of_one_le
File: Mathlib/Algebra/BigOperators/Group/List.lean

tactic: induction' L with j L IH h
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 ℕ
h : ∀ i ∈ L, 1 ≤ i
⊢ L.length ≤ L.sum
state_after: case nil
ι : 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
h : ∀ i ∈ [], 1 ≤ i
⊢ [].length ≤ [].sum

case cons
ι : 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
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ (j :: L).length ≤ (j :: L).sum

tactic: rw [sum_cons, length, add_comm]
state_before: case cons
ι : 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
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ (j :: L).length ≤ (j :: L).sum
state_after: case cons
ι : 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
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ 1 + L.length ≤ j + L.sum

tactic: exact Nat.add_le_add (h _ (mem_cons_self _ _)) (IH fun i hi => h i (mem_cons.2 (Or.inr hi)))
state_before: case cons
ι : 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
j : ℕ
L : List ℕ
IH : (∀ i ∈ L, 1 ≤ i) → L.length ≤ L.sum
h : ∀ i ∈ j :: L, 1 ≤ i
⊢ 1 + L.length ≤ j + L.sum
state_after: no goals

tactic: simp
state_before: case nil
ι : 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
h : ∀ i ∈ [], 1 ≤ i
⊢ [].length ≤ [].sum
state_after: no goals
Theorem: Stream'.Seq.dropn_tail
File: Mathlib/Data/Seq/Seq.lean

tactic: rw [Nat.add_comm]
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ s.tail.drop n = s.drop (n + 1)
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ s.tail.drop n = s.drop (1 + n)

tactic: symm
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ s.tail.drop n = s.drop (1 + n)
state_after: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ s.drop (1 + n) = s.tail.drop n

tactic: apply dropn_add
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
n : ℕ
⊢ s.drop (1 + n) = s.tail.drop n
state_after: no goals
Theorem: Polynomial.quotient_mul_add_remainder_eq_aux
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

tactic: by_cases h : q = 0
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
⊢ q * p.div q + p.mod q = p
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : q = 0
⊢ q * p.div q + p.mod q = p

case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * p.div q + p.mod q = p

tactic: simp only [h, zero_mul, mod, modByMonic_zero, zero_add]
state_before: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : q = 0
⊢ q * p.div q + p.mod q = p
state_after: no goals

tactic: conv =>
  rhs
  rw [← modByMonic_add_div p (monic_mul_leadingCoeff_inv h)]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * p.div q + p.mod q = p
state_after: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * p.div q + p.mod q = p %ₘ (q * C q.leadingCoeff⁻¹) + q * C q.leadingCoeff⁻¹ * (p /ₘ (q * C q.leadingCoeff⁻¹))

tactic: rw [div, mod, add_comm, mul_assoc]
state_before: case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * p.div q + p.mod q = p %ₘ (q * C q.leadingCoeff⁻¹) + q * C q.leadingCoeff⁻¹ * (p /ₘ (q * C q.leadingCoeff⁻¹))
state_after: no goals