tasksource/leandojo huggingface dataset:
Theorem: closure_Ico
File: Mathlib/Topology/Order/Basic.lean

tactic: apply Subset.antisymm
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ico a b) = Icc a b

tactic: exact closure_minimal Ico_subset_Icc_self isClosed_Icc
state_before: case h₁
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ closure (Ico a b) ⊆ Icc a b

tactic: apply Subset.trans _ (closure_mono Ioo_subset_Ico_self)
state_before: case h₂
α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ico a b)

tactic: rw [closure_Ioo hab]
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderTopology α
inst✝ : DenselyOrdered α
a✝ b✝ : α
s : Set α
a b : α
hab : a ≠ b
⊢ Icc a b ⊆ closure (Ioo a b)
Theorem: PrimeSpectrum.basicOpen_eq_zeroLocus_compl
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simp only [SetLike.mem_coe, mem_basicOpen, Set.mem_compl_iff, mem_zeroLocus,
Set.singleton_subset_iff]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
r : R
x : PrimeSpectrum R
⊢ x ∈ ↑(basicOpen r) ↔ x ∈ zeroLocus {r}ᶜ
Theorem: ENNReal.inv_lt_one
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [inv_lt_iff_inv_lt, inv_one]
state_before: α : Type ?u.270615
β : Type ?u.270618
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a⁻¹ < 1 ↔ 1 < a
Theorem: algebraicIndependent_subtype
File: Mathlib/RingTheory/AlgebraicIndependent.lean

tactic: apply @algebraicIndependent_comp_subtype _ _ _ id
state_before: ι : Type ?u.625472
ι' : Type ?u.625475
R : Type u_2
K : Type ?u.625481
A : Type u_1
A' : Type ?u.625487
A'' : Type ?u.625490
V : Type u
V' : Type ?u.625495
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
s : Set A
⊢ AlgebraicIndependent R Subtype.val ↔ ∀ (p : MvPolynomial A R), p ∈ supported R s → ↑(aeval _root_.id) p = 0 → p = 0
Theorem: ContinuousMap.Homotopy.symm_symm
File: Mathlib/Topology/Homotopy/Basic.lean

tactic: ext
state_before: F✝ : Type ?u.84224
X : Type u
Y : Type v
Z : Type w
Z' : Type x
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
F : Homotopy f₀ f₁
⊢ symm (symm F) = F

tactic: simp
state_before: case h
F✝ : Type ?u.84224
X : Type u
Y : Type v
Z : Type w
Z' : Type x
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
f₀ f₁ : C(X, Y)
F : Homotopy f₀ f₁
x✝ : ↑I × X
⊢ ↑(symm (symm F)) x✝ = ↑F x✝
Theorem: Matrix.mulVec_cramer
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

tactic: rw [cramer_eq_adjugate_mulVec, mulVec_mulVec, mul_adjugate, smul_mulVec_assoc, one_mulVec]
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
b : n → α
⊢ mulVec A (↑(cramer A) b) = det A • b
Theorem: Polynomial.Monic.mul_left_ne_zero
File: Mathlib/Data/Polynomial/Monic.lean

tactic: by_cases h : p = 1
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
⊢ q * p ≠ 0

tactic: rw [Ne.def, ← degree_eq_bot, hp.degree_mul, WithBot.add_eq_bot, not_or, degree_eq_bot]
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : ¬p = 1
⊢ q * p ≠ 0

tactic: refine' ⟨hq, _⟩
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : ¬p = 1
⊢ ¬q = 0 ∧ ¬degree p = ⊥

tactic: rw [← hp.degree_le_zero_iff_eq_one, not_le] at h
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : ¬p = 1
⊢ ¬degree p = ⊥

tactic: refine' (lt_trans _ h).ne'
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : 0 < degree p
⊢ ¬degree p = ⊥

tactic: simp
state_before: case neg
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : 0 < degree p
⊢ ⊥ < 0

tactic: simpa [h]
state_before: case pos
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p : R[X]
hp : Monic p
q : R[X]
hq : q ≠ 0
h : p = 1
⊢ q * p ≠ 0
Theorem: isClosed_sInter
File: Mathlib/Topology/Basic.lean

tactic: simpa only [← isOpen_compl_iff, compl_sInter, sUnion_image] using isOpen_biUnion
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set (Set α)
⊢ (∀ (t : Set α), t ∈ s → IsClosed t) → IsClosed (⋂₀ s)
Theorem: Set.exists_range_iff
File: Mathlib/Data/Set/Image.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.64271
γ : Type ?u.64274
ι : Sort u_2
ι' : Sort ?u.64280
f : ι → α
s t : Set α
p : α → Prop
⊢ (∃ a, a ∈ range f ∧ p a) ↔ ∃ i, p (f i)
Theorem: Set.nonempty_iInter₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.138078
γ : Type ?u.138081
ι : Sort u_2
ι' : Sort ?u.138087
ι₂ : Sort ?u.138090
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.138100
κ₂ : ι → Sort ?u.138105
κ' : ι' → Sort ?u.138110
s : (i : ι) → κ i → Set α
⊢ Set.Nonempty (⋂ (i : ι) (j : κ i), s i j) ↔ ∃ a, ∀ (i : ι) (j : κ i), a ∈ s i j
Theorem: frobenius_inj
File: Mathlib/Algebra/CharP/Basic.lean

tactic: rw [← sub_eq_zero] at H⊢
state_before: R : Type u_1
inst✝³ : CommRing R
inst✝² : IsReduced R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x h : R
H : ↑(frobenius R p) x = ↑(frobenius R p) h
⊢ x = h

tactic: rw [← frobenius_sub] at H
state_before: R : Type u_1
inst✝³ : CommRing R
inst✝² : IsReduced R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x h : R
H✝ : ↑(frobenius R p) x = ↑(frobenius R p) h
H : ↑(frobenius R p) x - ↑(frobenius R p) h = 0
⊢ x - h = 0

tactic: exact IsReduced.eq_zero _ ⟨_, H⟩
state_before: R : Type u_1
inst✝³ : CommRing R
inst✝² : IsReduced R
p : ℕ
inst✝¹ : Fact (Nat.Prime p)
inst✝ : CharP R p
x h : R
H✝ : ↑(frobenius R p) x = ↑(frobenius R p) h
H : ↑(frobenius R p) (x - h) = 0
⊢ x - h = 0
Theorem: Nat.even_add'
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [even_add, even_iff_not_odd, even_iff_not_odd, not_iff_not]
state_before: m n : ℕ
⊢ Even (m + n) ↔ (Odd m ↔ Odd n)
Theorem: Real.two_pi_pos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: linarith [pi_pos]
state_before: ⊢ 0 < 2 * π
Theorem: Lagrange.basis_singleton
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [Lagrange.basis, erase_singleton, prod_empty]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i✝ j i : ι
⊢ Lagrange.basis {i} v i = 1
Theorem: measurable_to_bool
File: Mathlib/MeasureTheory/MeasurableSpace.lean

tactic: apply measurable_to_countable'
state_before: α : Type u_1
β : Type ?u.49288
γ : Type ?u.49291
δ : Type ?u.49294
δ' : Type ?u.49297
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ Measurable f

tactic: rintro (- | -)
state_before: case h
α : Type u_1
β : Type ?u.49288
γ : Type ?u.49291
δ : Type ?u.49294
δ' : Type ?u.49297
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ ∀ (x : Bool), MeasurableSet (f ⁻¹' {x})

tactic: exact h
state_before: case h.true
α : Type u_1
β : Type ?u.49288
γ : Type ?u.49291
δ : Type ?u.49294
δ' : Type ?u.49297
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ MeasurableSet (f ⁻¹' {true})

tactic: convert h.compl
state_before: case h.false
α : Type u_1
β : Type ?u.49288
γ : Type ?u.49291
δ : Type ?u.49294
δ' : Type ?u.49297
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ MeasurableSet (f ⁻¹' {false})

tactic: rw [← preimage_compl, Bool.compl_singleton, Bool.not_true]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.49288
γ : Type ?u.49291
δ : Type ?u.49294
δ' : Type ?u.49297
ι : Sort uι
s t u : Set α
inst✝ : MeasurableSpace α
f : α → Bool
h : MeasurableSet (f ⁻¹' {true})
⊢ f ⁻¹' {false} = (f ⁻¹' {true})ᶜ
Theorem: Set.ncard_insert_le
File: Mathlib/Data/Set/Ncard.lean

tactic: obtain hs | hs := s.finite_or_infinite
state_before: α : Type u_1
β : Type ?u.11040
s✝ t : Set α
a✝ b x y : α
f : α → β
a : α
s : Set α
⊢ ncard (insert a s) ≤ ncard s + 1

tactic: rw [(hs.mono (subset_insert a s)).ncard]
state_before: case inr
α : Type u_1
β : Type ?u.11040
s✝ t : Set α
a✝ b x y : α
f : α → β
a : α
s : Set α
hs : Set.Infinite s
⊢ ncard (insert a s) ≤ ncard s + 1

tactic: exact Nat.zero_le _
state_before: case inr
α : Type u_1
β : Type ?u.11040
s✝ t : Set α
a✝ b x y : α
f : α → β
a : α
s : Set α
hs : Set.Infinite s
⊢ 0 ≤ ncard s + 1

tactic: exact (em (a ∈ s)).elim (fun h ↦ (ncard_insert_of_mem h).trans_le (Nat.le_succ _))
  (fun h ↦ by rw [ncard_insert_of_not_mem h hs])
state_before: case inl
α : Type u_1
β : Type ?u.11040
s✝ t : Set α
a✝ b x y : α
f : α → β
a : α
s : Set α
hs : Set.Finite s
⊢ ncard (insert a s) ≤ ncard s + 1

tactic: rw [ncard_insert_of_not_mem h hs]
state_before: α : Type u_1
β : Type ?u.11040
s✝ t : Set α
a✝ b x y : α
f : α → β
a : α
s : Set α
hs : Set.Finite s
h : ¬a ∈ s
⊢ ncard (insert a s) ≤ ncard s + 1
Theorem: Multiset.prod_dvd_prod_of_le
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: obtain ⟨z, rfl⟩ := exists_add_of_le h
state_before: ι : Type ?u.84722
α : Type u_1
β : Type ?u.84728
γ : Type ?u.84731
inst✝ : CommMonoid α
s t : Multiset α
a : α
m : Multiset ι
f g : ι → α
h : s ≤ t
⊢ prod s ∣ prod t

tactic: simp only [prod_add, dvd_mul_right]
state_before: case intro
ι : Type ?u.84722
α : Type u_1
β : Type ?u.84728
γ : Type ?u.84731
inst✝ : CommMonoid α
s : Multiset α
a : α
m : Multiset ι
f g : ι → α
z : Multiset α
h : s ≤ s + z
⊢ prod s ∣ prod (s + z)
Theorem: mul_div_left_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.37588
G : Type ?u.37591
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a * (b / c) = b * (a / c)
Theorem: Real.lt_logb_iff_rpow_lt
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

tactic: rw [← rpow_lt_rpow_left_iff hb, rpow_logb (b_pos hb) (b_ne_one' hb) hy]
state_before: b x y : ℝ
hb : 1 < b
hy : 0 < y
⊢ x < logb b y ↔ b ^ x < y
Theorem: Set.Ici_add_bij
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: refine'
  ⟨fun x h => add_le_add_right (mem_Ici.mp h) _, (add_left_injective d).injOn _, fun _ h => _⟩
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a) (Ici (a + d))

tactic: obtain ⟨c, rfl⟩ := exists_add_of_le (mem_Ici.mp h)
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d x✝ : M
h : x✝ ∈ Ici (a + d)
⊢ x✝ ∈ (fun x => x + d) '' Ici a

tactic: rw [mem_Ici, add_right_comm, add_le_add_iff_right] at h
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a + d + c ∈ Ici (a + d)
⊢ a + d + c ∈ (fun x => x + d) '' Ici a

tactic: exact ⟨a + c, h, by rw [add_right_comm]⟩
state_before: case intro
M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ a + d + c ∈ (fun x => x + d) '' Ici a

tactic: rw [add_right_comm]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c✝ d c : M
h : a ≤ a + c
⊢ (fun x => x + d) (a + c) = a + d + c
Theorem: Multiset.one_le_prod_of_one_le
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: simpa using List.one_le_prod_of_one_le hl
state_before: ι : Type ?u.116545
α : Type u_1
β : Type ?u.116551
γ : Type ?u.116554
inst✝ : OrderedCommMonoid α
s t : Multiset α
a : α
l : List α
hl : ∀ (x : α), x ∈ Quotient.mk (List.isSetoid α) l → 1 ≤ x
⊢ 1 ≤ prod (Quotient.mk (List.isSetoid α) l)
Theorem: CategoryTheory.Limits.pullbackDiagonalMapIdIso_hom_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

tactic: delta pullbackDiagonalMapIdIso
state_before: C : Type u_2
inst✝⁵ : Category C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ :
  HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i))
⊢ (pullbackDiagonalMapIdIso f g i).hom ≫ fst = snd ≫ fst

tactic: simp
state_before: C : Type u_2
inst✝⁵ : Category C
X Y Z : C
inst✝⁴ : HasPullbacks C
S T : C
f : X ⟶ T
g : Y ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f g
inst✝¹ : HasPullback (f ≫ i) (g ≫ i)
inst✝ :
  HasPullback (diagonal i) (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i))
⊢ (asIso
            (map (diagonal i)
              (map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i)) (diagonal i)
              (map ((f ≫ inv fst) ≫ snd) ((g ≫ inv fst) ≫ snd) i i ((f ≫ inv fst) ≫ fst) ((g ≫ inv fst) ≫ fst) (𝟙 S)
                (_ : ((f ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((f ≫ inv fst) ≫ fst) ≫ i)
                (_ : ((g ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((g ≫ inv fst) ≫ fst) ≫ i))
              (𝟙 T) (congrHom (_ : f ≫ i = (f ≫ inv fst) ≫ snd) (_ : g ≫ i = (g ≫ inv fst) ≫ snd)).hom
              (𝟙 (diagonalObj i)) (_ : diagonal i ≫ 𝟙 (diagonalObj i) = 𝟙 T ≫ diagonal i)
              (_ :
                map (f ≫ i) (g ≫ i) i i f g (𝟙 S) (_ : (f ≫ i) ≫ 𝟙 S = f ≫ i) (_ : (g ≫ i) ≫ 𝟙 S = g ≫ i) ≫
                    𝟙 (diagonalObj i) =
                  (congrHom (_ : f ≫ i = (f ≫ inv fst) ≫ snd) (_ : g ≫ i = (g ≫ inv fst) ≫ snd)).hom ≫
                    map ((f ≫ inv fst) ≫ snd) ((g ≫ inv fst) ≫ snd) i i ((f ≫ inv fst) ≫ fst) ((g ≫ inv fst) ≫ fst)
                      (𝟙 S) (_ : ((f ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((f ≫ inv fst) ≫ fst) ≫ i)
                      (_ : ((g ≫ inv fst) ≫ snd) ≫ 𝟙 S = ((g ≫ inv fst) ≫ fst) ≫ i))) ≪≫
          pullbackDiagonalMapIso i (𝟙 S) (f ≫ inv fst) (g ≫ inv fst) ≪≫
            asIso
              (map (f ≫ inv fst) (g ≫ inv fst) f g (𝟙 X) (𝟙 Y) fst (_ : (f ≫ inv fst) ≫ fst = 𝟙 X ≫ f)
                (_ : (g ≫ inv fst) ≫ fst = 𝟙 Y ≫ g))).hom ≫
      fst =
    snd ≫ fst
Theorem: Ordinal.nhds_left'_eq_nhds_ne
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: rw [← nhds_left'_sup_nhds_right', nhds_right', sup_bot_eq]
state_before: s : Set Ordinal
a✝ : Ordinal
a : Ordinal
⊢ 𝓝[Set.Iio a] a = 𝓝[{a}ᶜ] a
Theorem: Polynomial.eq_of_degree_sub_lt_of_eval_index_eq
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [← sub_eq_zero]
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_fg_lt : degree (f - g) < ↑(card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ f = g

tactic: refine' eq_zero_of_degree_lt_of_eval_index_eq_zero _ hvs degree_fg_lt _
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_fg_lt : degree (f - g) < ↑(card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ f - g = 0

tactic: simp_rw [eval_sub, sub_eq_zero]
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_fg_lt : degree (f - g) < ↑(card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ ∀ (i : ι), i ∈ s → eval (v i) (f - g) = 0

tactic: exact eval_fg
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_fg_lt : degree (f - g) < ↑(card s)
eval_fg : ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
⊢ ∀ (i : ι), i ∈ s → eval (v i) f = eval (v i) g
Theorem: Finset.card_sigmaLift
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp_rw [sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ card (sigmaLift f a b) = if h : a.fst = b.fst then card (f (h ▸ a.snd) b.snd) else 0

tactic: split_ifs with h <;> simp [h]
state_before: ι : Type u_1
α : ι → Type u_3
β : ι → Type u_4
γ : ι → Type u_2
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ card (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅) =
    if h : a.fst = b.fst then card (f (h ▸ a.snd) b.snd) else 0
Theorem: vsub_sub_vsub_cancel_left
File: Mathlib/Algebra/AddTorsor.lean

tactic: rw [sub_eq_add_neg, neg_vsub_eq_vsub_rev, add_comm, vsub_add_vsub_cancel]
state_before: G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
p1 p2 p3 : P
⊢ p3 -ᵥ p2 - (p3 -ᵥ p1) = p1 -ᵥ p2
Theorem: MeasureTheory.lintegral_prod_swap
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: rw [← prod_swap] at hf
state_before: α : Type u_1
α' : Type ?u.5352062
β : Type u_2
β' : Type ?u.5352068
γ : Type ?u.5352071
E : Type ?u.5352074
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f
⊢ (∫⁻ (z : β × α), f (Prod.swap z) ∂Measure.prod ν μ) = ∫⁻ (z : α × β), f z ∂Measure.prod μ ν

tactic: rw [← lintegral_map' hf measurable_swap.aemeasurable, prod_swap]
state_before: α : Type u_1
α' : Type ?u.5352062
β : Type u_2
β' : Type ?u.5352068
γ : Type ?u.5352071
E : Type ?u.5352074
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
f : α × β → ℝ≥0∞
hf : AEMeasurable f
⊢ (∫⁻ (z : β × α), f (Prod.swap z) ∂Measure.prod ν μ) = ∫⁻ (z : α × β), f z ∂Measure.prod μ ν
Theorem: linearIndependent_biUnion_of_directed
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [biUnion_eq_iUnion]
state_before: ι : Type u'
ι' : Type ?u.220541
R : Type u_3
K : Type ?u.220547
M : Type u_2
M' : Type ?u.220553
M'' : Type ?u.220556
V : Type u
V' : Type ?u.220561
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_1
s : Set η
t : η → Set M
hs : DirectedOn (t ⁻¹'o fun x x_1 => x ⊆ x_1) s
h : ∀ (a : η), a ∈ s → LinearIndependent R fun x => ↑x
⊢ LinearIndependent R fun x => ↑x

tactic: exact
  linearIndependent_iUnion_of_directed (directed_comp.2 <| hs.directed_val) (by simpa using h)
state_before: ι : Type u'
ι' : Type ?u.220541
R : Type u_3
K : Type ?u.220547
M : Type u_2
M' : Type ?u.220553
M'' : Type ?u.220556
V : Type u
V' : Type ?u.220561
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_1
s : Set η
t : η → Set M
hs : DirectedOn (t ⁻¹'o fun x x_1 => x ⊆ x_1) s
h : ∀ (a : η), a ∈ s → LinearIndependent R fun x => ↑x
⊢ LinearIndependent R fun x => ↑x

tactic: simpa using h
state_before: ι : Type u'
ι' : Type ?u.220541
R : Type u_3
K : Type ?u.220547
M : Type u_2
M' : Type ?u.220553
M'' : Type ?u.220556
V : Type u
V' : Type ?u.220561
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
η : Type u_1
s : Set η
t : η → Set M
hs : DirectedOn (t ⁻¹'o fun x x_1 => x ⊆ x_1) s
h : ∀ (a : η), a ∈ s → LinearIndependent R fun x => ↑x
⊢ ∀ (i : ↑s), LinearIndependent R fun x => ↑x
Theorem: Multiset.untrop_prod
File: Mathlib/Algebra/Tropical/BigOperators.lean

tactic: simpa using List.untrop_prod
state_before: R : Type u_1
S : Type ?u.11886
inst✝ : AddCommMonoid R
s : Multiset (Tropical R)
⊢ ∀ (a : List (Tropical R)),
    untrop (prod (Quotient.mk (List.isSetoid (Tropical R)) a)) =
      sum (map untrop (Quotient.mk (List.isSetoid (Tropical R)) a))
Theorem: List.append_eq_cons
File: Std/Data/List/Lemmas.lean

tactic: cases a with simp | cons a as => ?_
state_before: α✝ : Type u_1
a b : List α✝
x : α✝
c : List α✝
⊢ a ++ b = x :: c ↔ a = [] ∧ b = x :: c ∨ ∃ a', a = x :: a' ∧ c = a' ++ b

tactic: exact ⟨fun h => ⟨as, by simp [h]⟩, fun ⟨a', ⟨aeq, aseq⟩, h⟩ => ⟨aeq, by rw [aseq, h]⟩⟩
state_before: case cons
α✝ : Type u_1
b : List α✝
x : α✝
c : List α✝
a : α✝
as : List α✝
⊢ a = x ∧ as ++ b = c ↔ ∃ a', (a = x ∧ as = a') ∧ c = a' ++ b

tactic: simp [h]
state_before: α✝ : Type u_1
b : List α✝
x : α✝
c : List α✝
a : α✝
as : List α✝
h : a = x ∧ as ++ b = c
⊢ (a = x ∧ as = as) ∧ c = as ++ b

tactic: rw [aseq, h]
state_before: α✝ : Type u_1
b : List α✝
x : α✝
c : List α✝
a : α✝
as : List α✝
x✝ : ∃ a', (a = x ∧ as = a') ∧ c = a' ++ b
a' : List α✝
aeq : a = x
aseq : as = a'
h : c = a' ++ b
⊢ as ++ b = c
Theorem: LaurentPolynomial.degree_T_le
File: Mathlib/Data/Polynomial/Laurent.lean

tactic: rw [map_one, one_mul]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
⊢ degree (T n) = degree (↑C 1 * T n)
Theorem: MeasureTheory.lintegral_add_measure
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simpa [tsum_fintype] using lintegral_sum_measure f fun b => cond b μ ν
state_before: α : Type u_1
β : Type ?u.918292
γ : Type ?u.918295
δ : Type ?u.918298
m✝ : MeasurableSpace α
μ✝ ν✝ : Measure α
m : MeasurableSpace α
f : α → ℝ≥0∞
μ ν : Measure α
⊢ (∫⁻ (a : α), f a ∂μ + ν) = (∫⁻ (a : α), f a ∂μ) + ∫⁻ (a : α), f a ∂ν
Theorem: Asymptotics.isTheta_const_mul_right
File: Mathlib/Analysis/Asymptotics/Theta.lean

tactic: simpa only [← smul_eq_mul] using isTheta_const_smul_right hc
state_before: α : Type u_2
β : Type ?u.60720
E : Type u_3
F : Type ?u.60726
G : Type ?u.60729
E' : Type ?u.60732
F' : Type ?u.60735
G' : Type ?u.60738
E'' : Type ?u.60741
F'' : Type ?u.60744
G'' : Type ?u.60747
R : Type ?u.60750
R' : Type ?u.60753
𝕜 : Type u_1
𝕜' : Type ?u.60759
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c✝ c' c₁ c₂ : ℝ
f : α → E
g✝ : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
l l' : Filter α
c : 𝕜
g : α → 𝕜
hc : c ≠ 0
⊢ (f =Θ[l] fun x => c * g x) ↔ f =Θ[l] g
Theorem: FormalMultilinearSeries.order_zero
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: simp [order]
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁰ : CommRing 𝕜
n : ℕ
inst✝⁹ : AddCommGroup E
inst✝⁸ : Module 𝕜 E
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalAddGroup E
inst✝⁵ : ContinuousConstSMul 𝕜 E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
⊢ order 0 = 0