tasksource/leandojo huggingface dataset:
Theorem: Set.seq_def
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [seq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.258305
ι : Sort ?u.258308
ι' : Sort ?u.258311
ι₂ : Sort ?u.258314
κ : ι → Sort ?u.258319
κ₁ : ι → Sort ?u.258324
κ₂ : ι → Sort ?u.258329
κ' : ι' → Sort ?u.258334
s : Set (α → β)
t : Set α
⊢ ∀ (x : β), x ∈ seq s t ↔ x ∈ ⋃ (f : α → β) (_ : f ∈ s), f '' t
Theorem: mul_div_cancel_of_imp
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

tactic: simp [*]
state_before: α : Type ?u.9473
M₀ : Type ?u.9476
G₀ : Type u_1
M₀' : Type ?u.9482
G₀' : Type ?u.9485
F : Type ?u.9488
F' : Type ?u.9491
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a✝ b✝ c a b : G₀
h : b = 0 → a = 0
hb : b = 0
⊢ a * b / b = a
Theorem: Ideal.quotientToQuotientRangePowQuotSuccAux_mk
File: Mathlib/NumberTheory/RamificationInertia.lean

tactic: apply Quotient.map'_mk''
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
a : S
a_mem : a ∈ P ^ i
x : S
⊢ quotientToQuotientRangePowQuotSuccAux f p P a_mem (Submodule.Quotient.mk x) =
    Submodule.Quotient.mk
      { val := ↑(Quotient.mk (P ^ e)) (x * a),
        property := (_ : ↑(Quotient.mk (P ^ e)) (x * a) ∈ map (Quotient.mk (P ^ e)) (P ^ i)) }
Theorem: Pell.eq_pow_of_pell_lem
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [sub_sq, mul_one, one_pow, sub_add, sub_sub_cancel, two_mul, sub_sub, ← add_sub,
  le_add_iff_nonneg_right, sub_nonneg, Int.add_one_le_iff]
state_before: a y k : ℕ
hy0 : y ≠ 0
hk0 : k ≠ 0
hyk : y ^ k < a
hya : y < a
⊢ ↑a ≤ ↑a ^ 2 - (↑a - 1) ^ 2 - 1

tactic: norm_cast
state_before: a y k : ℕ
hy0 : y ≠ 0
hk0 : k ≠ 0
hyk : y ^ k < a
hya : y < a
⊢ 1 < ↑a

tactic: exact lt_of_le_of_lt (Nat.succ_le_of_lt (Nat.pos_of_ne_zero hy0)) hya
state_before: a y k : ℕ
hy0 : y ≠ 0
hk0 : k ≠ 0
hyk : y ^ k < a
hya : y < a
⊢ 1 < a

tactic: have := hya.le
state_before: a y k : ℕ
hy0 : y ≠ 0
hk0 : k ≠ 0
hyk : y ^ k < a
hya : y < a
⊢ ↑a ^ 2 - (↑a - 1) ^ 2 - 1 ≤ ↑a ^ 2 - (↑a - ↑y) ^ 2 - 1

tactic: mono * <;> norm_cast <;> simp [Nat.zero_le, Nat.succ_le_of_lt (Nat.pos_of_ne_zero hy0)]
state_before: a y k : ℕ
hy0 : y ≠ 0
hk0 : k ≠ 0
hyk : y ^ k < a
hya : y < a
this : y ≤ a
⊢ ↑a ^ 2 - (↑a - 1) ^ 2 - 1 ≤ ↑a ^ 2 - (↑a - ↑y) ^ 2 - 1

tactic: ring
state_before: a y k : ℕ
hy0 : y ≠ 0
hk0 : k ≠ 0
hyk : y ^ k < a
hya : y < a
⊢ ↑a ^ 2 - (↑a - ↑y) ^ 2 - 1 = 2 * ↑a * ↑y - ↑y * ↑y - 1
Theorem: UniqueFactorizationMonoid.normalizedFactors_of_irreducible_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [normalizedFactors_pow, normalizedFactors_irreducible hp, Multiset.nsmul_singleton]
state_before: α : Type u_1
inst✝³ : CancelCommMonoidWithZero α
inst✝² : DecidableEq α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p : α
hp : Irreducible p
k : ℕ
⊢ normalizedFactors (p ^ k) = Multiset.replicate k (↑normalize p)
Theorem: Nat.two_not_dvd_two_mul_add_one
File: Mathlib/Data/Nat/Parity.lean

tactic: simp [add_mod]
state_before: m n✝ n : ℕ
⊢ ¬2 ∣ 2 * n + 1
Theorem: CategoryTheory.Presheaf.isSheaf_iff_isLimit_pretopology
File: Mathlib/CategoryTheory/Sites/Sheaf.lean

tactic: dsimp [IsSheaf]
state_before: C : Type u₁
inst✝² : Category C
A : Type u₂
inst✝¹ : Category A
J : GrothendieckTopology C
P : Cᵒᵖ ⥤ A
X : C
S : Sieve X
R : Presieve X
E : Aᵒᵖ
x : FamilyOfElements (P ⋙ coyoneda.obj E) S.arrows
hx : SieveCompatible x
inst✝ : HasPullbacks C
K : Pretopology C
⊢ IsSheaf (Pretopology.toGrothendieck C K) P ↔
    ∀ ⦃X : C⦄ (R : Presieve X),
      R ∈ Pretopology.coverings K X → Nonempty (IsLimit (P.mapCone (Cocone.op (cocone (generate R).arrows))))

tactic: simp_rw [isSheaf_pretopology]
state_before: C : Type u₁
inst✝² : Category C
A : Type u₂
inst✝¹ : Category A
J : GrothendieckTopology C
P : Cᵒᵖ ⥤ A
X : C
S : Sieve X
R : Presieve X
E : Aᵒᵖ
x : FamilyOfElements (P ⋙ coyoneda.obj E) S.arrows
hx : SieveCompatible x
inst✝ : HasPullbacks C
K : Pretopology C
⊢ (∀ (E : A), Presieve.IsSheaf (Pretopology.toGrothendieck C K) (P ⋙ coyoneda.obj E.op)) ↔
    ∀ ⦃X : C⦄ (R : Presieve X),
      R ∈ Pretopology.coverings K X → Nonempty (IsLimit (P.mapCone (Cocone.op (cocone (generate R).arrows))))

tactic: exact
  ⟨fun h X R hR => (isLimit_iff_isSheafFor_presieve P R).2 fun E => h E.unop R hR,
    fun h E X R hR => (isLimit_iff_isSheafFor_presieve P R).1 (h R hR) (op E)⟩
state_before: C : Type u₁
inst✝² : Category C
A : Type u₂
inst✝¹ : Category A
J : GrothendieckTopology C
P : Cᵒᵖ ⥤ A
X : C
S : Sieve X
R : Presieve X
E : Aᵒᵖ
x : FamilyOfElements (P ⋙ coyoneda.obj E) S.arrows
hx : SieveCompatible x
inst✝ : HasPullbacks C
K : Pretopology C
⊢ (∀ (E : A) {X : C} (R : Presieve X), R ∈ Pretopology.coverings K X → IsSheafFor (P ⋙ coyoneda.obj E.op) R) ↔
    ∀ ⦃X : C⦄ (R : Presieve X),
      R ∈ Pretopology.coverings K X → Nonempty (IsLimit (P.mapCone (Cocone.op (cocone (generate R).arrows))))
Theorem: matPolyEquiv_coeff_apply_aux_1
File: Mathlib/RingTheory/PolynomialAlgebra.lean

tactic: simp only [matPolyEquiv, AlgEquiv.trans_apply, matrixEquivTensor_apply_std_basis]
state_before: R : Type u_1
A : Type ?u.483263
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
i j : n
k : ℕ
x : R
⊢ ↑matPolyEquiv (stdBasisMatrix i j (↑(monomial k) x)) = ↑(monomial k) (stdBasisMatrix i j x)

tactic: apply (polyEquivTensor R (Matrix n n R)).injective
state_before: R : Type u_1
A : Type ?u.483263
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
i j : n
k : ℕ
x : R
⊢ ↑(AlgEquiv.symm (polyEquivTensor R (Matrix n n R)))
      (↑(Algebra.TensorProduct.comm R R[X] (Matrix n n R)) (↑(monomial k) x ⊗ₜ[R] stdBasisMatrix i j 1)) =
    ↑(monomial k) (stdBasisMatrix i j x)

tactic: simp only [AlgEquiv.apply_symm_apply,Algebra.TensorProduct.comm_tmul,
  polyEquivTensor_apply, eval₂_monomial]
state_before: case a
R : Type u_1
A : Type ?u.483263
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
i j : n
k : ℕ
x : R
⊢ ↑(polyEquivTensor R (Matrix n n R))
      (↑(AlgEquiv.symm (polyEquivTensor R (Matrix n n R)))
        (↑(Algebra.TensorProduct.comm R R[X] (Matrix n n R)) (↑(monomial k) x ⊗ₜ[R] stdBasisMatrix i j 1))) =
    ↑(polyEquivTensor R (Matrix n n R)) (↑(monomial k) (stdBasisMatrix i j x))

tactic: simp only [Algebra.TensorProduct.tmul_mul_tmul, one_pow, one_mul, Matrix.mul_one,
  Algebra.TensorProduct.tmul_pow, Algebra.TensorProduct.includeLeft_apply, mul_eq_mul]
state_before: case a
R : Type u_1
A : Type ?u.483263
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
i j : n
k : ℕ
x : R
⊢ stdBasisMatrix i j 1 ⊗ₜ[R] ↑(monomial k) x = ↑↑includeLeft (stdBasisMatrix i j x) * 1 ⊗ₜ[R] X ^ k

tactic: rw [← smul_X_eq_monomial, ← TensorProduct.smul_tmul]
state_before: case a
R : Type u_1
A : Type ?u.483263
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
i j : n
k : ℕ
x : R
⊢ stdBasisMatrix i j 1 ⊗ₜ[R] ↑(monomial k) x = ↑↑includeLeft (stdBasisMatrix i j x) * 1 ⊗ₜ[R] (X ^ k)

tactic: congr with i' <;> simp [stdBasisMatrix]
state_before: case a
R : Type u_1
A : Type ?u.483263
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
i j : n
k : ℕ
x : R
⊢ (x • stdBasisMatrix i j 1) ⊗ₜ[R] (X ^ k) = ↑↑includeLeft (stdBasisMatrix i j x) * 1 ⊗ₜ[R] (X ^ k)
Theorem: Complex.re_eq_add_conj
File: Mathlib/Data/Complex/Basic.lean

tactic: have : (↑(↑2 : ℝ) : ℂ)  = (2 : ℂ) := by rfl
state_before: z : ℂ
⊢ ↑z.re = (z + ↑(starRingEnd ℂ) z) / 2

tactic: simp only [add_conj, ofReal_mul, ofReal_one, ofReal_bit0, this,
  mul_div_cancel_left (z.re : ℂ) two_ne_zero]
state_before: z : ℂ
this : ↑2 = 2
⊢ ↑z.re = (z + ↑(starRingEnd ℂ) z) / 2

tactic: rfl
state_before: z : ℂ
⊢ ↑2 = 2
Theorem: mul_right_mem_nonZeroDivisors_eq_zero_iff
File: Mathlib/RingTheory/NonZeroDivisors.lean

tactic: simp (config := { contextual := true })
state_before: M : Type u_1
M' : Type ?u.10326
M₁ : Type ?u.10329
R : Type ?u.10332
R' : Type ?u.10335
F : Type ?u.10338
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x r : M
hr : r ∈ M⁰
⊢ x = 0 → x * r = 0
Theorem: Set.image_image2_antidistrib
File: Mathlib/Data/Set/NAry.lean

tactic: rw [image2_swap f]
state_before: α : Type u_3
α' : Type u_6
β : Type u_4
β' : Type u_5
γ : Type u_2
γ' : Type ?u.47516
δ : Type u_1
δ' : Type ?u.47522
ε : Type ?u.47525
ε' : Type ?u.47528
ζ : Type ?u.47531
ζ' : Type ?u.47534
ν : Type ?u.47537
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ g '' image2 f s t = image2 f' (g₁ '' t) (g₂ '' s)

tactic: exact image_image2_distrib fun _ _ => h_antidistrib _ _
state_before: α : Type u_3
α' : Type u_6
β : Type u_4
β' : Type u_5
γ : Type u_2
γ' : Type ?u.47516
δ : Type u_1
δ' : Type ?u.47522
ε : Type ?u.47525
ε' : Type ?u.47528
ζ : Type ?u.47531
ζ' : Type ?u.47534
ν : Type ?u.47537
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : β' → α' → δ
g₁ : β → β'
g₂ : α → α'
h_antidistrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ b) (g₂ a)
⊢ g '' image2 (fun a b => f b a) t s = image2 f' (g₁ '' t) (g₂ '' s)
Theorem: Complex.frontier_setOf_im_le
File: Mathlib/Analysis/Complex/ReImTopology.lean

tactic: simpa only [frontier_Iic] using frontier_preimage_im (Iic a)
state_before: a : ℝ
⊢ frontier {z | z.im ≤ a} = {z | z.im = a}
Theorem: NNReal.iInf_const_zero
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [← NNReal.coe_eq, coe_iInf]
state_before: ι : Sort ?u.273037
f : ι → ℝ≥0
α : Sort u_1
⊢ (⨅ (x : α), 0) = 0

tactic: exact Real.ciInf_const_zero
state_before: ι : Sort ?u.273037
f : ι → ℝ≥0
α : Sort u_1
⊢ (⨅ (i : α), ↑0) = ↑0
Theorem: FreeCommRing.isSupported_int
File: Mathlib/RingTheory/FreeCommRing.lean

tactic: rw [Int.cast_add, Int.cast_one]
state_before: α : Type u
β : Type v
f : α → β
x y : FreeCommRing α
s✝ t : Set α
i✝ : ℤ
s : Set α
i : ℕ
hi : IsSupported (↑↑i) s
⊢ IsSupported (↑(↑i + 1)) s

tactic: exact isSupported_add hi isSupported_one
state_before: α : Type u
β : Type v
f : α → β
x y : FreeCommRing α
s✝ t : Set α
i✝ : ℤ
s : Set α
i : ℕ
hi : IsSupported (↑↑i) s
⊢ IsSupported (↑↑i + 1) s

tactic: rw [Int.cast_sub, Int.cast_one]
state_before: α : Type u
β : Type v
f : α → β
x y : FreeCommRing α
s✝ t : Set α
i✝ : ℤ
s : Set α
i : ℕ
hi : IsSupported (↑(-↑i)) s
⊢ IsSupported (↑(-↑i - 1)) s

tactic: exact isSupported_sub hi isSupported_one
state_before: α : Type u
β : Type v
f : α → β
x y : FreeCommRing α
s✝ t : Set α
i✝ : ℤ
s : Set α
i : ℕ
hi : IsSupported (↑(-↑i)) s
⊢ IsSupported (↑(-↑i) - 1) s
Theorem: Cardinal.nat_power_eq
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: assumption_mod_cast
state_before: c : Cardinal
h : ℵ₀ ≤ c
n : ℕ
hn : 2 ≤ n
⊢ 2 ≤ ↑n
Theorem: Matrix.det_of_card_zero
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: rw [Fintype.card_eq_zero_iff] at h
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ : Matrix n n R
h : Fintype.card n = 0
M : Matrix n n R
⊢ det M = 1

tactic: suffices M = 1 by simp [this]
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ : Matrix n n R
h : IsEmpty n
M : Matrix n n R
⊢ det M = 1

tactic: ext i
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ : Matrix n n R
h : IsEmpty n
M : Matrix n n R
⊢ M = 1

tactic: exact h.elim i
state_before: case a.h
R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ : Matrix n n R
h : IsEmpty n
M : Matrix n n R
i x✝ : n
⊢ M i x✝ = OfNat.ofNat 1 i x✝

tactic: simp [this]
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ : Matrix n n R
h : IsEmpty n
M : Matrix n n R
this : M = 1
⊢ det M = 1
Theorem: Multiset.map_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

tactic: rw [← Multiset.card_eq_zero, Multiset.card_map, Multiset.card_eq_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.121444
s : Multiset α
f : α → β
⊢ map f s = 0 ↔ s = 0
Theorem: SemiconjBy.function_semiconj_mul_left
File: Mathlib/Algebra/Hom/Iterate.lean

tactic: dsimp only
state_before: M : Type ?u.84938
N : Type ?u.84941
G : Type u_1
H : Type ?u.84947
inst✝ : Semigroup G
a b c : G
h : SemiconjBy a b c
j : G
⊢ (fun x => a * x) ((fun x => b * x) j) = (fun x => c * x) ((fun x => a * x) j)

tactic: rw [← mul_assoc, h.eq, mul_assoc]
state_before: M : Type ?u.84938
N : Type ?u.84941
G : Type u_1
H : Type ?u.84947
inst✝ : Semigroup G
a b c : G
h : SemiconjBy a b c
j : G
⊢ a * (b * j) = c * (a * j)
Theorem: MeasureTheory.set_integral_nonpos_ae
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rwa [EventuallyLE, ae_restrict_iff' hs]
state_before: α : Type u_1
β : Type ?u.297148
E : Type ?u.297151
F : Type ?u.297154
inst✝ : MeasurableSpace α
μ : Measure α
f : α → ℝ
s : Set α
hs : MeasurableSet s
hf : ∀ᵐ (a : α) ∂μ, a ∈ s → f a ≤ 0
⊢ (fun a => f a) ≤ᵐ[Measure.restrict μ s] 0
Theorem: MeasureTheory.ae_of_ae_restrict_of_ae_restrict_compl
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← inter_union_distrib_left, union_compl_self, inter_univ]
state_before: α : Type u_1
β : Type ?u.576854
γ : Type ?u.576857
δ : Type ?u.576860
ι : Type ?u.576863
R : Type ?u.576866
R' : Type ?u.576869
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ t : Set α
p : α → Prop
ht : ∀ᵐ (x : α) ∂Measure.restrict μ t, p x
htc : ∀ᵐ (x : α) ∂Measure.restrict μ (tᶜ), p x
⊢ ↑↑μ {x | ¬p x} = ↑↑μ ({x | ¬p x} ∩ t ∪ {x | ¬p x} ∩ tᶜ)

tactic: rw [ae_iff.1 ht, ae_iff.1 htc, zero_add]
state_before: α : Type u_1
β : Type ?u.576854
γ : Type ?u.576857
δ : Type ?u.576860
ι : Type ?u.576863
R : Type ?u.576866
R' : Type ?u.576869
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ t : Set α
p : α → Prop
ht : ∀ᵐ (x : α) ∂Measure.restrict μ t, p x
htc : ∀ᵐ (x : α) ∂Measure.restrict μ (tᶜ), p x
⊢ ↑↑(Measure.restrict μ t) {x | ¬p x} + ↑↑(Measure.restrict μ (tᶜ)) {x | ¬p x} = 0
Theorem: List.destutter'_singleton
File: Mathlib/Data/List/Destutter.lean

tactic: split_ifs with h <;> simp! [h]
state_before: α : Type u_1
l : List α
R : α → α → Prop
inst✝ : DecidableRel R
a b : α
⊢ destutter' R a [b] = if R a b then [a, b] else [a]
Theorem: Multiset.add_product
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [SProd.sprod, product]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.59441
δ : Type ?u.59444
a : α
b : β
s✝ : Multiset α
t✝ : Multiset β
s t : Multiset α
u : Multiset β
⊢ (s + t) ×ˢ u = s ×ˢ u + t ×ˢ u
Theorem: Fintype.card_compl_eq_card_compl
File: Mathlib/Data/Fintype/Card.lean

tactic: cases nonempty_fintype α
state_before: α : Type u_1
β : Type ?u.59809
γ : Type ?u.59812
inst✝⁴ : Finite α
p q : α → Prop
inst✝³ : Fintype { x // p x }
inst✝² : Fintype { x // ¬p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // ¬q x }
h : card { x // p x } = card { x // q x }
⊢ card { x // ¬p x } = card { x // ¬q x }

tactic: simp only [Fintype.card_subtype_compl, h]
state_before: case intro
α : Type u_1
β : Type ?u.59809
γ : Type ?u.59812
inst✝⁴ : Finite α
p q : α → Prop
inst✝³ : Fintype { x // p x }
inst✝² : Fintype { x // ¬p x }
inst✝¹ : Fintype { x // q x }
inst✝ : Fintype { x // ¬q x }
h : card { x // p x } = card { x // q x }
val✝ : Fintype α
⊢ card { x // ¬p x } = card { x // ¬q x }
Theorem: LowerSet.prod_le_prod_iff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.187458
ι : Sort ?u.187461
κ : ι → Sort ?u.187466
inst✝¹ : Preorder α
inst✝ : Preorder β
s s₁ s₂ : LowerSet α
t t₁ t₂ : LowerSet β
x : α × β
⊢ ↑s₁ ⊆ ↑s₂ ∧ ↑t₁ ⊆ ↑t₂ ∨ ↑s₁ = ∅ ∨ ↑t₁ = ∅ ↔ s₁ ≤ s₂ ∧ t₁ ≤ t₂ ∨ s₁ = ⊥ ∨ t₁ = ⊥
Theorem: List.prod_replicate
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' n with n ih
state_before: ι : Type ?u.13701
α : Type ?u.13704
M : Type u_1
N : Type ?u.13710
P : Type ?u.13713
M₀ : Type ?u.13716
G : Type ?u.13719
R : Type ?u.13722
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ : M
n : ℕ
a : M
⊢ prod (replicate n a) = a ^ n

tactic: rw [pow_zero]
state_before: case zero
ι : Type ?u.13701
α : Type ?u.13704
M : Type u_1
N : Type ?u.13710
P : Type ?u.13713
M₀ : Type ?u.13716
G : Type ?u.13719
R : Type ?u.13722
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
⊢ prod (replicate Nat.zero a) = a ^ Nat.zero

tactic: rfl
state_before: case zero
ι : Type ?u.13701
α : Type ?u.13704
M : Type u_1
N : Type ?u.13710
P : Type ?u.13713
M₀ : Type ?u.13716
G : Type ?u.13719
R : Type ?u.13722
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
⊢ prod (replicate Nat.zero a) = 1

tactic: rw [replicate_succ, prod_cons, ih, pow_succ]
state_before: case succ
ι : Type ?u.13701
α : Type ?u.13704
M : Type u_1
N : Type ?u.13710
P : Type ?u.13713
M₀ : Type ?u.13716
G : Type ?u.13719
R : Type ?u.13722
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ a : M
n : ℕ
ih : prod (replicate n a) = a ^ n
⊢ prod (replicate (Nat.succ n) a) = a ^ Nat.succ n
Theorem: exists_mem_Ico_zpow
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: classical exact
    let ⟨N, hN⟩ := pow_unbounded_of_one_lt x⁻¹ hy
    have he : ∃ m : ℤ, y ^ m ≤ x :=
      ⟨-N,
        le_of_lt
          (by
            rw [zpow_neg y ↑N, zpow_ofNat]
            exact (inv_lt hx (lt_trans (inv_pos.2 hx) hN)).1 hN)⟩
    let ⟨M, hM⟩ := pow_unbounded_of_one_lt x hy
    have hb : ∃ b : ℤ, ∀ m, y ^ m ≤ x → m ≤ b :=
      ⟨M, fun m hm =>
        le_of_not_lt fun hlt =>
          not_lt_of_ge (zpow_le_of_le hy.le hlt.le)
            (lt_of_le_of_lt hm (by rwa [← zpow_ofNat] at hM))⟩
    let ⟨n, hn₁, hn₂⟩ := Int.exists_greatest_of_bdd hb he
    ⟨n, hn₁, lt_of_not_ge fun hge => not_le_of_gt (Int.lt_succ _) (hn₂ _ hge)⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
⊢ ∃ n, x ∈ Ico (y ^ n) (y ^ (n + 1))

tactic: exact
let ⟨N, hN⟩ := pow_unbounded_of_one_lt x⁻¹ hy
have he : ∃ m : ℤ, y ^ m ≤ x :=
⟨-N,
le_of_lt
(by
  rw [zpow_neg y ↑N, zpow_ofNat]
  exact (inv_lt hx (lt_trans (inv_pos.2 hx) hN)).1 hN)⟩
let ⟨M, hM⟩ := pow_unbounded_of_one_lt x hy
have hb : ∃ b : ℤ, ∀ m, y ^ m ≤ x → m ≤ b :=
⟨M, fun m hm =>
le_of_not_lt fun hlt =>
not_lt_of_ge (zpow_le_of_le hy.le hlt.le)
  (lt_of_le_of_lt hm (by rwa [← zpow_ofNat] at hM))⟩
let ⟨n, hn₁, hn₂⟩ := Int.exists_greatest_of_bdd hb he
⟨n, hn₁, lt_of_not_ge fun hge => not_le_of_gt (Int.lt_succ _) (hn₂ _ hge)⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
⊢ ∃ n, x ∈ Ico (y ^ n) (y ^ (n + 1))

tactic: rw [zpow_neg y ↑N, zpow_ofNat]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
N : ℕ
hN : x⁻¹ < y ^ N
⊢ y ^ (-↑N) < x

tactic: exact (inv_lt hx (lt_trans (inv_pos.2 hx) hN)).1 hN
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
N : ℕ
hN : x⁻¹ < y ^ N
⊢ (y ^ N)⁻¹ < x

tactic: rwa [← zpow_ofNat] at hM
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
hx : 0 < x
hy : 1 < y
N : ℕ
hN : x⁻¹ < y ^ N
he : ∃ m, y ^ m ≤ x
M : ℕ
hM : x < y ^ M
m : ℤ
hm : y ^ m ≤ x
hlt : ↑M < m
⊢ x < y ^ ↑M
Theorem: norm_mk_eq_zero
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rwa [quotient_norm_eq_zero_iff, hS.closure_eq] at h
state_before: M : Type u_1
N : Type ?u.361198
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
hS : IsClosed ↑S
m : M
h : ‖↑(mk' S) m‖ = 0
⊢ m ∈ S
Theorem: Fintype.linearIndependent_iff'
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simp [Fintype.linearIndependent_iff, LinearMap.ker_eq_bot', funext_iff]
state_before: ι : Type u'
ι' : Type ?u.36281
R : Type u_1
K : Type ?u.36287
M : Type u_2
M' : Type ?u.36293
M'' : Type ?u.36296
V : Type u
V' : Type ?u.36301
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
inst✝ : Fintype ι
⊢ LinearIndependent R v ↔
    LinearMap.ker (↑(LinearMap.lsum R (fun x => R) ℕ) fun i => LinearMap.smulRight LinearMap.id (v i)) = ⊥
Theorem: iSup_sup
File: Mathlib/Order/CompleteLattice.lean

tactic: rw [iSup_sup_eq, iSup_const]
state_before: α : Type u_2
β : Type ?u.101691
β₂ : Type ?u.101694
γ : Type ?u.101697
ι : Sort u_1
ι' : Sort ?u.101703
κ : ι → Sort ?u.101708
κ' : ι' → Sort ?u.101713
inst✝¹ : CompleteLattice α
f✝ g s t : ι → α
a✝ b : α
inst✝ : Nonempty ι
f : ι → α
a : α
⊢ (⨆ (x : ι), f x) ⊔ a = ⨆ (x : ι), f x ⊔ a
Theorem: Subgroup.map_one_eq_bot
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rintro x ⟨y, _, rfl⟩
state_before: G : Type u_2
G' : Type ?u.252260
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.252269
inst✝² : AddGroup A
H K : Subgroup G
k : Set G
N : Type u_1
inst✝¹ : Group N
P : Type ?u.252296
inst✝ : Group P
⊢ map 1 K ≤ ⊥

tactic: simp
state_before: case intro.intro
G : Type u_2
G' : Type ?u.252260
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.252269
inst✝² : AddGroup A
H K : Subgroup G
k : Set G
N : Type u_1
inst✝¹ : Group N
P : Type ?u.252296
inst✝ : Group P
y : G
left✝ : y ∈ ↑K
⊢ ↑1 y ∈ ⊥
Theorem: UpperSet.Ici_iSup₂
File: Mathlib/Order/UpperLower/Basic.lean

tactic: simp_rw [Ici_iSup]
state_before: α : Type u_1
β : Type ?u.115994
γ : Type ?u.115997
ι : Sort u_2
κ : ι → Sort u_3
inst✝ : CompleteLattice α
f : (i : ι) → κ i → α
⊢ Ici (⨆ (i : ι) (j : κ i), f i j) = ⨆ (i : ι) (j : κ i), Ici (f i j)
Theorem: Ordnode.Sized.induction
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: induction t with
| nil => exact H0
| node _ _ _ _ t_ih_l t_ih_r =>
  rw [hl.eq_node']
  exact H1 _ _ _ (t_ih_l hl.2.1) (t_ih_r hl.2.2)
state_before: α : Type u_1
t : Ordnode α
hl : Sized t
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (Ordnode.node' l x r)
⊢ C t

tactic: exact H0
state_before: case nil
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (Ordnode.node' l x r)
hl : Sized nil
⊢ C nil

tactic: rw [hl.eq_node']
state_before: case node
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (Ordnode.node' l x r)
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
t_ih_l : Sized l✝ → C l✝
t_ih_r : Sized r✝ → C r✝
hl : Sized (node size✝ l✝ x✝ r✝)
⊢ C (node size✝ l✝ x✝ r✝)

tactic: exact H1 _ _ _ (t_ih_l hl.2.1) (t_ih_r hl.2.2)
state_before: case node
α : Type u_1
C : Ordnode α → Prop
H0 : C nil
H1 : ∀ (l : Ordnode α) (x : α) (r : Ordnode α), C l → C r → C (Ordnode.node' l x r)
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
t_ih_l : Sized l✝ → C l✝
t_ih_r : Sized r✝ → C r✝
hl : Sized (node size✝ l✝ x✝ r✝)
⊢ C (Ordnode.node' l✝ x✝ r✝)
Theorem: MeasureTheory.FiniteMeasure.coeFn_smul_apply
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

tactic: rw [coeFn_smul, Pi.smul_apply]
state_before: Ω : Type u_2
inst✝⁵ : MeasurableSpace Ω
R : Type u_1
inst✝⁴ : SMul R ℝ≥0
inst✝³ : SMul R ℝ≥0∞
inst✝² : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0 ℝ≥0
c : R
μ : FiniteMeasure Ω
s : Set Ω
⊢ (fun s => ENNReal.toNNReal (↑↑↑(c • μ) s)) s = c • (fun s => ENNReal.toNNReal (↑↑↑μ s)) s