1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LipschitzWith.const'
File: Mathlib/Topology/EMetricSpace/Lipschitz.lean

tactic: simp only [edist_self, zero_le]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : PseudoEMetricSpace α
inst✝¹ : PseudoEMetricSpace β
inst✝ : PseudoEMetricSpace γ
K✝ : ℝ≥0
f : α → β
x✝ y✝ : α
r : ℝ≥0∞
b : β
K : ℝ≥0
x y : α
⊢ edist ((fun x => b) x) ((fun x => b) y) ≤ ↑K * edist x y
state_after: no goals
Theorem: List.map_uncurry_zip_eq_zipWith
File: Mathlib/Data/List/Zip.lean

tactic: rw [zip]
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l : List α
l' : List β
⊢ map (Function.uncurry f) (l.zip l') = zipWith f l l'
state_after: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l : List α
l' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk l l') = zipWith f l l'

tactic: induction' l with hd tl hl generalizing l'
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l : List α
l' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk l l') = zipWith f l l'
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk [] l') = zipWith f [] l'

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
hd : α
tl : List α
hl : ∀ (l' : List β), map (Function.uncurry f) (zipWith Prod.mk tl l') = zipWith f tl l'
l' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk (hd :: tl) l') = zipWith f (hd :: tl) l'

tactic: simp
state_before: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
l' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk [] l') = zipWith f [] l'
state_after: no goals

tactic: cases' l' with hd' tl'
state_before: case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
hd : α
tl : List α
hl : ∀ (l' : List β), map (Function.uncurry f) (zipWith Prod.mk tl l') = zipWith f tl l'
l' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk (hd :: tl) l') = zipWith f (hd :: tl) l'
state_after: case cons.nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
hd : α
tl : List α
hl : ∀ (l' : List β), map (Function.uncurry f) (zipWith Prod.mk tl l') = zipWith f tl l'
⊢ map (Function.uncurry f) (zipWith Prod.mk (hd :: tl) []) = zipWith f (hd :: tl) []

case cons.cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
hd : α
tl : List α
hl : ∀ (l' : List β), map (Function.uncurry f) (zipWith Prod.mk tl l') = zipWith f tl l'
hd' : β
tl' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk (hd :: tl) (hd' :: tl')) = zipWith f (hd :: tl) (hd' :: tl')

tactic: simp
state_before: case cons.nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
hd : α
tl : List α
hl : ∀ (l' : List β), map (Function.uncurry f) (zipWith Prod.mk tl l') = zipWith f tl l'
⊢ map (Function.uncurry f) (zipWith Prod.mk (hd :: tl) []) = zipWith f (hd :: tl) []
state_after: no goals

tactic: simp [hl]
state_before: case cons.cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
f : α → β → γ
hd : α
tl : List α
hl : ∀ (l' : List β), map (Function.uncurry f) (zipWith Prod.mk tl l') = zipWith f tl l'
hd' : β
tl' : List β
⊢ map (Function.uncurry f) (zipWith Prod.mk (hd :: tl) (hd' :: tl')) = zipWith f (hd :: tl) (hd' :: tl')
state_after: no goals
Theorem: Submodule.IsPrincipal.generator_mem
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: conv_rhs => rw [← span_singleton_generator S]
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ generator S ∈ S
state_after: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ generator S ∈ span R {generator S}

tactic: exact subset_span (mem_singleton _)
state_before: R : Type u
M : Type v
inst✝³ : AddCommGroup M
inst✝² : Ring R
inst✝¹ : Module R M
S : Submodule R M
inst✝ : S.IsPrincipal
⊢ generator S ∈ span R {generator S}
state_after: no goals
Theorem: HomogeneousIdeal.toIdeal_iInf₂
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: simp_rw [toIdeal_iInf]
state_before: ι : Type u_1
σ : Type u_2
R : Type u_3
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_5
κ' : κ → Sort u_6
s : (i : κ) → κ' i → HomogeneousIdeal 𝒜
⊢ (⨅ i, ⨅ j, s i j).toIdeal = ⨅ i, ⨅ j, (s i j).toIdeal
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.nonsingular_of_equiv
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rcases h with ⟨u, rfl⟩
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
h : P ≈ Q
⊢ W'.Nonsingular P ↔ W'.Nonsingular Q
state_after: case intro
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
Q : Fin 3 → R
u : Rˣ
⊢ W'.Nonsingular ((fun m => m • Q) u) ↔ W'.Nonsingular Q

tactic: exact nonsingular_smul Q u.isUnit
state_before: case intro
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
Q : Fin 3 → R
u : Rˣ
⊢ W'.Nonsingular ((fun m => m • Q) u) ↔ W'.Nonsingular Q
state_after: no goals
Theorem: nonempty_preirreducible_inter
File: Mathlib/Topology/Irreducible.lean

tactic: simpa only [univ_inter, univ_subset_iff] using
  @PreirreducibleSpace.isPreirreducible_univ X _ _ s t
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
s t : Set X
inst✝ : PreirreducibleSpace X
⊢ IsOpen s → IsOpen t → s.Nonempty → t.Nonempty → (s ∩ t).Nonempty
state_after: no goals
Theorem: MonoidAlgebra.mul_single_apply_aux
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: classical exact
    have A :
      ∀ a₁ b₁,
        ((single x r).sum fun a₂ b₂ => ite (a₁ * a₂ = z) (b₁ * b₂) 0) =
          ite (a₁ * x = z) (b₁ * r) 0 :=
      fun a₁ b₁ => sum_single_index <| by simp
    calc
      (HMul.hMul (β := MonoidAlgebra k G) f (single x r)) z =
          sum f fun a b => if a = y then b * r else 0 := by simp only [mul_apply, A, H]
      _ = if y ∈ f.support then f y * r else 0 := f.support.sum_ite_eq' _ _
      _ = f y * r := by split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), a * x = z ↔ a = y
⊢ (f * single x r) z = f y * r
state_after: no goals

tactic: exact
have A :
∀ a₁ b₁,
((single x r).sum fun a₂ b₂ => ite (a₁ * a₂ = z) (b₁ * b₂) 0) =
ite (a₁ * x = z) (b₁ * r) 0 :=
fun a₁ b₁ => sum_single_index <| by simp
calc
(HMul.hMul (β := MonoidAlgebra k G) f (single x r)) z =
sum f fun a b => if a = y then b * r else 0 := by simp only [mul_apply, A, H]
_ = if y ∈ f.support then f y * r else 0 := f.support.sum_ite_eq' _ _
_ = f y * r := by split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), a * x = z ↔ a = y
⊢ (f * single x r) z = f y * r
state_after: no goals

tactic: simp
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), a * x = z ↔ a = y
a₁ : G
b₁ : k
⊢ (if a₁ * x = z then b₁ * 0 else 0) = 0
state_after: no goals

tactic: simp only [mul_apply, A, H]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), a * x = z ↔ a = y
A :
  ∀ (a₁ : G) (b₁ : k),
    (sum (single x r) fun a₂ b₂ => if a₁ * a₂ = z then b₁ * b₂ else 0) = if a₁ * x = z then b₁ * r else 0
⊢ (f * single x r) z = sum f fun a b => if a = y then b * r else 0
state_after: no goals

tactic: split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
H✝ : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), a * x = z ↔ a = y
A :
  ∀ (a₁ : G) (b₁ : k),
    (sum (single x r) fun a₂ b₂ => if a₁ * a₂ = z then b₁ * b₂ else 0) = if a₁ * x = z then b₁ * r else 0
⊢ (if y ∈ f.support then f y * r else 0) = f y * r
state_after: no goals
Theorem: Set.preimage_neg_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic, ← Ici_inter_Iio, inter_comm]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ -Ioc a b = Ico (-b) (-a)
state_after: no goals
Theorem: Finsupp.card_Iic
File: Mathlib/Data/Finsupp/Interval.lean

tactic: classical simp_rw [Iic_eq_Icc, card_Icc, Finsupp.bot_eq_zero, support_zero, empty_union,
    zero_apply, bot_eq_zero]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : CanonicallyOrderedAddCommMonoid α
inst✝ : LocallyFiniteOrder α
f : ι →₀ α
⊢ (Iic f).card = ∏ i ∈ f.support, (Iic (f i)).card
state_after: no goals

tactic: simp_rw [Iic_eq_Icc, card_Icc, Finsupp.bot_eq_zero, support_zero, empty_union,
zero_apply, bot_eq_zero]
state_before: ι : Type u_1
α : Type u_2
inst✝¹ : CanonicallyOrderedAddCommMonoid α
inst✝ : LocallyFiniteOrder α
f : ι →₀ α
⊢ (Iic f).card = ∏ i ∈ f.support, (Iic (f i)).card
state_after: no goals
Theorem: Finsupp.prod_mapRange_index
File: Mathlib/Algebra/BigOperators/Finsupp.lean

tactic: rw [not_mem_support_iff.1 H, h0]
state_before: α : Type u_1
ι : Type u_2
γ : Type u_3
A : Type u_4
B : Type u_5
C : Type u_6
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : AddCommMonoid C
t : ι → A → C
h0✝ : ∀ (i : ι), t i 0 = 0
h1 : ∀ (i : ι) (x y : A), t i (x + y) = t i x + t i y
s : Finset α
f✝ : α → ι →₀ A
i : ι
g✝ : ι →₀ A
k : ι → A → γ → B
x : γ
β : Type u_7
M : Type u_8
M' : Type u_9
N : Type u_10
P : Type u_11
G : Type u_12
H✝ : Type u_13
R : Type u_14
S : Type u_15
inst✝² : Zero M
inst✝¹ : Zero M'
inst✝ : CommMonoid N
f : M → M'
hf : f 0 = 0
g : α →₀ M
h : α → M' → N
h0 : ∀ (a : α), h a 0 = 1
x✝¹ : α
x✝ : x✝¹ ∈ g.support
H : x✝¹ ∉ (mapRange f hf g).support
⊢ h x✝¹ ((mapRange f hf g) x✝¹) = 1
state_after: no goals
Theorem: Real.sqrtTwoAddSeries_one
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp
state_before: x : ℝ
⊢ sqrtTwoAddSeries 0 1 = √2
state_after: no goals
Theorem: partialSups_eq_sup_range
File: Mathlib/Order/PartialSups.lean

tactic: simp [Nat.lt_succ_iff]
state_before: α : Type u_1
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
f : ℕ → α
n : ℕ
x✝ : α
⊢ (partialSups f) n ≤ x✝ ↔ (Finset.range (n + 1)).sup f ≤ x✝
state_after: no goals
Theorem: Int.Ico_filter_dvd_card
File: Mathlib/Data/Int/CardIntervalMod.lean

tactic: rw [Ico_filter_dvd_eq _ _ hr, card_map, card_Ico, toNat_eq_max]
state_before: a b r : ℤ
hr : 0 < r
⊢ ↑(filter (fun x => r ∣ x) (Ico a b)).card = max (⌈↑b / ↑r⌉ - ⌈↑a / ↑r⌉) 0
state_after: no goals
Theorem: ZMod.exponent
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: cases n
state_before: α : Type u
a : α
n : ℕ
⊢ AddMonoid.exponent (ZMod n) = n
state_after: case zero
α : Type u
a : α
⊢ AddMonoid.exponent (ZMod 0) = 0

case succ
α : Type u
a : α
n✝ : ℕ
⊢ AddMonoid.exponent (ZMod (n✝ + 1)) = n✝ + 1

tactic: rw [IsAddCyclic.exponent_eq_zero_of_infinite]
state_before: case zero
α : Type u
a : α
⊢ AddMonoid.exponent (ZMod 0) = 0
state_after: no goals

tactic: rw [IsAddCyclic.exponent_eq_card, card]
state_before: case succ
α : Type u
a : α
n✝ : ℕ
⊢ AddMonoid.exponent (ZMod (n✝ + 1)) = n✝ + 1
state_after: no goals
Theorem: Ordinal.IsNormal.blsub_eq
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [← IsNormal.bsup_eq.{u, v} H h, bsup_eq_blsub_of_lt_succ_limit h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{u} → Ordinal.{max u v}
H : IsNormal f
o : Ordinal.{u}
h : o.IsLimit
⊢ (o.blsub fun x x_1 => f x) = f o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{u} → Ordinal.{max u v}
H : IsNormal f
o : Ordinal.{u}
h : o.IsLimit
⊢ ∀ a < o, f a < f (succ a)

tactic: exact fun a _ => H.1 a
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : Ordinal.{u} → Ordinal.{max u v}
H : IsNormal f
o : Ordinal.{u}
h : o.IsLimit
⊢ ∀ a < o, f a < f (succ a)
state_after: no goals
Theorem: Function.update_exp
File: Mathlib/Analysis/NormedSpace/Exponential.lean

tactic: ext i
state_before: 𝕂 : Type u_1
𝔸✝ : Type u_2
𝔹 : Type u_3
inst✝¹⁰ : RCLike 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_4
𝔸 : ι → Type u_5
inst✝⁴ : Finite ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
⊢ Function.update (exp 𝕂 x) j (exp 𝕂 xj) = exp 𝕂 (Function.update x j xj)
state_after: case h
𝕂 : Type u_1
𝔸✝ : Type u_2
𝔹 : Type u_3
inst✝¹⁰ : RCLike 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_4
𝔸 : ι → Type u_5
inst✝⁴ : Finite ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
i : ι
⊢ Function.update (exp 𝕂 x) j (exp 𝕂 xj) i = exp 𝕂 (Function.update x j xj) i

tactic: simp_rw [Pi.exp_def]
state_before: case h
𝕂 : Type u_1
𝔸✝ : Type u_2
𝔹 : Type u_3
inst✝¹⁰ : RCLike 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_4
𝔸 : ι → Type u_5
inst✝⁴ : Finite ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
i : ι
⊢ Function.update (exp 𝕂 x) j (exp 𝕂 xj) i = exp 𝕂 (Function.update x j xj) i
state_after: case h
𝕂 : Type u_1
𝔸✝ : Type u_2
𝔹 : Type u_3
inst✝¹⁰ : RCLike 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_4
𝔸 : ι → Type u_5
inst✝⁴ : Finite ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
i : ι
⊢ Function.update (fun i => exp 𝕂 (x i)) j (exp 𝕂 xj) i = exp 𝕂 (Function.update x j xj i)

tactic: exact (Function.apply_update (fun i => exp 𝕂) x j xj i).symm
state_before: case h
𝕂 : Type u_1
𝔸✝ : Type u_2
𝔹 : Type u_3
inst✝¹⁰ : RCLike 𝕂
inst✝⁹ : NormedRing 𝔸✝
inst✝⁸ : NormedAlgebra 𝕂 𝔸✝
inst✝⁷ : NormedRing 𝔹
inst✝⁶ : NormedAlgebra 𝕂 𝔹
inst✝⁵ : CompleteSpace 𝔸✝
ι : Type u_4
𝔸 : ι → Type u_5
inst✝⁴ : Finite ι
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → NormedRing (𝔸 i)
inst✝¹ : (i : ι) → NormedAlgebra 𝕂 (𝔸 i)
inst✝ : ∀ (i : ι), CompleteSpace (𝔸 i)
x : (i : ι) → 𝔸 i
j : ι
xj : 𝔸 j
i : ι
⊢ Function.update (fun i => exp 𝕂 (x i)) j (exp 𝕂 xj) i = exp 𝕂 (Function.update x j xj i)
state_after: no goals
Theorem: BotHom.cancel_left
File: Mathlib/Order/Hom/Bounded.lean

tactic: rw [← BotHom.comp_apply, h, BotHom.comp_apply]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁴ : FunLike F α β
inst✝³ : Bot α
inst✝² : Bot β
inst✝¹ : Bot γ
inst✝ : Bot δ
g : BotHom β γ
f₁ f₂ : BotHom α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
Theorem: LinearMap.toMvPolynomial_zero
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: unfold toMvPolynomial
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
⊢ toMvPolynomial b₁ b₂ 0 = 0
state_after: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
⊢ (fun i => ((toMatrix b₁ b₂) 0).toMvPolynomial i) = 0

tactic: simp only [map_zero, Matrix.toMvPolynomial_zero]
state_before: R : Type u_1
M₁ : Type u_2
M₂ : Type u_3
ι₁ : Type u_4
ι₂ : Type u_5
inst✝⁷ : CommRing R
inst✝⁶ : AddCommGroup M₁
inst✝⁵ : AddCommGroup M₂
inst✝⁴ : Module R M₁
inst✝³ : Module R M₂
inst✝² : Fintype ι₁
inst✝¹ : Finite ι₂
inst✝ : DecidableEq ι₁
b₁ : Basis ι₁ R M₁
b₂ : Basis ι₂ R M₂
⊢ (fun i => ((toMatrix b₁ b₂) 0).toMvPolynomial i) = 0
state_after: no goals
Theorem: CategoryTheory.IsFilteredOrEmpty.of_right_adjoint
File: Mathlib/CategoryTheory/Filtered/Basic.lean

tactic: rw [← h.homEquiv_naturality_left, ← h.homEquiv_naturality_left, coeq_condition]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : IsFilteredOrEmpty C
D : Type u₁
inst✝ : Category.{v₁, u₁} D
L : D ⥤ C
R : C ⥤ D
h : L ⊣ R
X Y : D
f g : X ⟶ Y
⊢ f ≫ (h.homEquiv Y (coeq (?m.8685 X Y f g) (?m.8686 X Y f g))) (coeqHom (?m.8685 X Y f g) (?m.8686 X Y f g)) =
    g ≫ (h.homEquiv Y (coeq (?m.8685 X Y f g) (?m.8686 X Y f g))) (coeqHom (?m.8685 X Y f g) (?m.8686 X Y f g))
state_after: no goals
Theorem: LinearMap.range_codRestrict
File: Mathlib/Algebra/Module/Submodule/Range.lean

tactic: simpa only [range_eq_map] using map_codRestrict _ _ _ _
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝¹³ : Semiring R
inst✝¹² : Semiring R₂
inst✝¹¹ : Semiring R₃
inst✝¹⁰ : AddCommMonoid M
inst✝⁹ : AddCommMonoid M₂
inst✝⁸ : AddCommMonoid M₃
σ₁₂ : R →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R →+* R₃
inst✝⁷ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
inst✝⁶ : Module R M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
σ₂₁ : R₂ →+* R
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝³ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
F : Type u_11
inst✝² : FunLike F M M₂
inst✝¹ : SemilinearMapClass F τ₁₂ M M₂
τ₂₁ : R₂ →+* R
inst✝ : RingHomSurjective τ₂₁
p : Submodule R M
f : M₂ →ₛₗ[τ₂₁] M
hf : ∀ (c : M₂), f c ∈ p
⊢ range (codRestrict p f hf) = comap p.subtype (range f)
state_after: no goals
Theorem: List.perm_dlookup
File: Mathlib/Data/List/Sigma.lean

tactic: ext b
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
⊢ dlookup a l₁ = dlookup a l₂
state_after: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ b ∈ dlookup a l₁ ↔ b ∈ dlookup a l₂

tactic: simp only [mem_dlookup_iff nd₁, mem_dlookup_iff nd₂]
state_before: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ b ∈ dlookup a l₁ ↔ b ∈ dlookup a l₂
state_after: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ ⟨a, b⟩ ∈ l₁ ↔ ⟨a, b⟩ ∈ l₂

tactic: exact p.mem_iff
state_before: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ ⟨a, b⟩ ∈ l₁ ↔ ⟨a, b⟩ ∈ l₂
state_after: no goals
Theorem: Basis.reindexFinsetRange_repr
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [reindexFinsetRange]
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid M'
inst✝² : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x✝ : M
b' : Basis ι' R M'
e : ι ≃ ι'
inst✝¹ : Fintype ι
inst✝ : DecidableEq M
x : M
i : ι
h : optParam (b i ∈ Finset.image (⇑b) Finset.univ) ⋯
⊢ (b.reindexFinsetRange.repr x) ⟨b i, h⟩ = (b.repr x) i
state_after: no goals
Theorem: MvPolynomial.weightedDegree_one
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: simp [weightedDegree, degree, Finsupp.total, Finsupp.sum]
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
d : σ →₀ ℕ
⊢ (weightedDegree 1) d = degree d
state_after: no goals
Theorem: CyclotomicRing.eq_adjoin_primitive_root
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

tactic: rw [← IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_root_cyclotomic h,
  IsCyclotomicExtension.adjoin_roots_cyclotomic_eq_adjoin_nth_roots h]
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
μ : CyclotomicField n K
h : IsPrimitiveRoot μ ↑n
⊢ CyclotomicRing n A K = ↥(adjoin A {μ})
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
μ : CyclotomicField n K
h : IsPrimitiveRoot μ ↑n
⊢ CyclotomicRing n A K = ↥(adjoin A {b | ∃ a ∈ {n}, b ^ ↑a = 1})

tactic: simp [CyclotomicRing]
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁷ : CommRing A
inst✝⁶ : CommRing B
inst✝⁵ : Algebra A B
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra K L
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
μ : CyclotomicField n K
h : IsPrimitiveRoot μ ↑n
⊢ CyclotomicRing n A K = ↥(adjoin A {b | ∃ a ∈ {n}, b ^ ↑a = 1})
state_after: no goals
Theorem: List.formPerm_apply_nthLe_zero
File: Mathlib/GroupTheory/Perm/List.lean

tactic: omega
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ 0 < l.length
state_after: no goals

tactic: apply formPerm_apply_get_zero _ h
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
h : l.Nodup
hl : 1 < l.length
⊢ l.formPerm (l.nthLe 0 ⋯) = l.nthLe 1 hl
state_after: no goals
Theorem: ProbabilityTheory.kernel.setLIntegral_compProd_univ_left
File: Mathlib/Probability/Kernel/Composition.lean

tactic: simp_rw [setLIntegral_compProd κ η a hf MeasurableSet.univ ht, Measure.restrict_univ]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
s : Set (β × γ)
κ : ↥(kernel α β)
inst✝¹ : IsSFiniteKernel κ
η : ↥(kernel (α × β) γ)
inst✝ : IsSFiniteKernel η
a : α
f : β × γ → ℝ≥0∞
hf : Measurable f
t : Set γ
ht : MeasurableSet t
⊢ ∫⁻ (z : β × γ) in Set.univ ×ˢ t, f z ∂(κ ⊗ₖ η) a = ∫⁻ (x : β), ∫⁻ (y : γ) in t, f (x, y) ∂η (a, x) ∂κ a
state_after: no goals
Theorem: Set.subset_insert_diff_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: rw [← diff_singleton_subset_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
x : α
s : Set α
⊢ s ⊆ insert x (s \ {x})
state_after: no goals
Theorem: Finset.zero_mul_subset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [subset_iff, mem_mul]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : MulZeroClass α
s✝ t s : Finset α
⊢ 0 * s ⊆ 0
state_after: no goals
Theorem: Real.logb_pos_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [logb_pos_iff_of_base_lt_one b_pos b_lt_one hx]
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hx' : x < 1
⊢ 0 < logb b x
state_after: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hx' : x < 1
⊢ x < 1

tactic: exact hx'
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
hx' : x < 1
⊢ x < 1
state_after: no goals