tasksource/leandojo huggingface dataset:
Theorem: List.enumFrom_append
File: Mathlib/Data/List/Basic.lean

tactic: induction' xs with x xs IH generalizing ys n
state_before: ι : Type ?u.448212
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ xs ys : List α
n : ℕ
⊢ enumFrom n (xs ++ ys) = enumFrom n xs ++ enumFrom (n + length xs) ys

tactic: simp
state_before: case nil
ι : Type ?u.448212
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ ys✝ : List α
n✝ : ℕ
ys : List α
n : ℕ
⊢ enumFrom n ([] ++ ys) = enumFrom n [] ++ enumFrom (n + length []) ys

tactic: rw [cons_append, enumFrom_cons, IH, ← cons_append, ← enumFrom_cons, length, add_right_comm,
  add_assoc]
state_before: case cons
ι : Type ?u.448212
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ ys✝ : List α
n✝ : ℕ
x : α
xs : List α
IH : ∀ (ys : List α) (n : ℕ), enumFrom n (xs ++ ys) = enumFrom n xs ++ enumFrom (n + length xs) ys
ys : List α
n : ℕ
⊢ enumFrom n (x :: xs ++ ys) = enumFrom n (x :: xs) ++ enumFrom (n + length (x :: xs)) ys
Theorem: Path.delayReflLeft_zero
File: Mathlib/Topology/Homotopy/HSpaces.lean

tactic: simp only [delayReflLeft, delayReflRight_zero, trans_symm, refl_symm, Path.symm_symm]
state_before: X : Type u
inst✝ : TopologicalSpace X
x y : X
γ : Path x y
⊢ delayReflLeft 0 γ = trans (refl x) γ
Theorem: isPreconnected_of_forall_pair
File: Mathlib/Topology/Connected.lean

tactic: rcases eq_empty_or_nonempty s with (rfl | ⟨x, hx⟩)
state_before: α : Type u
β : Type v
ι : Type ?u.2516
π : ι → Type ?u.2521
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
H : ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → ∃ t, t ⊆ s ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t
⊢ IsPreconnected s

tactic: exacts [isPreconnected_empty, isPreconnected_of_forall x fun y => H x hx y]
state_before: case inl
α : Type u
β : Type v
ι : Type ?u.2516
π : ι → Type ?u.2521
inst✝ : TopologicalSpace α
s t u v : Set α
H : ∀ (x : α), x ∈ ∅ → ∀ (y : α), y ∈ ∅ → ∃ t, t ⊆ ∅ ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t
⊢ IsPreconnected ∅

case inr.intro
α : Type u
β : Type v
ι : Type ?u.2516
π : ι → Type ?u.2521
inst✝ : TopologicalSpace α
s✝ t u v s : Set α
H : ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → ∃ t, t ⊆ s ∧ x ∈ t ∧ y ∈ t ∧ IsPreconnected t
x : α
hx : x ∈ s
⊢ IsPreconnected s
Theorem: inv_lt_inv_iff
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a⁻¹ < b⁻¹ ↔ b < a

tactic: simp
state_before: α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ a * a⁻¹ * b < a * b⁻¹ * b ↔ b < a
Theorem: Matrix.Fin.circulant_mul_comm
File: Mathlib/LinearAlgebra/Matrix/Circulant.lean

tactic: simp [Injective]
state_before: α : Type u_1
β : Type ?u.36269
m : Type ?u.36272
n : Type ?u.36275
R : Type ?u.36278
inst✝¹ : CommSemigroup α
inst✝ : AddCommMonoid α
⊢ ∀ (v w : Fin 0 → α), circulant v ⬝ circulant w = circulant w ⬝ circulant v
Theorem: IsRingHom.map_sub
File: Mathlib/Deprecated/Ring.lean

tactic: simp [sub_eq_add_neg, hf.map_add, hf.map_neg]
state_before: α : Type u
β : Type v
inst✝¹ : Ring α
inst✝ : Ring β
f : α → β
hf✝ : IsRingHom f
x y : α
hf : IsRingHom f
⊢ f (x - y) = f x - f y
Theorem: Finset.pow_eq_prod_const
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: simp
state_before: ι : Type ?u.662711
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
b : β
⊢ ∀ (n : ℕ), b ^ n = ∏ _k in range n, b
Theorem: Function.IsPeriodicPt.right_of_add
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [add_comm] at hn
state_before: α : Type u_1
β : Type ?u.1334
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f (n + m) x
hm : IsPeriodicPt f n x
⊢ IsPeriodicPt f m x

tactic: exact hn.left_of_add hm
state_before: α : Type u_1
β : Type ?u.1334
f fa : α → α
fb : β → β
x y : α
m n : ℕ
hn : IsPeriodicPt f (m + n) x
hm : IsPeriodicPt f n x
⊢ IsPeriodicPt f m x
Theorem: Cycle.mem_map
File: Mathlib/Data/List/Cycle.lean

tactic: simp
state_before: α : Type u_2
β : Type u_1
f : α → β
b : β
s : Cycle α
⊢ ∀ (a : List α), b ∈ map f (Quotient.mk'' a) ↔ ∃ a_1, a_1 ∈ Quotient.mk'' a ∧ f a_1 = b
Theorem: lt_mul_of_lt_one_right
File: Mathlib/Algebra/Order/Ring/Defs.lean

tactic: simpa only [mul_one] using mul_lt_mul_of_neg_left h ha
state_before: α : Type u
β : Type ?u.88483
inst✝ : StrictOrderedRing α
a b c : α
ha : a < 0
h : b < 1
⊢ a < a * b
Theorem: EuclideanDomain.div_self
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: simpa only [one_mul] using mul_div_cancel 1 a0
state_before: R : Type u
inst✝ : EuclideanDomain R
a : R
a0 : a ≠ 0
⊢ a / a = 1
Theorem: List.mem_of_formPerm_ne_self
File: Mathlib/GroupTheory/Perm/List.lean

tactic: suffices x ∈ { y | formPerm l y ≠ y } by
  rw [← mem_toFinset]
  exact support_formPerm_le' _ this
state_before: α : Type u_1
β : Type ?u.815968
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
h : ↑(formPerm l) x ≠ x
⊢ x ∈ l

tactic: simpa using h
state_before: α : Type u_1
β : Type ?u.815968
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
h : ↑(formPerm l) x ≠ x
⊢ x ∈ {y | ↑(formPerm l) y ≠ y}

tactic: rw [← mem_toFinset]
state_before: α : Type u_1
β : Type ?u.815968
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
h : ↑(formPerm l) x ≠ x
this : x ∈ {y | ↑(formPerm l) y ≠ y}
⊢ x ∈ l

tactic: exact support_formPerm_le' _ this
state_before: α : Type u_1
β : Type ?u.815968
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l : List α
x : α
h : ↑(formPerm l) x ≠ x
this : x ∈ {y | ↑(formPerm l) y ≠ y}
⊢ x ∈ toFinset l
Theorem: Filter.isCobounded_bot
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsCobounded]
state_before: α : Type u_1
β : Type ?u.17744
γ : Type ?u.17747
ι : Type ?u.17750
r : α → α → Prop
f g : Filter α
⊢ IsCobounded r ⊥ ↔ ∃ b, ∀ (x : α), r b x
Theorem: LinearMap.ker_comp_of_ker_eq_bot
File: Mathlib/LinearAlgebra/Basic.lean

tactic: rw [ker_comp, hg, Submodule.comap_bot]
state_before: R : Type u_1
R₁ : Type ?u.1582116
R₂ : Type u_2
R₃ : Type u_5
R₄ : Type ?u.1582125
S : Type ?u.1582128
K : Type ?u.1582131
K₂ : Type ?u.1582134
M : Type u_3
M' : Type ?u.1582140
M₁ : Type ?u.1582143
M₂ : Type u_4
M₃ : Type u_6
M₄ : Type ?u.1582152
N : Type ?u.1582155
N₂ : Type ?u.1582158
ι : Type ?u.1582161
V : Type ?u.1582164
V₂ : Type ?u.1582167
inst✝⁹ : Semiring R
inst✝⁸ : Semiring R₂
inst✝⁷ : Semiring R₃
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : AddCommMonoid M₃
inst✝³ : Module R M
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
τ₁₂ : R →+* R₂
τ₂₃ : R₂ →+* R₃
τ₁₃ : R →+* R₃
inst✝ : RingHomCompTriple τ₁₂ τ₂₃ τ₁₃
f : M →ₛₗ[τ₁₂] M₂
g : M₂ →ₛₗ[τ₂₃] M₃
hg : ker g = ⊥
⊢ ker (comp g f) = ker f
Theorem: Multiset.mem_product
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [product, and_left_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.62033
δ : Type ?u.62036
a✝ : α
b✝ : β
s✝ : Multiset α
t✝ : Multiset β
s : Multiset α
t : Multiset β
a : α
b : β
⊢ (a, b) ∈ product s t ↔ (a, b).fst ∈ s ∧ (a, b).snd ∈ t
Theorem: Subgroup.pi_top
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp [mem_pi]
state_before: G : Type ?u.316307
G' : Type ?u.316310
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.316319
inst✝³ : AddGroup A
H K : Subgroup G
k : Set G
N : Type ?u.316340
inst✝² : Group N
P : Type ?u.316346
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
x : (i : η) → f i
⊢ (x ∈ pi I fun i => ⊤) ↔ x ∈ ⊤
Theorem: InnerProductSpace.Core.inner_add_add_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: simp only [inner_add_left, inner_add_right]
state_before: 𝕜 : Type u_1
E : Type ?u.639791
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ inner (x + y) (x + y) = inner x x + inner x y + inner y x + inner y y

tactic: ring
state_before: 𝕜 : Type u_1
E : Type ?u.639791
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
⊢ inner x x + inner y x + (inner x y + inner y y) = inner x x + inner x y + inner y x + inner y y
Theorem: EReal.sign_mul_abs
File: Mathlib/Data/Real/EReal.lean

tactic: simp
state_before: ⊢ ↑(↑sign ⊥) * ↑(EReal.abs ⊥) = ⊥

tactic: simp
state_before: ⊢ ↑(↑sign ⊤) * ↑(EReal.abs ⊤) = ⊤

tactic: rw [sign_coe, coe_abs, ← coe_coe_sign, ← coe_mul, sign_mul_abs]
state_before: x : ℝ
⊢ ↑(↑sign ↑x) * ↑(EReal.abs ↑x) = ↑x
Theorem: CategoryTheory.Limits.spanExt_inv_app_left
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: dsimp [spanExt]
state_before: C : Type u
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Y
g : X ⟶ Z
f' : X' ⟶ Y'
g' : X' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iY.hom
wg : iX.hom ≫ g' = g ≫ iZ.hom
⊢ (spanExt iX iY iZ wf wg).inv.app WalkingSpan.left = iY.inv
Theorem: Rat.zero_mkRat
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mkRat_def]
state_before: n : Nat
⊢ mkRat 0 n = 0

tactic: apply ite_self
state_before: n : Nat
⊢ (if h : n = 0 then 0 else 0) = 0
Theorem: Polynomial.opRingEquiv_symm_C_mul_X_pow
File: Mathlib/RingTheory/Polynomial/Opposites.lean

tactic: rw [C_mul_X_pow_eq_monomial, opRingEquiv_symm_monomial, C_mul_X_pow_eq_monomial]
state_before: R : Type u_1
inst✝ : Semiring R
r : Rᵐᵒᵖ
n : ℕ
⊢ ↑(RingEquiv.symm (opRingEquiv R)) (↑C r * X ^ n) = op (↑C (unop r) * X ^ n)
Theorem: List.mapM_append
File: Std/Data/List/Init/Lemmas.lean

tactic: induction l₁ <;> simp [*]
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → m β
l₁ l₂ : List α
⊢ mapM f (l₁ ++ l₂) = do
    let __do_lift ← mapM f l₁
    let __do_lift_1 ← mapM f l₂
    pure (__do_lift ++ __do_lift_1)
Theorem: SimpleGraph.Walk.IsEulerian.even_degree_iff
File: Mathlib/Combinatorics/SimpleGraph/Trails.lean

tactic: convert ht.isTrail.even_countp_edges_iff x
state_before: V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ Even (degree G x) ↔ u ≠ v → x ≠ u ∧ x ≠ v

tactic: rw [← Multiset.coe_countp, Multiset.countp_eq_card_filter, ← card_incidenceFinset_eq_degree]
state_before: case h.e'_1.h.e'_3
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ degree G x = List.countp (fun e => decide (x ∈ e)) (edges p)

tactic: change Multiset.card _ = _
state_before: case h.e'_1.h.e'_3
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ Finset.card (incidenceFinset G x) = ↑Multiset.card (Multiset.filter (fun e => x ∈ e) ↑(edges p))

tactic: congr 1
state_before: case h.e'_1.h.e'_3
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ ↑Multiset.card (incidenceFinset G x).val = ↑Multiset.card (Multiset.filter (fun e => x ∈ e) ↑(edges p))

tactic: convert_to _ = (ht.isTrail.edgesFinset.filter (Membership.mem x)).val
state_before: case h.e'_1.h.e'_3.h.e_6.h
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ (incidenceFinset G x).val = Multiset.filter (fun e => x ∈ e) ↑(edges p)

tactic: have : Fintype G.edgeSet := fintypeEdgeSet ht
state_before: case h.e'_1.h.e'_3.h.e_6.h
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
⊢ (incidenceFinset G x).val = (Finset.filter (Membership.mem x) (IsTrail.edgesFinset (_ : IsTrail p))).val

tactic: rw [ht.edgesFinset_eq, G.incidenceFinset_eq_filter x]
state_before: case h.e'_1.h.e'_3.h.e_6.h
V : Type u_1
G : SimpleGraph V
inst✝² : DecidableEq V
x u v : V
p : Walk G u v
ht : IsEulerian p
inst✝¹ : Fintype V
inst✝ : DecidableRel G.Adj
this : Fintype ↑(edgeSet G)
⊢ (incidenceFinset G x).val = (Finset.filter (Membership.mem x) (IsTrail.edgesFinset (_ : IsTrail p))).val
Theorem: principal_subtype
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [comap_principal, preimage_image_eq _ Subtype.coe_injective]
state_before: α✝ : Type ?u.190164
β : Type ?u.190167
γ : Type ?u.190170
δ : Type ?u.190173
inst✝ : TopologicalSpace α✝
α : Type u_1
s : Set α
t : Set ↑s
⊢ 𝓟 t = comap Subtype.val (𝓟 (Subtype.val '' t))
Theorem: isCoprime_of_irreducible_dvd
File: Mathlib/RingTheory/PrincipalIdealDomain.lean

tactic: apply isCoprime_of_dvd x y nonzero
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
x y : R
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : R), Irreducible z → z ∣ x → ¬z ∣ y
⊢ IsCoprime x y

tactic: intro z znu znz zx zy
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
x y : R
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : R), Irreducible z → z ∣ x → ¬z ∣ y
⊢ ∀ (z : R), z ∈ nonunits R → z ≠ 0 → z ∣ x → ¬z ∣ y

tactic: obtain ⟨i, h1, h2⟩ := WfDvdMonoid.exists_irreducible_factor znu znz
state_before: R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
x y : R
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : R), Irreducible z → z ∣ x → ¬z ∣ y
z : R
znu : z ∈ nonunits R
znz : z ≠ 0
zx : z ∣ x
zy : z ∣ y
⊢ False

tactic: apply dvd_trans h2
state_before: case intro.intro.a
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
x y : R
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : R), Irreducible z → z ∣ x → ¬z ∣ y
z : R
znu : z ∈ nonunits R
znz : z ≠ 0
zx : z ∣ x
zy : z ∣ y
i : R
h1 : Irreducible i
h2 : i ∣ z
⊢ i ∣ y

tactic: assumption
state_before: case intro.intro.a
R : Type u
M : Type v
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : IsPrincipalIdealRing R
inst✝ : GCDMonoid R
x y : R
nonzero : ¬(x = 0 ∧ y = 0)
H : ∀ (z : R), Irreducible z → z ∣ x → ¬z ∣ y
z : R
znu : z ∈ nonunits R
znz : z ≠ 0
zx : z ∣ x
zy : z ∣ y
i : R
h1 : Irreducible i
h2 : i ∣ z
⊢ z ∣ y
Theorem: ProbabilityTheory.condCount_add_compl_eq
File: Mathlib/Probability/CondCount.lean

tactic: have : condCount s t = (condCount (s ∩ u) t * condCount (s ∩ u ∪ s ∩ uᶜ) (s ∩ u) +
    condCount (s ∩ uᶜ) t * condCount (s ∩ u ∪ s ∩ uᶜ) (s ∩ uᶜ)) := by
  rw [condCount_disjoint_union (hs.inter_of_left _) (hs.inter_of_left _)
    (disjoint_compl_right.mono inf_le_right inf_le_right), Set.inter_union_compl]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t✝ u✝ u t : Set Ω
hs : Set.Finite s
⊢ ↑↑(condCount (s ∩ u)) t * ↑↑(condCount s) u + ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount s) (uᶜ) = ↑↑(condCount s) t

tactic: rw [this]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t✝ u✝ u t : Set Ω
hs : Set.Finite s
this :
  ↑↑(condCount s) t =
    ↑↑(condCount (s ∩ u)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ u) +
      ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ uᶜ)
⊢ ↑↑(condCount (s ∩ u)) t * ↑↑(condCount s) u + ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount s) (uᶜ) = ↑↑(condCount s) t

tactic: simp [condCount_inter_self hs]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t✝ u✝ u t : Set Ω
hs : Set.Finite s
this :
  ↑↑(condCount s) t =
    ↑↑(condCount (s ∩ u)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ u) +
      ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ uᶜ)
⊢ ↑↑(condCount (s ∩ u)) t * ↑↑(condCount s) u + ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount s) (uᶜ) =
    ↑↑(condCount (s ∩ u)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ u) +
      ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ uᶜ)

tactic: rw [condCount_disjoint_union (hs.inter_of_left _) (hs.inter_of_left _)
  (disjoint_compl_right.mono inf_le_right inf_le_right), Set.inter_union_compl]
state_before: Ω : Type u_1
inst✝¹ : MeasurableSpace Ω
inst✝ : MeasurableSingletonClass Ω
s t✝ u✝ u t : Set Ω
hs : Set.Finite s
⊢ ↑↑(condCount s) t =
    ↑↑(condCount (s ∩ u)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ u) +
      ↑↑(condCount (s ∩ uᶜ)) t * ↑↑(condCount (s ∩ u ∪ s ∩ uᶜ)) (s ∩ uᶜ)
Theorem: Ordinal.add_mul_succ
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: apply limitRecOn c
state_before: a b c : Ordinal
ba : b + a = a
⊢ (a + b) * succ c = a * succ c + b

tactic: simp only [succ_zero, mul_one]
state_before: case H₁
a b c : Ordinal
ba : b + a = a
⊢ (a + b) * succ 0 = a * succ 0 + b

tactic: intro c IH
state_before: case H₂
a b c : Ordinal
ba : b + a = a
⊢ ∀ (o : Ordinal), (a + b) * succ o = a * succ o + b → (a + b) * succ (succ o) = a * succ (succ o) + b

tactic: rw [mul_succ, IH, ← add_assoc, add_assoc _ b, ba, ← mul_succ]
state_before: case H₂
a b c✝ : Ordinal
ba : b + a = a
c : Ordinal
IH : (a + b) * succ c = a * succ c + b
⊢ (a + b) * succ (succ c) = a * succ (succ c) + b

tactic: intro c l IH
state_before: case H₃
a b c : Ordinal
ba : b + a = a
⊢ ∀ (o : Ordinal),
    IsLimit o → (∀ (o' : Ordinal), o' < o → (a + b) * succ o' = a * succ o' + b) → (a + b) * succ o = a * succ o + b

tactic: rw [mul_succ, add_mul_limit_aux ba l IH, mul_succ, add_assoc]
state_before: case H₃
a b c✝ : Ordinal
ba : b + a = a
c : Ordinal
l : IsLimit c
IH : ∀ (o' : Ordinal), o' < c → (a + b) * succ o' = a * succ o' + b
⊢ (a + b) * succ c = a * succ c + b
Theorem: Nat.eq_zero_of_add_eq_zero_right
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.zero_add]
state_before: m : Nat
⊢ 0 + m = 0 → 0 = 0

tactic: rw [add_one, succ_add] at h
state_before: n m : Nat
h : n + 1 + m = 0
⊢ n + 1 = 0

tactic: cases succ_ne_zero _ h
state_before: n m : Nat
h : succ (n + m) = 0
⊢ n + 1 = 0
Theorem: Multiset.bind_singleton
File: Mathlib/Data/Multiset/Bind.lean

tactic: rw [zero_bind, map_zero]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.18111
δ : Type ?u.18114
a : α
s t : Multiset α
f✝ g : α → Multiset β
f : α → β
⊢ (bind 0 fun x => {f x}) = map f 0

tactic: simp [singleton_add]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.18111
δ : Type ?u.18114
a : α
s t : Multiset α
f✝ g : α → Multiset β
f : α → β
⊢ ∀ ⦃a : α⦄ {s : Multiset α}, (bind s fun x => {f x}) = map f s → (bind (a ::ₘ s) fun x => {f x}) = map f (a ::ₘ s)
Theorem: Basis.reindex_refl
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp
state_before: ι : Type u_1
ι' : Type ?u.368486
R : Type u_2
R₂ : Type ?u.368492
K : Type ?u.368495
M : Type u_3
M' : Type ?u.368501
M'' : Type ?u.368504
V : Type u
V' : Type ?u.368509
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
i : ι
⊢ ↑(reindex b (Equiv.refl ι)) i = ↑b i
Theorem: MeasureTheory.measurePreserving_finTwoArrow
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: simpa only [Matrix.vec_single_eq_const, Matrix.vecCons_const] using
  measurePreserving_finTwoArrow_vec μ μ
state_before: ι : Type ?u.6010588
ι' : Type ?u.6010591
α✝ : ι → Type ?u.6010596
inst✝¹ : Fintype ι
m✝ : (i : ι) → OuterMeasure (α✝ i)
α : Type u
m : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
⊢ MeasurePreserving ↑MeasurableEquiv.finTwoArrow
Theorem: Monotone.csInf_image_le
File: Mathlib/Order/ConditionallyCompleteLattice/Basic.lean

tactic: let f' : αᵒᵈ → βᵒᵈ := f
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.97518
ι : Sort ?u.97521
inst✝¹ : Preorder α
inst✝ : ConditionallyCompleteLattice β
f : α → β
h_mono : Monotone f
s : Set α
c : α
hcs : c ∈ s
h_bdd : BddBelow s
⊢ sInf (f '' s) ≤ f c

tactic: exact @le_csSup_image αᵒᵈ βᵒᵈ _ _ _
  (show Monotone f' from fun x y hxy => h_mono hxy) _ _ hcs h_bdd
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.97518
ι : Sort ?u.97521
inst✝¹ : Preorder α
inst✝ : ConditionallyCompleteLattice β
f : α → β
h_mono : Monotone f
s : Set α
c : α
hcs : c ∈ s
h_bdd : BddBelow s
f' : αᵒᵈ → βᵒᵈ := f
⊢ sInf (f '' s) ≤ f c
Theorem: Ideal.span_mul_span'
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: unfold span
state_before: R : Type u
ι : Type ?u.222969
inst✝ : CommSemiring R
I J K L : Ideal R
S T : Set R
⊢ span S * span T = span (S * T)

tactic: rw [Submodule.span_mul_span]
state_before: R : Type u
ι : Type ?u.222969
inst✝ : CommSemiring R
I J K L : Ideal R
S T : Set R
⊢ Submodule.span R S * Submodule.span R T = Submodule.span R (S * T)
Theorem: Equiv.Perm.fst_prodExtendRight
File: Mathlib/Logic/Equiv/Basic.lean

tactic: rw [prodExtendRight]
state_before: α₁ : Type u_1
β₁ : Type u_2
inst✝ : DecidableEq α₁
a : α₁
e : Perm β₁
ab : α₁ × β₁
⊢ (↑(prodExtendRight a e) ab).fst = ab.fst

tactic: dsimp
state_before: α₁ : Type u_1
β₁ : Type u_2
inst✝ : DecidableEq α₁
a : α₁
e : Perm β₁
ab : α₁ × β₁
⊢ (↑{ toFun := fun ab => if ab.fst = a then (a, ↑e ab.snd) else ab,
            invFun := fun ab => if ab.fst = a then (a, ↑e.symm ab.snd) else ab,
            left_inv :=
              (_ :
                ∀ (x : α₁ × β₁),
                  (fun ab => if ab.fst = a then (a, ↑e.symm ab.snd) else ab)
                      ((fun ab => if ab.fst = a then (a, ↑e ab.snd) else ab) x) =
                    x),
            right_inv :=
              (_ :
                ∀ (x : α₁ × β₁),
                  (fun ab => if ab.fst = a then (a, ↑e ab.snd) else ab)
                      ((fun ab => if ab.fst = a then (a, ↑e.symm ab.snd) else ab) x) =
                    x) }
        ab).fst =
    ab.fst

tactic: split_ifs with h
state_before: α₁ : Type u_1
β₁ : Type u_2
inst✝ : DecidableEq α₁
a : α₁
e : Perm β₁
ab : α₁ × β₁
⊢ (if ab.fst = a then (a, ↑e ab.snd) else ab).fst = ab.fst

tactic: rw [h]
state_before: case inl
α₁ : Type u_1
β₁ : Type u_2
inst✝ : DecidableEq α₁
a : α₁
e : Perm β₁
ab : α₁ × β₁
h : ab.fst = a
⊢ (a, ↑e ab.snd).fst = ab.fst

tactic: rfl
state_before: case inr
α₁ : Type u_1
β₁ : Type u_2
inst✝ : DecidableEq α₁
a : α₁
e : Perm β₁
ab : α₁ × β₁
h : ¬ab.fst = a
⊢ ab.fst = ab.fst
Theorem: Trivialization.mk_coordChange
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: refine' Prod.ext _ rfl
state_before: ι : Type ?u.53743
B : Type u_1
F : Type u_2
E : B → Type ?u.53754
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ (b, coordChange e₁ e₂ b x) = ↑e₂ (↑(LocalHomeomorph.symm e₁.toLocalHomeomorph) (b, x))

tactic: rw [e₂.coe_fst', ← e₁.coe_fst', e₁.apply_symm_apply' h₁]
state_before: ι : Type ?u.53743
B : Type u_1
F : Type u_2
E : B → Type ?u.53754
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ (b, coordChange e₁ e₂ b x).fst = (↑e₂ (↑(LocalHomeomorph.symm e₁.toLocalHomeomorph) (b, x))).fst

tactic: rwa [e₁.proj_symm_apply' h₁]
state_before: ι : Type ?u.53743
B : Type u_1
F : Type u_2
E : B → Type ?u.53754
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ proj (↑(LocalHomeomorph.symm e₁.toLocalHomeomorph) (b, x)) ∈ e₁.baseSet

tactic: rwa [e₁.proj_symm_apply' h₁]
state_before: ι : Type ?u.53743
B : Type u_1
F : Type u_2
E : B → Type ?u.53754
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e : Trivialization F proj
x✝ : Z
e' : Trivialization F TotalSpace.proj
x' : TotalSpace E
b✝ : B
y : E b✝
e₁ e₂ : Trivialization F proj
b : B
h₁ : b ∈ e₁.baseSet
h₂ : b ∈ e₂.baseSet
x : F
⊢ proj (↑(LocalHomeomorph.symm e₁.toLocalHomeomorph) (b, x)) ∈ e₂.baseSet