tasksource/leandojo huggingface dataset:
Theorem: Polynomial.exists_partition_polynomial
File: Mathlib/NumberTheory/ClassNumber/AdmissibleCardPowDegree.lean

tactic: obtain ⟨t, ht⟩ := exists_partition_polynomial_aux n hε hb A
state_before: Fq : Type u_1
inst✝¹ : Fintype Fq
inst✝ : Field Fq
n : ℕ
ε : ℝ
hε : 0 < ε
b : Fq[X]
hb : b ≠ 0
A : Fin n → Fq[X]
⊢ ∃ t, ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(↑cardPowDegree (A i₁ % b - A i₀ % b)) < ↑cardPowDegree b • ε

tactic: exact ⟨t, fun i₀ i₁ hi => (ht i₀ i₁).mp hi⟩
state_before: case intro
Fq : Type u_1
inst✝¹ : Fintype Fq
inst✝ : Field Fq
n : ℕ
ε : ℝ
hε : 0 < ε
b : Fq[X]
hb : b ≠ 0
A : Fin n → Fq[X]
t : Fin n → Fin (Fintype.card Fq ^ ⌈-log ε / log ↑(Fintype.card Fq)⌉₊)
ht : ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ ↔ ↑(↑cardPowDegree (A i₁ % b - A i₀ % b)) < ↑cardPowDegree b • ε
⊢ ∃ t, ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(↑cardPowDegree (A i₁ % b - A i₀ % b)) < ↑cardPowDegree b • ε
Theorem: Std.RBNode.Stream.toList_cons
File: Std/Data/RBMap/Lemmas.lean

tactic: rw [toList, toList, foldr, RBNode.foldr_cons]
state_before: α : Type u_1
x : α
r : RBNode α
s : RBNode.Stream α
⊢ toList (cons x r s) = x :: RBNode.toList r ++ toList s

tactic: rfl
state_before: α : Type u_1
x : α
r : RBNode α
s : RBNode.Stream α
⊢ x :: (RBNode.toList r ++ foldr (fun x x_1 => x :: x_1) s []) =
    x :: RBNode.toList r ++ foldr (fun x x_1 => x :: x_1) s []
Theorem: Vector.scanl_head
File: Mathlib/Data/Vector/Basic.lean

tactic: cases n
state_before: n : ℕ
α : Type u_2
β : Type u_1
f : β → α → β
b : β
v : Vector α n
⊢ head (scanl f b v) = b

tactic: have : v = nil := by simp only [Nat.zero_eq, eq_iff_true_of_subsingleton]
state_before: case zero
α : Type u_2
β : Type u_1
f : β → α → β
b : β
v : Vector α Nat.zero
⊢ head (scanl f b v) = b

tactic: simp only [this, scanl_nil, head_cons]
state_before: case zero
α : Type u_2
β : Type u_1
f : β → α → β
b : β
v : Vector α Nat.zero
this : v = nil
⊢ head (scanl f b v) = b

tactic: simp only [Nat.zero_eq, eq_iff_true_of_subsingleton]
state_before: α : Type u_2
β : Type u_1
f : β → α → β
b : β
v : Vector α Nat.zero
⊢ v = nil

tactic: rw [← cons_head_tail v]
state_before: case succ
α : Type u_2
β : Type u_1
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (Nat.succ n✝)
⊢ head (scanl f b v) = b

tactic: simp only [← get_zero, get_eq_get, toList_scanl, toList_cons, List.scanl, Fin.val_zero,
  List.get]
state_before: case succ
α : Type u_2
β : Type u_1
f : β → α → β
b : β
n✝ : ℕ
v : Vector α (Nat.succ n✝)
⊢ head (scanl f b (head v ::ᵥ tail v)) = b
Theorem: Polynomial.monic_of_degree_le
File: Mathlib/Data/Polynomial/Monic.lean

tactic: rwa [Monic, Polynomial.leadingCoeff, natDegree, (lt_or_eq_of_le H1).resolve_left H]
state_before: R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
n : ℕ
H1 : degree p ≤ ↑n
H2 : coeff p n = 1
H : ¬degree p < ↑n
⊢ Monic p
Theorem: Derivation.leibniz_inv
File: Mathlib/RingTheory/Derivation/Basic.lean

tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: R : Type u_3
inst✝⁸ : CommRing R
A : Type ?u.578634
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module A M
inst✝³ : Module R M
D✝ D1 D2 : Derivation R A M
r : R
a✝ b : A
K : Type u_1
inst✝² : Field K
inst✝¹ : Module K M
inst✝ : Algebra R K
D : Derivation R K M
a : K
⊢ ↑D a⁻¹ = -a⁻¹ ^ 2 • ↑D a

tactic: simp
state_before: case inl
R : Type u_3
inst✝⁸ : CommRing R
A : Type ?u.578634
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module A M
inst✝³ : Module R M
D✝ D1 D2 : Derivation R A M
r : R
a b : A
K : Type u_1
inst✝² : Field K
inst✝¹ : Module K M
inst✝ : Algebra R K
D : Derivation R K M
⊢ ↑D 0⁻¹ = -0⁻¹ ^ 2 • ↑D 0

tactic: exact D.leibniz_of_mul_eq_one (inv_mul_cancel ha)
state_before: case inr
R : Type u_3
inst✝⁸ : CommRing R
A : Type ?u.578634
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
M : Type u_2
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module A M
inst✝³ : Module R M
D✝ D1 D2 : Derivation R A M
r : R
a✝ b : A
K : Type u_1
inst✝² : Field K
inst✝¹ : Module K M
inst✝ : Algebra R K
D : Derivation R K M
a : K
ha : a ≠ 0
⊢ ↑D a⁻¹ = -a⁻¹ ^ 2 • ↑D a
Theorem: MeasureTheory.set_integral_prod
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

tactic: simp only [← Measure.prod_restrict s t, IntegrableOn] at hf ⊢
state_before: α : Type u_1
α' : Type ?u.2462095
β : Type u_2
β' : Type ?u.2462101
γ : Type ?u.2462104
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type ?u.2462369
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : α × β → E
s : Set α
t : Set β
hf : IntegrableOn f (s ×ˢ t)
⊢ (∫ (z : α × β) in s ×ˢ t, f z ∂Measure.prod μ ν) = ∫ (x : α) in s, ∫ (y : β) in t, f (x, y) ∂ν ∂μ

tactic: rw [← Measure.prod_restrict s t] at hf ⊢
state_before: α : Type u_1
α' : Type ?u.2462095
β : Type u_2
β' : Type ?u.2462101
γ : Type ?u.2462104
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type ?u.2462369
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : α × β → E
s : Set α
t : Set β
hf : Integrable f
⊢ (∫ (z : α × β) in s ×ˢ t, f z ∂Measure.prod μ ν) = ∫ (x : α) in s, ∫ (y : β) in t, f (x, y) ∂ν ∂μ

tactic: exact integral_prod f hf
state_before: α : Type u_1
α' : Type ?u.2462095
β : Type u_2
β' : Type ?u.2462101
γ : Type ?u.2462104
E : Type u_3
inst✝¹² : MeasurableSpace α
inst✝¹¹ : MeasurableSpace α'
inst✝¹⁰ : MeasurableSpace β
inst✝⁹ : MeasurableSpace β'
inst✝⁸ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : SigmaFinite ν
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : CompleteSpace E
inst✝³ : SigmaFinite μ
E' : Type ?u.2462369
inst✝² : NormedAddCommGroup E'
inst✝¹ : CompleteSpace E'
inst✝ : NormedSpace ℝ E'
f : α × β → E
s : Set α
t : Set β
hf : Integrable f
⊢ (∫ (z : α × β), f z ∂Measure.prod (Measure.restrict μ s) (Measure.restrict ν t)) =
    ∫ (x : α) in s, ∫ (y : β) in t, f (x, y) ∂ν ∂μ
Theorem: Finset.piecewise_singleton
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← insert_emptyc_eq, piecewise_insert, piecewise_empty]
state_before: α : Type u_1
β : Type ?u.302885
γ : Type ?u.302888
δ : α → Sort u_2
s : Finset α
f g : (i : α) → δ i
inst✝¹ : (j : α) → Decidable (j ∈ s)
inst✝ : DecidableEq α
i : α
⊢ piecewise {i} f g = update g i (f i)
Theorem: BoxIntegral.Box.coe_splitUpper
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: rw [splitUpper, coe_mk']
state_before: ι : Type u_1
M : Type ?u.11166
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ ↑(splitUpper I i x) = ↑I ∩ {y | x < y i}

tactic: ext y
state_before: ι : Type u_1
M : Type ?u.11166
n : ℕ
I : Box ι
i : ι
x : ℝ
y : ι → ℝ
⊢ (Set.pi univ fun i_1 => Ioc (update I.lower i (max x (lower I i)) i_1) (upper I i_1)) = ↑I ∩ {y | x < y i}

tactic: simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_setOf_eq, forall_and,
  forall_update_iff I.lower fun j z => z < y j, max_lt_iff, and_assoc (a := x < y i),
  and_forall_ne (p := fun j => lower I j < y j) i, mem_def]
state_before: case h
ι : Type u_1
M : Type ?u.11166
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (y ∈ Set.pi univ fun i_1 => Ioc (update I.lower i (max x (lower I i)) i_1) (upper I i_1)) ↔ y ∈ ↑I ∩ {y | x < y i}

tactic: exact and_comm
state_before: case h
ι : Type u_1
M : Type ?u.11166
n : ℕ
I : Box ι
i : ι
x : ℝ
y✝ y : ι → ℝ
⊢ (x < y i ∧ (∀ (b : ι), lower I b < y b) ∧ ∀ (x : ι), y x ≤ upper I x) ↔
    ((∀ (x : ι), lower I x < y x) ∧ ∀ (x : ι), y x ≤ upper I x) ∧ x < y i
Theorem: Finset.univ_fin2
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: ext x
state_before: ⊢ univ = {0, 1}

tactic: fin_cases x <;> simp
state_before: case a
x : Fin 2
⊢ x ∈ univ ↔ x ∈ {0, 1}
Theorem: Complex.ofReal_pow
File: Mathlib/Data/Complex/Basic.lean

tactic: induction n <;> simp [*, ofReal_mul, pow_succ]
state_before: r : ℝ
n : ℕ
⊢ ↑(r ^ n) = ↑r ^ n
Theorem: IsROrC.div_re_ofReal
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [div_eq_inv_mul, div_eq_inv_mul, ← ofReal_inv, ofReal_mul_re]
state_before: K : Type u_1
E : Type ?u.5998790
inst✝ : IsROrC K
z : K
r : ℝ
⊢ ↑re (z / ↑r) = ↑re z / r
Theorem: PiLp.edist_eq_iSup
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: dsimp [edist]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.7794
𝕜' : Type ?u.7797
ι : Type u_1
α : ι → Type ?u.7805
β : ι → Type u_2
inst✝¹ : Fintype ι
inst✝ : (i : ι) → EDist (β i)
f g : PiLp ⊤ β
⊢ edist f g = ⨆ (i : ι), edist (f i) (g i)

tactic: exact if_neg ENNReal.top_ne_zero
state_before: p : ℝ≥0∞
𝕜 : Type ?u.7794
𝕜' : Type ?u.7797
ι : Type u_1
α : ι → Type ?u.7805
β : ι → Type u_2
inst✝¹ : Fintype ι
inst✝ : (i : ι) → EDist (β i)
f g : PiLp ⊤ β
⊢ (if ⊤ = 0 then ↑(Finset.card (Finite.toFinset (_ : Set.Finite {i | f i ≠ g i})))
    else if ⊤ = ⊤ then ⨆ (i : ι), edist (f i) (g i) else (∑ i : ι, edist (f i) (g i) ^ 0) ^ (1 / 0)) =
    ⨆ (i : ι), edist (f i) (g i)
Theorem: OrderEmbedding.isAtom_of_map_bot_of_image
File: Mathlib/Order/Atoms.lean

tactic: simp only [← bot_covby_iff] at hb ⊢
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
f : β ↪o α
hbot : ↑f ⊥ = ⊥
b : β
hb : IsAtom (↑f b)
⊢ IsAtom b

tactic: exact Covby.of_image f (hbot.symm ▸ hb)
state_before: α : Type u_1
β : Type u_2
inst✝³ : PartialOrder α
inst✝² : PartialOrder β
inst✝¹ : OrderBot α
inst✝ : OrderBot β
f : β ↪o α
hbot : ↑f ⊥ = ⊥
b : β
hb : ⊥ ⋖ ↑f b
⊢ ⊥ ⋖ b
Theorem: RatFunc.mk_zero
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [mk_eq_div', RingHom.map_zero, div_zero]
state_before: K : Type u
inst✝¹ : CommRing K
inst✝ : IsDomain K
p : K[X]
⊢ RatFunc.mk p 0 = { toFractionRing := 0 }
Theorem: GromovHausdorff.candidates_lipschitz
File: Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean

tactic: apply LipschitzWith.of_dist_le_mul
state_before: X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
fA : f ∈ candidates X Y
⊢ LipschitzWith (2 * GromovHausdorff.maxVar X Y) f

tactic: rintro ⟨x, y⟩ ⟨z, t⟩
state_before: case a
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x y z t : X ⊕ Y
fA : f ∈ candidates X Y
⊢ ∀ (x y : (X ⊕ Y) × (X ⊕ Y)), dist (f x) (f y) ≤ ↑(2 * GromovHausdorff.maxVar X Y) * dist x y

tactic: rw [Real.dist_eq, abs_sub_le_iff]
state_before: case a.mk.mk
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x✝ y✝ z✝ t✝ : X ⊕ Y
fA : f ∈ candidates X Y
x y z t : X ⊕ Y
⊢ dist (f (x, y)) (f (z, t)) ≤ ↑(2 * GromovHausdorff.maxVar X Y) * dist (x, y) (z, t)

tactic: use candidates_lipschitz_aux fA
state_before: case a.mk.mk
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x✝ y✝ z✝ t✝ : X ⊕ Y
fA : f ∈ candidates X Y
x y z t : X ⊕ Y
⊢ f (x, y) - f (z, t) ≤ ↑(2 * GromovHausdorff.maxVar X Y) * dist (x, y) (z, t) ∧
    f (z, t) - f (x, y) ≤ ↑(2 * GromovHausdorff.maxVar X Y) * dist (x, y) (z, t)

tactic: rw [dist_comm]
state_before: case a.mk.mk
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x✝ y✝ z✝ t✝ : X ⊕ Y
fA : f ∈ candidates X Y
x y z t : X ⊕ Y
⊢ f (z, t) - f (x, y) ≤ ↑(2 * GromovHausdorff.maxVar X Y) * dist (x, y) (z, t)

tactic: exact candidates_lipschitz_aux fA
state_before: case a.mk.mk
X : Type u
Y : Type v
inst✝⁵ : MetricSpace X
inst✝⁴ : CompactSpace X
inst✝³ : Nonempty X
inst✝² : MetricSpace Y
inst✝¹ : CompactSpace Y
inst✝ : Nonempty Y
f : GromovHausdorff.ProdSpaceFun X Y
x✝ y✝ z✝ t✝ : X ⊕ Y
fA : f ∈ candidates X Y
x y z t : X ⊕ Y
⊢ f (z, t) - f (x, y) ≤ ↑(2 * GromovHausdorff.maxVar X Y) * dist (z, t) (x, y)
Theorem: Primrec.fst
File: Mathlib/Computability/Primrec.lean

tactic: simp
state_before: α✝ : Type ?u.35741
σ : Type ?u.35744
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.unpaired
      (fun z n =>
        Nat.casesOn n 0 fun y =>
          Nat.unpaired (fun z n => Nat.casesOn n 0 fun y => Nat.succ (Nat.unpair (Nat.pair z y)).fst)
            (Nat.pair (Nat.unpair (Nat.pair z y)).snd (encode (decode (Nat.unpair (Nat.pair z y)).fst))))
      (Nat.pair (Nat.unpair n).snd (encode (decode (Nat.unpair n).fst))) =
    encode (Option.map Prod.fst (decode n))

tactic: cases @decode α _ n.unpair.1 <;> simp
state_before: α✝ : Type ?u.35741
σ : Type ?u.35744
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
⊢ Nat.rec 0 (fun n_1 n_ih => Nat.rec 0 (fun n n_ih => Nat.succ n_1) (encode (decode (Nat.unpair n).snd)))
      (encode (decode (Nat.unpair n).fst)) =
    encode
      (Option.map Prod.fst
        (Option.bind (decode (Nat.unpair n).fst) fun a => Option.map (Prod.mk a) (decode (Nat.unpair n).snd)))

tactic: cases @decode β _ n.unpair.2 <;> simp
state_before: case some
α✝ : Type ?u.35741
σ : Type ?u.35744
inst✝³ : Primcodable α✝
inst✝² : Primcodable σ
α : Type u_1
β : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable β
n : ℕ
val✝ : α
⊢ Nat.rec 0 (fun n n_ih => Nat.succ (encode val✝)) (encode (decode (Nat.unpair n).snd)) =
    encode (Option.map (Function.const β val✝) (decode (Nat.unpair n).snd))
Theorem: Dfinsupp.support_update_ne_zero
File: Mathlib/Data/Dfinsupp/Basic.lean

tactic: ext j
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
⊢ support (update i f b) = insert i (support f)

tactic: rcases eq_or_ne i j with (rfl | hi)
state_before: case a
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
j : ι
⊢ j ∈ support (update i f b) ↔ j ∈ insert i (support f)

tactic: simp [h]
state_before: case a.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
⊢ i ∈ support (update i f b) ↔ i ∈ insert i (support f)

tactic: simp [hi.symm]
state_before: case a.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
dec : DecidableEq ι
inst✝¹ : (i : ι) → Zero (β i)
inst✝ : (i : ι) → (x : β i) → Decidable (x ≠ 0)
f : Π₀ (i : ι), β i
i : ι
b : β i
h : b ≠ 0
j : ι
hi : i ≠ j
⊢ j ∈ support (update i f b) ↔ j ∈ insert i (support f)
Theorem: vadd_eq_vadd_iff_sub_eq_vsub
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [vadd_eq_vadd_iff_neg_add_eq_vsub, neg_add_eq_sub]
state_before: G : Type u_2
P : Type u_1
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
v₁ v₂ : G
p₁ p₂ : P
⊢ v₁ +ᵥ p₁ = v₂ +ᵥ p₂ ↔ v₂ - v₁ = p₁ -ᵥ p₂
Theorem: Filter.prod_assoc_symm
File: Mathlib/Order/Filter/Prod.lean

tactic: simp_rw [map_equiv_symm, SProd.sprod, Filter.prod, comap_inf, comap_comap, inf_assoc,
  Function.comp, Equiv.prodAssoc_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.20903
ι : Sort ?u.20906
s : Set α
t : Set β
f✝ : Filter α
g✝ : Filter β
f : Filter α
g : Filter β
h : Filter γ
⊢ map (↑(Equiv.prodAssoc α β γ).symm) (f ×ˢ g ×ˢ h) = (f ×ˢ g) ×ˢ h
Theorem: CategoryTheory.Limits.pullbackIsoUnopPushout_inv_fst
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
J : Type u₂
inst✝² : Category J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (PushoutCocone.unop (colimit.cocone (span f.op g.op))).π.app WalkingCospan.left = pushout.inl.unop
Theorem: QuadraticForm.polar_zero_right
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp only [add_zero, polar, QuadraticForm.map_zero, sub_self]
state_before: S : Type ?u.160007
R : Type u_1
R₁ : Type ?u.160013
M : Type u_2
inst✝³ : Ring R
inst✝² : CommRing R₁
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
y : M
⊢ polar (↑Q) y 0 = 0
Theorem: WeakDual.isClosed_polar
File: Mathlib/Analysis/NormedSpace/WeakDual.lean

tactic: simp only [polar_def, setOf_forall]
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ IsClosed (polar 𝕜 s)

tactic: exact isClosed_biInter fun x hx => isClosed_Iic.preimage (WeakBilin.eval_continuous _ _).norm
state_before: 𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : Set E
⊢ IsClosed (⋂ (i : E) (_ : i ∈ s), {x | ‖↑x i‖ ≤ 1})
Theorem: Complex.exp_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp]
state_before: x y : ℂ
⊢ exp 0 = 1

tactic: refine' lim_eq_of_equiv_const fun ε ε0 => ⟨1, fun j hj => _⟩
state_before: x y : ℂ
⊢ CauSeq.lim (exp' 0) = 1

tactic: convert (config := .unfoldSameFun) ε0
state_before: x y : ℂ
ε : ℝ
ε0 : ε > 0
j : ℕ
hj : j ≥ 1
⊢ ↑abs (↑(exp' 0 - const (↑abs) 1) j) < ε

tactic: cases' j with j j
state_before: case h.e'_3
x y : ℂ
ε : ℝ
ε0 : ε > 0
j : ℕ
hj : j ≥ 1
⊢ ↑abs (↑(exp' 0 - const (↑abs) 1) j) = 0

tactic: exact absurd hj (not_le_of_gt zero_lt_one)
state_before: case h.e'_3.zero
x y : ℂ
ε : ℝ
ε0 : ε > 0
hj : Nat.zero ≥ 1
⊢ ↑abs (↑(exp' 0 - const (↑abs) 1) Nat.zero) = 0

tactic: dsimp [exp']
state_before: case h.e'_3.succ
x y : ℂ
ε : ℝ
ε0 : ε > 0
j : ℕ
hj : Nat.succ j ≥ 1
⊢ ↑abs (↑(exp' 0 - const (↑abs) 1) (Nat.succ j)) = 0

tactic: induction' j with j ih
state_before: case h.e'_3.succ
x y : ℂ
ε : ℝ
ε0 : ε > 0
j : ℕ
hj : Nat.succ j ≥ 1
⊢ ↑abs (∑ m in range (Nat.succ j), 0 ^ m / ↑(Nat.factorial m) - 1) = 0

tactic: dsimp [exp']
state_before: case h.e'_3.succ.zero
x y : ℂ
ε : ℝ
ε0 : ε > 0
j : ℕ
hj✝ : Nat.succ j ≥ 1
hj : Nat.succ Nat.zero ≥ 1
⊢ ↑abs (∑ m in range (Nat.succ Nat.zero), 0 ^ m / ↑(Nat.factorial m) - 1) = 0

tactic: simp [show Nat.succ 0 = 1 from rfl]
state_before: case h.e'_3.succ.zero
x y : ℂ
ε : ℝ
ε0 : ε > 0
j : ℕ
hj✝ : Nat.succ j ≥ 1
hj : Nat.succ Nat.zero ≥ 1
⊢ ↑abs (∑ m in range (Nat.succ 0), 0 ^ m / ↑(Nat.factorial m) - 1) = 0

tactic: rw [← ih (by simp [show 1 = Nat.succ 0 from rfl, Nat.succ_le_succ])]
state_before: case h.e'_3.succ.succ
x y : ℂ
ε : ℝ
ε0 : ε > 0
j✝ : ℕ
hj✝ : Nat.succ j✝ ≥ 1
j : ℕ
ih : Nat.succ j ≥ 1 → ↑abs (∑ m in range (Nat.succ j), 0 ^ m / ↑(Nat.factorial m) - 1) = 0
hj : Nat.succ (Nat.succ j) ≥ 1
⊢ ↑abs (∑ m in range (Nat.succ (Nat.succ j)), 0 ^ m / ↑(Nat.factorial m) - 1) = 0

tactic: simp only [sum_range_succ, pow_succ]
state_before: case h.e'_3.succ.succ
x y : ℂ
ε : ℝ
ε0 : ε > 0
j✝ : ℕ
hj✝ : Nat.succ j✝ ≥ 1
j : ℕ
ih : Nat.succ j ≥ 1 → ↑abs (∑ m in range (Nat.succ j), 0 ^ m / ↑(Nat.factorial m) - 1) = 0
hj : Nat.succ (Nat.succ j) ≥ 1
⊢ ↑abs (∑ m in range (Nat.succ (Nat.succ j)), 0 ^ m / ↑(Nat.factorial m) - 1) =
    ↑abs (∑ m in range (Nat.succ j), 0 ^ m / ↑(Nat.factorial m) - 1)

tactic: simp
state_before: case h.e'_3.succ.succ
x y : ℂ
ε : ℝ
ε0 : ε > 0
j✝ : ℕ
hj✝ : Nat.succ j✝ ≥ 1
j : ℕ
ih : Nat.succ j ≥ 1 → ↑abs (∑ m in range (Nat.succ j), 0 ^ m / ↑(Nat.factorial m) - 1) = 0
hj : Nat.succ (Nat.succ j) ≥ 1
⊢ ↑abs
      (∑ m in range j, 0 ^ m / ↑(Nat.factorial m) + 0 ^ j / ↑(Nat.factorial j) + 0 * 0 ^ j / ↑(Nat.factorial (j + 1)) -
        1) =
    ↑abs (∑ m in range j, 0 ^ m / ↑(Nat.factorial m) + 0 ^ j / ↑(Nat.factorial j) - 1)

tactic: simp [show 1 = Nat.succ 0 from rfl, Nat.succ_le_succ]
state_before: x y : ℂ
ε : ℝ
ε0 : ε > 0
j✝ : ℕ
hj✝ : Nat.succ j✝ ≥ 1
j : ℕ
ih : Nat.succ j ≥ 1 → ↑abs (∑ m in range (Nat.succ j), 0 ^ m / ↑(Nat.factorial m) - 1) = 0
hj : Nat.succ (Nat.succ j) ≥ 1
⊢ Nat.succ j ≥ 1
Theorem: Multiset.zero_union
File: Mathlib/Data/Multiset/Basic.lean

tactic: simp [union_def]
state_before: α : Type u_1
β : Type ?u.169521
γ : Type ?u.169524
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
⊢ 0 ∪ s = s
Theorem: Int.sign_mul
File: Std/Data/Int/Lemmas.lean

tactic: simp [Int.mul_zero, Int.zero_mul]
state_before: b : Int
⊢ sign (0 * b) = sign 0 * sign b
Theorem: MeasureTheory.Measure.univ_pi_Ioi_ae_eq_Ici
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: rw [← pi_univ_Ici]
state_before: ι : Type u_2
ι' : Type ?u.3710571
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (Set.pi univ fun i => Ioi (f i)) =ᶠ[ae (Measure.pi μ)] Ici f

tactic: exact pi_Ioi_ae_eq_pi_Ici
state_before: ι : Type u_2
ι' : Type ?u.3710571
α : ι → Type u_1
inst✝⁴ : Fintype ι
m : (i : ι) → OuterMeasure (α i)
inst✝³ : (i : ι) → MeasurableSpace (α i)
μ : (i : ι) → Measure (α i)
inst✝² : ∀ (i : ι), SigmaFinite (μ i)
inst✝¹ : (i : ι) → PartialOrder (α i)
inst✝ : ∀ (i : ι), NoAtoms (μ i)
f : (i : ι) → α i
⊢ (Set.pi univ fun i => Ioi (f i)) =ᶠ[ae (Measure.pi μ)] Set.pi univ fun i => Ici (f i)
Theorem: multiplicity.min_le_multiplicity_add
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [min_eq_left h, multiplicity_le_multiplicity_iff]
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≤ multiplicity p b
⊢ min (multiplicity p a) (multiplicity p b) ≤ multiplicity p (a + b)

tactic: exact fun n hn => dvd_add hn (multiplicity_le_multiplicity_iff.1 h n hn)
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≤ multiplicity p b
⊢ ∀ (n : ℕ), p ^ n ∣ a → p ^ n ∣ a + b

tactic: rw [min_eq_right h, multiplicity_le_multiplicity_iff]
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b ≤ multiplicity p a
⊢ min (multiplicity p a) (multiplicity p b) ≤ multiplicity p (a + b)

tactic: exact fun n hn => dvd_add (multiplicity_le_multiplicity_iff.1 h n hn) hn
state_before: α : Type u_1
inst✝¹ : Semiring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b ≤ multiplicity p a
⊢ ∀ (n : ℕ), p ^ n ∣ b → p ^ n ∣ a + b
Theorem: UFModel.Models.rank_eq
File: Mathlib/Data/UnionFind.lean

tactic: rw [H.size_eq]
state_before: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
H : Models arr m
i : ℕ
h : i < Array.size arr
⊢ i < n

tactic: exact h
state_before: α : Type u_1
arr : Array (UFNode α)
n : ℕ
m : UFModel n
H : Models arr m
i : ℕ
h : i < Array.size arr
⊢ i < Array.size arr