1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: SimpleGraph.cliqueSet_map_of_equiv
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

tactic: obtain rfl | hn := eq_or_ne n 1
state_before: α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n✝ : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
n : ℕ
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet n = map e.toEmbedding '' G.cliqueSet n
state_after: case inl
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet 1 = map e.toEmbedding '' G.cliqueSet 1

case inr
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n✝ : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
n : ℕ
hn : n ≠ 1
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet n = map e.toEmbedding '' G.cliqueSet n

tactic: ext
state_before: case inl
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet 1 = map e.toEmbedding '' G.cliqueSet 1
state_after: case inl.h
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
x✝ : Finset β
⊢ x✝ ∈ (SimpleGraph.map e.toEmbedding G).cliqueSet 1 ↔ x✝ ∈ map e.toEmbedding '' G.cliqueSet 1

tactic: simp [e.exists_congr_left]
state_before: case inl.h
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
x✝ : Finset β
⊢ x✝ ∈ (SimpleGraph.map e.toEmbedding G).cliqueSet 1 ↔ x✝ ∈ map e.toEmbedding '' G.cliqueSet 1
state_after: no goals

tactic: exact cliqueSet_map hn _ _
state_before: case inr
α : Type u_1
β : Type u_2
G✝ H : SimpleGraph α
n✝ : ℕ
a b c : α
s : Finset α
G : SimpleGraph α
e : α ≃ β
n : ℕ
hn : n ≠ 1
⊢ (SimpleGraph.map e.toEmbedding G).cliqueSet n = map e.toEmbedding '' G.cliqueSet n
state_after: no goals
Theorem: MeasureTheory.prob_compl_le_one_sub_of_le_prob
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: simpa [prob_compl_eq_one_sub s_mble] using tsub_le_tsub_left hμs 1
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s t : Set α
inst✝ : IsProbabilityMeasure μ
p✝ : α → Prop
f : β → α
p : ℝ≥0∞
hμs : p ≤ μ s
s_mble : MeasurableSet s
⊢ μ sᶜ ≤ 1 - p
state_after: no goals
Theorem: CochainComplex.HomComplex.Cochain.shift_v'
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

tactic: omega
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
⊢ p + a + n = q + a
state_after: no goals

tactic: simp only [shift_v γ a p q hpq _ _ rfl rfl, shiftFunctor_obj_X, shiftFunctorObjXIso,
  HomologicalComplex.XIsoOfEq_rfl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
⊢ (γ.shift a).v p q hpq = γ.v (p + a) (q + a) ⋯
state_after: no goals
Theorem: TFAE_mem_nhdsWithin_Iio
File: Mathlib/Topology/Order/LeftRightNhds.lean

tactic: simpa only [exists_prop, OrderDual.exists, dual_Ioi, dual_Ioc, dual_Ioo] using
  TFAE_mem_nhdsWithin_Ioi h.dual (ofDual ⁻¹' s)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : TopologicalSpace α
inst✝¹ : LinearOrder α
inst✝ : OrderTopology α
a b : α
h : a < b
s : Set α
⊢ [s ∈ 𝓝[<] b, s ∈ 𝓝[Ico a b] b, s ∈ 𝓝[Ioo a b] b, ∃ l ∈ Ico a b, Ioo l b ⊆ s, ∃ l ∈ Iio b, Ioo l b ⊆ s].TFAE
state_after: no goals
Theorem: ValuationSubring.idealOfLE_le_of_le
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

tactic: by_contra c
state_before: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
⊢ R.valuation ↑((A.inclusion R hR) x) < 1
state_after: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : ¬R.valuation ↑((A.inclusion R hR) x) < 1
⊢ False

tactic: push_neg at c
state_before: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : ¬R.valuation ↑((A.inclusion R hR) x) < 1
⊢ False
state_after: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : 1 ≤ R.valuation ↑((A.inclusion R hR) x)
⊢ False

tactic: replace c := monotone_mapOfLE R S h c
state_before: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : 1 ≤ R.valuation ↑((A.inclusion R hR) x)
⊢ False
state_after: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : (R.mapOfLE S h) 1 ≤ (R.mapOfLE S h) (R.valuation ↑((A.inclusion R hR) x))
⊢ False

tactic: rw [(mapOfLE _ _ _).map_one, mapOfLE_valuation_apply] at c
state_before: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : (R.mapOfLE S h) 1 ≤ (R.mapOfLE S h) (R.valuation ↑((A.inclusion R hR) x))
⊢ False
state_after: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : 1 ≤ S.valuation ↑((A.inclusion R hR) x)
⊢ False

tactic: apply not_le_of_lt ((valuation_lt_one_iff S _).1 hx) c
state_before: K : Type u
inst✝ : Field K
A R S : ValuationSubring K
hR : A ≤ R
hS : A ≤ S
h : R ≤ S
x : ↥A
hx : x ∈ A.idealOfLE S hS
c : 1 ≤ S.valuation ↑((A.inclusion R hR) x)
⊢ False
state_after: no goals
Theorem: Batteries.RBNode.upperBound?_of_some
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t generalizing y <;> simp [upperBound?]
state_before: α : Type u_1
cut : α → Ordering
y : α
t : RBNode α
⊢ ∃ x, upperBound? cut t (some y) = some x
state_after: case node
α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : ∀ {y : α}, ∃ x, upperBound? cut l✝ (some y) = some x
r_ih✝ : ∀ {y : α}, ∃ x, upperBound? cut r✝ (some y) = some x
y : α
⊢ ∃ x,
    (match cut v✝ with
      | Ordering.lt => upperBound? cut l✝ (some v✝)
      | Ordering.gt => upperBound? cut r✝ (some y)
      | Ordering.eq => some v✝) =
      some x

tactic: split <;> simp [*]
state_before: case node
α : Type u_1
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : ∀ {y : α}, ∃ x, upperBound? cut l✝ (some y) = some x
r_ih✝ : ∀ {y : α}, ∃ x, upperBound? cut r✝ (some y) = some x
y : α
⊢ ∃ x,
    (match cut v✝ with
      | Ordering.lt => upperBound? cut l✝ (some v✝)
      | Ordering.gt => upperBound? cut r✝ (some y)
      | Ordering.eq => some v✝) =
      some x
state_after: no goals
Theorem: Ordinal.IsLimit.one_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: simpa only [succ_zero] using h.2 _ h.pos
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
h : o.IsLimit
⊢ 1 < o
state_after: no goals
Theorem: Nat.two_pow_mul_factorial_le_factorial_two_mul
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: obtain _ | n := n
state_before: n : ℕ
⊢ 2 ^ n * n ! ≤ (2 * n)!
state_after: case zero

⊢ 2 ^ 0 * 0! ≤ (2 * 0)!

case succ
n : ℕ
⊢ 2 ^ (n + 1) * (n + 1)! ≤ (2 * (n + 1))!

tactic: rw [Nat.mul_comm, Nat.two_mul]
state_before: case succ
n : ℕ
⊢ 2 ^ (n + 1) * (n + 1)! ≤ (2 * (n + 1))!
state_after: case succ
n : ℕ
⊢ (n + 1)! * 2 ^ (n + 1) ≤ (n + 1 + (n + 1))!

tactic: calc
  _ ≤ (n + 1)! * (n + 2) ^ (n + 1) :=
    Nat.mul_le_mul_left _ (pow_le_pow_of_le_left (le_add_left _ _) _)
  _ ≤ _ := Nat.factorial_mul_pow_le_factorial
state_before: case succ
n : ℕ
⊢ (n + 1)! * 2 ^ (n + 1) ≤ (n + 1 + (n + 1))!
state_after: no goals

tactic: simp
state_before: case zero

⊢ 2 ^ 0 * 0! ≤ (2 * 0)!
state_after: no goals
Theorem: contDiff_succ_iff_deriv
File: Mathlib/Analysis/Calculus/ContDiff/Basic.lean

tactic: simp only [← contDiffOn_univ, contDiffOn_succ_iff_deriv_of_isOpen, isOpen_univ,
  differentiableOn_univ]
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
D : Type uD
inst✝⁹ : NormedAddCommGroup D
inst✝⁸ : NormedSpace 𝕜 D
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type u_2
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
b : E × F → G
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
f₂ : 𝕜 → F
s₂ : Set 𝕜
n : ℕ
⊢ ContDiff 𝕜 (↑(n + 1)) f₂ ↔ Differentiable 𝕜 f₂ ∧ ContDiff 𝕜 (↑n) (deriv f₂)
state_after: no goals
Theorem: ZMod.eisenstein_lemma_aux₁
File: Mathlib/NumberTheory/LegendreSymbol/GaussEisensteinLemmas.lean

tactic: simp only [mod_add_div]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, a * x) = ↑(∑ x ∈ Ico 1 (p / 2).succ, (a * x % p + p * (a * x / p)))
state_after: no goals

tactic: simp only [val_natCast]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, (a * x % p + p * (a * x / p))) =
    ↑(∑ x ∈ Ico 1 (p / 2).succ, (↑(a * x)).val) + ↑(∑ x ∈ Ico 1 (p / 2).succ, a * x / p)
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, (a * x % p + p * (a * x / p))) =
    ↑(∑ x ∈ Ico 1 (p / 2).succ, a * x % p) + ↑(∑ x ∈ Ico 1 (p / 2).succ, a * x / p)

tactic: simp [sum_add_distrib, ← mul_sum, Nat.cast_add, Nat.cast_mul, Nat.cast_sum, hp2]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, (a * x % p + p * (a * x / p))) =
    ↑(∑ x ∈ Ico 1 (p / 2).succ, a * x % p) + ↑(∑ x ∈ Ico 1 (p / 2).succ, a * x / p)
state_after: no goals

tactic: simp only [(val_eq_ite_valMinAbs _).symm]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, (↑(a * x)).val) =
    ∑ x ∈ Ico 1 (p / 2).succ, ↑((↑a * ↑x).valMinAbs + ↑(if (↑a * ↑x).val ≤ p / 2 then 0 else p))
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, (↑(a * x)).val) = ∑ x ∈ Ico 1 (p / 2).succ, ↑↑(↑a * ↑x).val

tactic: simp [Nat.cast_sum]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(∑ x ∈ Ico 1 (p / 2).succ, (↑(a * x)).val) = ∑ x ∈ Ico 1 (p / 2).succ, ↑↑(↑a * ↑x).val
state_after: no goals

tactic: simp [add_comm, sum_add_distrib, Finset.sum_ite, hp2, Nat.cast_sum]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ∑ x ∈ Ico 1 (p / 2).succ, ↑((↑a * ↑x).valMinAbs + ↑(if (↑a * ↑x).val ≤ p / 2 then 0 else p)) =
    ↑(filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card +
      ↑(∑ x ∈ Ico 1 (p / 2).succ, (↑a * ↑x).valMinAbs.natAbs)
state_after: no goals

tactic: rw [Finset.sum_eq_multiset_sum, Ico_map_valMinAbs_natAbs_eq_Ico_map_id p a hap, ←
  Finset.sum_eq_multiset_sum]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
hp2✝ : Fact (p % 2 = 1)
a : ℕ
hap : ↑a ≠ 0
hp2 : ↑p = ↑1
⊢ ↑(filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card +
      ↑(∑ x ∈ Ico 1 (p / 2).succ, (↑a * ↑x).valMinAbs.natAbs) =
    ↑(filter (fun x => p / 2 < (↑a * ↑x).val) (Ico 1 (p / 2).succ)).card + ↑(∑ x ∈ Ico 1 (p / 2).succ, x)
state_after: no goals
Theorem: Equiv.Perm.disjoint_inv_left_iff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: refine ⟨fun h => ?_, Disjoint.inv_left⟩
state_before: α : Type u_1
f g h : Perm α
⊢ f⁻¹.Disjoint g ↔ f.Disjoint g
state_after: α : Type u_1
f g h✝ : Perm α
h : f⁻¹.Disjoint g
⊢ f.Disjoint g

tactic: convert h.inv_left
state_before: α : Type u_1
f g h✝ : Perm α
h : f⁻¹.Disjoint g
⊢ f.Disjoint g
state_after: no goals
Theorem: DMatrix.map_map
File: Mathlib/Data/Matrix/DMatrix.lean

tactic: ext
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
M : DMatrix m n α
β : m → n → Type w
γ : m → n → Type z
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j
g : ⦃i : m⦄ → ⦃j : n⦄ → β i j → γ i j
⊢ (M.map f).map g = M.map fun i j x => g (f x)
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
M : DMatrix m n α
β : m → n → Type w
γ : m → n → Type z
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j
g : ⦃i : m⦄ → ⦃j : n⦄ → β i j → γ i j
i✝ : m
j✝ : n
⊢ (M.map f).map g i✝ j✝ = M.map (fun i j x => g (f x)) i✝ j✝

tactic: simp
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
α : m → n → Type v
M : DMatrix m n α
β : m → n → Type w
γ : m → n → Type z
f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j
g : ⦃i : m⦄ → ⦃j : n⦄ → β i j → γ i j
i✝ : m
j✝ : n
⊢ (M.map f).map g i✝ j✝ = M.map (fun i j x => g (f x)) i✝ j✝
state_after: no goals
Theorem: MeasureTheory.lintegral_norm_eq_lintegral_edist
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp only [ofReal_norm_eq_coe_nnnorm, edist_eq_coe_nnnorm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
⊢ ∫⁻ (a : α), ENNReal.ofReal ‖f a‖ ∂μ = ∫⁻ (a : α), edist (f a) 0 ∂μ
state_after: no goals
Theorem: tendsto_atBot_isLUB
File: Mathlib/Topology/Order/MonotoneConvergence.lean

tactic: convert tendsto_atTop_isLUB h_anti.dual_left ha using 1
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
ha : IsLUB (range f) a
⊢ Tendsto f atBot (𝓝 a)
state_after: no goals
Theorem: Cube.insertAt_boundary
File: Mathlib/Topology/Homotopy/HomotopyGroup.lean

tactic: obtain H | ⟨j, H⟩ := H
state_before: N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : (t₀ = 0 ∨ t₀ = 1) ∨ t ∈ boundary { j // j ≠ i }
⊢ (insertAt i) (t₀, t) ∈ boundary N
state_after: case inl
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : t₀ = 0 ∨ t₀ = 1
⊢ (insertAt i) (t₀, t) ∈ boundary N

case inr.intro
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
j : { j // j ≠ i }
H : t j = 0 ∨ t j = 1
⊢ (insertAt i) (t₀, t) ∈ boundary N

tactic: use i
state_before: case inl
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : t₀ = 0 ∨ t₀ = 1
⊢ (insertAt i) (t₀, t) ∈ boundary N
state_after: case h
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : t₀ = 0 ∨ t₀ = 1
⊢ (insertAt i) (t₀, t) i = 0 ∨ (insertAt i) (t₀, t) i = 1

tactic: rwa [funSplitAt_symm_apply, dif_pos rfl]
state_before: case h
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
H : t₀ = 0 ∨ t₀ = 1
⊢ (insertAt i) (t₀, t) i = 0 ∨ (insertAt i) (t₀, t) i = 1
state_after: no goals

tactic: use j
state_before: case inr.intro
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
j : { j // j ≠ i }
H : t j = 0 ∨ t j = 1
⊢ (insertAt i) (t₀, t) ∈ boundary N
state_after: case h
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
j : { j // j ≠ i }
H : t j = 0 ∨ t j = 1
⊢ (insertAt i) (t₀, t) ↑j = 0 ∨ (insertAt i) (t₀, t) ↑j = 1

tactic: rwa [funSplitAt_symm_apply, dif_neg j.prop, Subtype.coe_eta]
state_before: case h
N : Type u_1
inst✝ : DecidableEq N
i : N
t₀ : ↑I
t : { j // j ≠ i } → ↑I
j : { j // j ≠ i }
H : t j = 0 ∨ t j = 1
⊢ (insertAt i) (t₀, t) ↑j = 0 ∨ (insertAt i) (t₀, t) ↑j = 1
state_after: no goals
Theorem: Matrix.det_eq_of_eq_det_one_mul
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

tactic: rw [hC, one_mul]
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A B C : Matrix n n R
hC : C.det = 1
hA : A = C * B
⊢ C.det * B.det = B.det
state_after: no goals
Theorem: Nat.sum_zeckendorf_fib
File: Mathlib/Data/Nat/Fib/Zeckendorf.lean

tactic: induction n using zeckendorf.induct <;> simp_all [fib_greatestFib_le]
state_before: l : List ℕ
a m n✝ n : ℕ
⊢ (map fib n.zeckendorf).sum = n
state_after: no goals
Theorem: Subalgebra.mul_toSubmodule_le
File: Mathlib/Algebra/Algebra/Subalgebra/Pointwise.lean

tactic: rw [Submodule.mul_le]
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
⊢ toSubmodule S * toSubmodule T ≤ toSubmodule (S ⊔ T)
state_after: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
⊢ ∀ m ∈ toSubmodule S, ∀ n ∈ toSubmodule T, m * n ∈ toSubmodule (S ⊔ T)

tactic: intro y hy z hz
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
⊢ ∀ m ∈ toSubmodule S, ∀ n ∈ toSubmodule T, m * n ∈ toSubmodule (S ⊔ T)
state_after: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
y : A
hy : y ∈ toSubmodule S
z : A
hz : z ∈ toSubmodule T
⊢ y * z ∈ toSubmodule (S ⊔ T)

tactic: show y * z ∈ S ⊔ T
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
y : A
hy : y ∈ toSubmodule S
z : A
hz : z ∈ toSubmodule T
⊢ y * z ∈ toSubmodule (S ⊔ T)
state_after: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
y : A
hy : y ∈ toSubmodule S
z : A
hz : z ∈ toSubmodule T
⊢ y * z ∈ S ⊔ T

tactic: exact mul_mem (Algebra.mem_sup_left hy) (Algebra.mem_sup_right hz)
state_before: R : Type u_1
A : Type u_2
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Subalgebra R A
y : A
hy : y ∈ toSubmodule S
z : A
hz : z ∈ toSubmodule T
⊢ y * z ∈ S ⊔ T
state_after: no goals
Theorem: Multiset.measurable_prod
File: Mathlib/MeasureTheory/Group/Arithmetic.lean

tactic: simpa only [← Pi.multiset_prod_apply] using s.measurable_prod' hs
state_before: α✝ : Type u_1
M : Type u_2
ι : Type u_3
α : Type u_4
inst✝² : CommMonoid M
inst✝¹ : MeasurableSpace M
inst✝ : MeasurableMul₂ M
m : MeasurableSpace α
μ : Measure α
f : ι → α → M
s : Multiset (α → M)
hs : ∀ f ∈ s, Measurable f
⊢ Measurable fun x => (map (fun f => f x) s).prod
state_after: no goals
Theorem: reflection_map_apply
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: simp [two_smul, reflection_apply, orthogonalProjection_map_apply f K x]
state_before: 𝕜 : Type u_1
E✝ : Type u_2
F : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
inst✝⁹ : NormedAddCommGroup E✝
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : InnerProductSpace 𝕜 E✝
inst✝⁶ : InnerProductSpace ℝ F
K✝ : Submodule 𝕜 E✝
inst✝⁵ : HasOrthogonalProjection K✝
E : Type u_4
E' : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup E'
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace 𝕜 E'
f : E ≃ₗᵢ[𝕜] E'
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
x : E'
⊢ (reflection (Submodule.map (↑f.toLinearEquiv) K)) x = f ((reflection K) (f.symm x))
state_after: no goals
Theorem: padicValRat.multiplicity_sub_multiplicity
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: rw [← finite_iff_dom, finite_nat_iff]
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ (multiplicity p q.den).Dom
state_after: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den

tactic: exact ⟨hp, q.pos⟩
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den
state_after: no goals

tactic: rw [padicValRat, padicValInt.of_ne_one_ne_zero hp, padicValNat, dif_pos]
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ padicValRat p q = ↑((multiplicity (↑p) q.num).get ⋯) - ↑((multiplicity p q.den).get ⋯)
state_after: case hc
p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den

p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ q.num ≠ 0

tactic: exact ⟨hp, q.pos⟩
state_before: case hc
p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ p ≠ 1 ∧ 0 < q.den
state_after: no goals

tactic: exact Rat.num_ne_zero.2 hq
state_before: p : ℕ
q : ℚ
hp : p ≠ 1
hq : q ≠ 0
⊢ q.num ≠ 0
state_after: no goals
Theorem: Asymptotics.IsEquivalent.tendsto_const
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

tactic: rcases em <| c = 0 with rfl | h
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
⊢ Tendsto u l (𝓝 c)
state_after: case inl
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
hu : u ~[l] const α 0
⊢ Tendsto u l (𝓝 0)

case inr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
h : ¬c = 0
⊢ Tendsto u l (𝓝 c)

tactic: exact (tendsto_congr' <| isEquivalent_zero_iff_eventually_zero.mp hu).mpr tendsto_const_nhds
state_before: case inl
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
hu : u ~[l] const α 0
⊢ Tendsto u l (𝓝 0)
state_after: no goals

tactic: exact (isEquivalent_const_iff_tendsto h).mp hu
state_before: case inr
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
c : β
hu : u ~[l] const α c
h : ¬c = 0
⊢ Tendsto u l (𝓝 c)
state_after: no goals
Theorem: MeasureTheory.JordanDecomposition.toSignedMeasure_smul
File: Mathlib/MeasureTheory/Decomposition/Jordan.lean

tactic: ext1 i hi
state_before: α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ≥0
⊢ (r • j).toSignedMeasure = r • j.toSignedMeasure
state_after: case h
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ≥0
i : Set α
hi : MeasurableSet i
⊢ ↑(r • j).toSignedMeasure i = ↑(r • j.toSignedMeasure) i

tactic: rw [VectorMeasure.smul_apply, toSignedMeasure, toSignedMeasure,
  toSignedMeasure_sub_apply hi, toSignedMeasure_sub_apply hi, smul_sub, smul_posPart,
  smul_negPart, ← ENNReal.toReal_smul, ← ENNReal.toReal_smul, Measure.smul_apply,
  Measure.smul_apply]
state_before: case h
α : Type u_1
β : Type u_2
inst✝ : MeasurableSpace α
j : JordanDecomposition α
r : ℝ≥0
i : Set α
hi : MeasurableSet i
⊢ ↑(r • j).toSignedMeasure i = ↑(r • j.toSignedMeasure) i
state_after: no goals
Theorem: PMF.restrict_toMeasure_support
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

tactic: ext s hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : MeasurableSpace α
p✝ : PMF α
s t : Set α
inst✝ : MeasurableSingletonClass α
p : PMF α
⊢ p.toMeasure.restrict p.support = p.toMeasure
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : MeasurableSpace α
p✝ : PMF α
s✝ t : Set α
inst✝ : MeasurableSingletonClass α
p : PMF α
s : Set α
hs : MeasurableSet s
⊢ (p.toMeasure.restrict p.support) s = p.toMeasure s

tactic: apply (MeasureTheory.Measure.restrict_apply hs).trans
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : MeasurableSpace α
p✝ : PMF α
s✝ t : Set α
inst✝ : MeasurableSingletonClass α
p : PMF α
s : Set α
hs : MeasurableSet s
⊢ (p.toMeasure.restrict p.support) s = p.toMeasure s
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : MeasurableSpace α
p✝ : PMF α
s✝ t : Set α
inst✝ : MeasurableSingletonClass α
p : PMF α
s : Set α
hs : MeasurableSet s
⊢ p.toMeasure (s ∩ p.support) = p.toMeasure s

tactic: apply toMeasure_apply_inter_support p s hs p.support_countable.measurableSet
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : MeasurableSpace α
p✝ : PMF α
s✝ t : Set α
inst✝ : MeasurableSingletonClass α
p : PMF α
s : Set α
hs : MeasurableSet s
⊢ p.toMeasure (s ∩ p.support) = p.toMeasure s
state_after: no goals
Theorem: padicNormE.eq_of_norm_add_lt_right
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [padicNormE.add_eq_max_of_ne hne]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ ‖z1 + z2‖ ≥ ‖z2‖
state_after: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z2‖

tactic: apply le_max_right
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z1 z2 : ℚ_[p]
h : ‖z1 + z2‖ < ‖z2‖
hne : ¬‖z1‖ = ‖z2‖
⊢ max ‖z1‖ ‖z2‖ ≥ ‖z2‖
state_after: no goals